diff --git a/base/base_tests/condition_test.cpp b/base/base_tests/condition_test.cpp
index 3bd28b0d34..d745c8dbd9 100644
--- a/base/base_tests/condition_test.cpp
+++ b/base/base_tests/condition_test.cpp
@@ -25,10 +25,10 @@ UNIT_TEST(Condition_Test)
   ThreadedList<int> l;
 
   threads::Thread t0;
-  t0.Create(new ConditionThread(&l));
+  t0.Create(make_unique<ConditionThread>(&l));
 
   threads::Thread t1;
-  t1.Create(new ConditionThread(&l));
+  t1.Create(make_unique<ConditionThread>(&l));
 
   l.Cancel();
   t0.Join();
diff --git a/base/base_tests/threaded_list_test.cpp b/base/base_tests/threaded_list_test.cpp
index 1be89655c5..c7c34bc5a5 100644
--- a/base/base_tests/threaded_list_test.cpp
+++ b/base/base_tests/threaded_list_test.cpp
@@ -76,13 +76,13 @@ UNIT_TEST(ThreadedList)
   ThreadedList<int> p;
 
   threads::Thread t0;
-  t0.Create(new ThreadedListProcessor(p, resMutex, res, 0));
+  t0.Create(make_unique<ThreadedListProcessor>(p, resMutex, res, 0));
 
   threads::Thread t1;
-  t1.Create(new ThreadedListProcessor(p, resMutex, res, 1));
+  t1.Create(make_unique<ThreadedListProcessor>(p, resMutex, res, 1));
 
   threads::Thread t2;
-  t2.Create(new ThreadedListProcessor(p, resMutex, res, 2));
+  t2.Create(make_unique<ThreadedListProcessor>(p, resMutex, res, 2));
 
   p.PushBack(0);
   threads::Sleep(200);
@@ -115,13 +115,13 @@ UNIT_TEST(ThreadedPriorityQueue)
   ThreadedPriorityQueue<int> p;
 
   threads::Thread t0;
-  t0.Create(new ThreadedPriorityQueueProcessor(p, resMutex, res, 0));
+  t0.Create(make_unique<ThreadedPriorityQueueProcessor>(p, resMutex, res, 0));
 
   threads::Thread t1;
-  t1.Create(new ThreadedPriorityQueueProcessor(p, resMutex, res, 1));
+  t1.Create(make_unique<ThreadedPriorityQueueProcessor>(p, resMutex, res, 1));
 
   threads::Thread t2;
-  t2.Create(new ThreadedPriorityQueueProcessor(p, resMutex, res, 2));
+  t2.Create(make_unique<ThreadedPriorityQueueProcessor>(p, resMutex, res, 2));
 
   p.Push(0);
   threads::Sleep(200);
diff --git a/base/base_tests/threads_test.cpp b/base/base_tests/threads_test.cpp
index b81c583531..51e8ba64a7 100644
--- a/base/base_tests/threads_test.cpp
+++ b/base/base_tests/threads_test.cpp
@@ -44,13 +44,13 @@ UNIT_TEST(Simple_Threads)
   Vector vec;
 
   threads::Thread reader;
-  bool ok = reader.Create(new GeneratorThread(vec));
+  bool ok = reader.Create(make_unique<GeneratorThread>(vec));
   TEST( ok, ("Create Generator thread") );
 
   reader.Join();
 
   threads::Thread writer;
-  ok = writer.Create(new ReaderThread(vec));
+  ok = writer.Create(make_unique<ReaderThread>(vec));
   TEST( ok, ("Create Reader thread") );
 
   writer.Join();
diff --git a/base/commands_queue.cpp b/base/commands_queue.cpp
index 881c41cc50..94df6b1b86 100644
--- a/base/commands_queue.cpp
+++ b/base/commands_queue.cpp
@@ -121,25 +121,20 @@ namespace core
     m_env.Cancel();
   }
 
-  CommandsQueue::Executor::Executor() : m_routine(0)
-  {}
-
   void CommandsQueue::Executor::Cancel()
   {
-    if (m_routine != 0)
+    if (m_thread.GetRoutine())
       m_thread.Cancel();
-    delete m_routine;
-    m_routine = 0;
   }
 
   void CommandsQueue::Executor::CancelCommand()
   {
-    m_routine->CancelCommand();
+    Routine * routine = m_thread.GetRoutineAs<Routine>();
+    routine->CancelCommand();
   }
 
   CommandsQueue::CommandsQueue(size_t executorsCount)
-    : m_executors(new Executor[executorsCount]), m_executorsCount(executorsCount),
-      m_activeCommands(0)
+      : m_executors(executorsCount), m_activeCommands(0)
   {
   }
 
@@ -153,26 +148,21 @@ namespace core
   {
     m_commands.Cancel();
 
-    for (size_t i = 0; i < m_executorsCount; ++i)
-      m_executors[i].Cancel();
-
-    delete [] m_executors;
-    m_executors = 0;
+    for (auto & executor : m_executors)
+      executor.Cancel();
+    m_executors.clear();
   }
 
   void CommandsQueue::CancelCommands()
   {
-    for (size_t i = 0; i < m_executorsCount; ++i)
-      m_executors[i].CancelCommand();
+    for (auto & executor : m_executors)
+      executor.CancelCommand();
   }
 
   void CommandsQueue::Start()
   {
-    for (size_t i = 0; i < m_executorsCount; ++i)
-    {
-      m_executors[i].m_routine = new CommandsQueue::Routine(this, i);
-      m_executors[i].m_thread.Create(m_executors[i].m_routine);
-    }
+    for (size_t i = 0; i < m_executors.size(); ++i)
+      m_executors[i].m_thread.Create(make_unique<Routine>(this, i));
   }
 
   void CommandsQueue::AddCommand(shared_ptr<Command> const & cmd)
@@ -232,11 +222,14 @@ namespace core
     /// to prevent the situation when Executor could start processing some command
     /// between "operation A" and "operation B" which could lead to underflow of m_activeCommands
 
-    m_commands.ProcessList([this] (list<shared_ptr<CommandsQueue::Command> > & l) { ClearImpl(l); });
+    m_commands.ProcessList([this](list<shared_ptr<CommandsQueue::Command> > & l)
+                           {
+                             ClearImpl(l);
+                           });
   }
 
   size_t CommandsQueue::ExecutorsCount() const
   {
-    return m_executorsCount;
+    return m_executors.size();
   }
 }
diff --git a/base/commands_queue.hpp b/base/commands_queue.hpp
index a8d68b258d..50326ce99b 100644
--- a/base/commands_queue.hpp
+++ b/base/commands_queue.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "../std/function.hpp"
-#include "../std/vector.hpp"
 #include "../std/shared_ptr.hpp"
+#include "../std/vector.hpp"
 
 #include "cancellable.hpp"
 #include "thread.hpp"
@@ -15,11 +15,9 @@ namespace core
   class CommandsQueue
   {
   private:
-
     class Routine;
 
   public:
-
     struct Command;
 
     /// execution environment for single command
@@ -68,11 +66,9 @@ namespace core
     struct Chain
     {
     private:
-
       list<function_t> m_fns;
 
     public:
-
       Chain();
 
       Chain(function_t const & fn)
@@ -94,11 +90,9 @@ namespace core
     struct Command : BaseCommand
     {
     private:
-
       function_t m_fn;
 
     public:
-
       Command(bool isWaitable = false);
 
       template <typename tt>
@@ -110,21 +104,20 @@ namespace core
     };
 
   private:
-
     /// single execution routine
     class Routine : public threads::IRoutine
     {
     private:
-
       CommandsQueue * m_parent;
       Environment m_env;
 
     public:
-
       Routine(CommandsQueue * parent, size_t idx);
 
-      void Do();
-      void Cancel();
+      /// threads::IRoutine overrides:
+      void Do() override;
+      void Cancel() override;
+
       void CancelCommand();
     };
 
@@ -132,14 +125,12 @@ namespace core
     struct Executor
     {
       threads::Thread m_thread;
-      Routine * m_routine;
-      Executor();
+
       void Cancel();
       void CancelCommand();
     };
 
-    Executor * m_executors;
-    size_t m_executorsCount;
+    vector<Executor> m_executors;
     ThreadedList<shared_ptr<Command> > m_commands;
 
     list<shared_ptr<Command> > m_initCommands;
@@ -158,7 +149,6 @@ namespace core
     void ClearImpl(list<shared_ptr<Command> > & l);
 
   public:
-
     CommandsQueue(size_t executorsCount);
     ~CommandsQueue();
 
diff --git a/base/scheduled_task.cpp b/base/scheduled_task.cpp
index 6042fc559f..1400909db9 100644
--- a/base/scheduled_task.cpp
+++ b/base/scheduled_task.cpp
@@ -1,48 +1,48 @@
 #include "scheduled_task.hpp"
 #include "timer.hpp"
 
+#include "../base/logging.hpp"
+
+#include "../std/algorithm.hpp"
+#include "../std/chrono.hpp"
+
 ScheduledTask::Routine::Routine(fn_t const & fn,
                                 unsigned ms,
-                                threads::Condition * cond)
+                                condition_variable & condVar)
   : m_fn(fn),
     m_ms(ms),
-    m_pCond(cond)
+    m_condVar(condVar)
 {}
 
 void ScheduledTask::Routine::Do()
 {
-  m_pCond->Lock();
+  unique_lock<mutex> lock(m_mutex);
 
-  unsigned msLeft = m_ms;
-
-  while (!IsCancelled())
+  milliseconds timeLeft(m_ms);
+  while (!IsCancelled() && timeLeft != milliseconds::zero())
   {
     my::Timer t;
-
-    if (m_pCond->Wait(msLeft))
-      break;
-
-    msLeft -= (unsigned)(t.ElapsedSeconds() * 1000);
+    m_condVar.wait_for(lock, timeLeft, [this]()
+                       {
+                         return IsCancelled();
+                       });
+    milliseconds timeElapsed(static_cast<unsigned>(t.ElapsedSeconds() * 1000));
+    timeLeft -= min(timeLeft, timeElapsed);
   }
 
   if (!IsCancelled())
     m_fn();
-
-  m_pCond->Unlock();
 }
 
 void ScheduledTask::Routine::Cancel()
 {
   threads::IRoutine::Cancel();
-
-  m_pCond->Signal();
-  m_pCond->Unlock();
+  m_condVar.notify_one();
 }
 
 ScheduledTask::ScheduledTask(fn_t const & fn, unsigned ms)
-  : m_routine(new Routine(fn, ms, &m_cond))
 {
-  m_thread.Create(m_routine.get());
+  m_thread.Create(make_unique<Routine>(fn, ms, m_condVar));
 }
 
 ScheduledTask::~ScheduledTask()
@@ -52,16 +52,13 @@ ScheduledTask::~ScheduledTask()
 
 bool ScheduledTask::CancelNoBlocking()
 {
-  if (m_cond.TryLock())
-  {
-    m_thread.Cancel();
-    return true;
-  }
-  return false;
+  if (!m_thread.GetRoutine())
+    return false;
+  m_thread.GetRoutine()->Cancel();
+  return true;
 }
 
 void ScheduledTask::CancelBlocking()
 {
-  m_cond.Lock();
   m_thread.Cancel();
 }
diff --git a/base/scheduled_task.hpp b/base/scheduled_task.hpp
index f7ab0b2040..99e5cbd303 100644
--- a/base/scheduled_task.hpp
+++ b/base/scheduled_task.hpp
@@ -1,12 +1,13 @@
 #pragma once
 
-#include "thread.hpp"
 #include "condition.hpp"
+#include "thread.hpp"
 
+#include "../std/condition_variable.hpp"
 #include "../std/function.hpp"
+#include "../std/mutex.hpp"
 #include "../std/unique_ptr.hpp"
 
-
 /// Class, which performs any function when the specified
 /// amount of time is elapsed.
 class ScheduledTask
@@ -17,19 +18,21 @@ class ScheduledTask
   {
     fn_t m_fn;
     unsigned m_ms;
-    threads::Condition * m_pCond;
+
+    condition_variable & m_condVar;
+    mutex m_mutex;
 
   public:
-    Routine(fn_t const & fn, unsigned ms, threads::Condition * cond);
+    Routine(fn_t const & fn, unsigned ms, condition_variable & condVar);
 
     virtual void Do();
     virtual void Cancel();
   };
 
   /// The construction and destruction order is strict here: m_cond is
-  /// used by m_routine and m_routine is used by m_thread.
-  threads::Condition m_cond;
-  unique_ptr<Routine> const m_routine;
+  /// used by routine that will be executed on m_thread.
+  mutex m_mutex;
+  condition_variable m_condVar;
   threads::Thread m_thread;
 
 public:
diff --git a/base/thread.cpp b/base/thread.cpp
index f63d0ca068..111ae7ca73 100644
--- a/base/thread.cpp
+++ b/base/thread.cpp
@@ -1,5 +1,4 @@
 #include "thread.hpp"
-#include "assert.hpp"
 
 #include "../base/logging.hpp"
 
@@ -16,7 +15,7 @@ namespace threads
 namespace
 {
 /// Prepares worker thread and runs routine.
-void RunRoutine(IRoutine * routine)
+void RunRoutine(shared_ptr<IRoutine> routine)
 {
 #if defined(OMIM_OS_ANDROID)
   AndroidThreadAttachToJVM();
@@ -32,7 +31,6 @@ void RunRoutine(IRoutine * routine)
 
 /////////////////////////////////////////////////////////////////////
 // Thread wrapper implementation
-Thread::Thread() : m_routine(0) {}
 
 Thread::~Thread()
 {
@@ -45,21 +43,22 @@ Thread::~Thread()
     m_thread.detach();
 }
 
-bool Thread::Create(IRoutine * pRoutine)
+bool Thread::Create(unique_ptr<IRoutine> && routine)
 {
   ASSERT(!m_routine, ("Current implementation doesn't allow to reuse thread"));
   thread routineThread;
   try
   {
-    routineThread = thread(&RunRoutine, pRoutine);
+    m_routine.reset(routine.release());
+    routineThread = thread(&RunRoutine, m_routine);
   }
   catch (exception & e)
   {
     LOG(LERROR, ("Thread creation failed with error:", e.what()));
+    m_routine.reset();
     return false;
   }
   m_thread = move(routineThread);
-  m_routine = pRoutine;
   return true;
 }
 
@@ -69,6 +68,7 @@ void Thread::Cancel()
     return;
   m_routine->Cancel();
   Join();
+  m_routine.reset();
 }
 
 void Thread::Join()
@@ -77,35 +77,23 @@ void Thread::Join()
     m_thread.join();
 }
 
+IRoutine * Thread::GetRoutine() { return m_routine.get(); }
+
 SimpleThreadPool::SimpleThreadPool(size_t reserve) { m_pool.reserve(reserve); }
 
-SimpleThreadPool::~SimpleThreadPool()
+void SimpleThreadPool::Add(unique_ptr<IRoutine> && routine)
 {
-  for (size_t i = 0; i < m_pool.size(); ++i)
-  {
-    delete m_pool[i].first;
-    delete m_pool[i].second;
-  }
-}
-
-void SimpleThreadPool::Add(IRoutine * pRoutine)
-{
-  ValueT v;
-  v.first = new Thread();
-  v.second = pRoutine;
-
-  m_pool.push_back(v);
-
-  v.first->Create(pRoutine);
+  m_pool.emplace_back(new Thread());
+  m_pool.back()->Create(move(routine));
 }
 
 void SimpleThreadPool::Join()
 {
-  for (size_t i = 0; i < m_pool.size(); ++i)
-    m_pool[i].first->Join();
+  for (auto & thread : m_pool)
+    thread->Join();
 }
 
-IRoutine * SimpleThreadPool::GetRoutine(size_t i) const { return m_pool[i].second; }
+IRoutine * SimpleThreadPool::GetRoutine(size_t i) const { return m_pool[i]->GetRoutine(); }
 
 void Sleep(size_t ms) { this_thread::sleep_for(milliseconds(ms)); }
 
diff --git a/base/thread.hpp b/base/thread.hpp
index 2ad31809a7..65dba1161f 100644
--- a/base/thread.hpp
+++ b/base/thread.hpp
@@ -1,11 +1,13 @@
 #pragma once
 
+#include "../base/assert.hpp"
 #include "../base/cancellable.hpp"
 #include "../base/macros.hpp"
 
 #include "../std/target_os.hpp"
 
 #include "../std/noncopyable.hpp"
+#include "../std/shared_ptr.hpp"
 #include "../std/stdint.hpp"
 #include "../std/thread.hpp"
 #include "../std/unique_ptr.hpp"
@@ -21,46 +23,63 @@ namespace threads
 class IRoutine : public my::Cancellable
 {
 public:
-  /// Performing the main task
+  /// Perform the main task.
   virtual void Do() = 0;
 };
 
-/// wrapper for Create and Terminate threads API
+/// A wrapper for system threads API.
+///
+/// Thread class manages lifetime of a running IRoutine and guarantees
+/// that it will be possible to access the IRoutine after
+/// Thread::Create()call until destruction of a Thread object.  In the
+/// latter case, system thread will be responsible for deletion of a
+/// IRoutine.
 class Thread
 {
   thread m_thread;
-  IRoutine * m_routine;
+  shared_ptr<IRoutine> m_routine;
 
 public:
-  Thread();
-
   ~Thread();
 
   /// Run thread immediately.
-  /// @param pRoutine is owned by Thread class
-  bool Create(IRoutine * pRoutine);
+  /// @param routine Routine that will be executed on m_thread and destroyed by
+  ///                the current Thread instance or by the m_thread, if
+  ///                it will be detached during the execution of routine.
+  bool Create(unique_ptr<IRoutine> && routine);
 
-  /// Calling the IRoutine::Cancel method, and Join'ing with the task execution.
+  /// Calling the IRoutine::Cancel method, and Join'ing with the task
+  /// execution.  After that, routine is deleted.
   void Cancel();
 
   /// Wait for thread ending.
   void Join();
 
-private:
-  DISALLOW_COPY_AND_MOVE(Thread);
+  /// \return Pointer to the routine.
+  IRoutine * GetRoutine();
+
+  /// \return Pointer to the routine converted to T *.  When it's not
+  ///         possible to convert routine to the T *, release version
+  ///         returns nullptr, debug version fails.
+  template <typename T>
+  T * GetRoutineAs()
+  {
+    ASSERT(m_routine.get(), ("Routine is not set"));
+    T * ptr = dynamic_cast<T *>(m_routine.get());
+    ASSERT(ptr, ("Can't convert IRoutine* to", TO_STRING(T) "*"));
+    return ptr;
+  }
 };
 
 /// Simple threads container. Takes ownership for every added IRoutine.
 class SimpleThreadPool : public noncopyable
 {
-  typedef pair<Thread *, IRoutine *> ValueT;
-  vector<ValueT> m_pool;
+  vector<unique_ptr<Thread>> m_pool;
 
 public:
   SimpleThreadPool(size_t reserve = 0);
-  ~SimpleThreadPool();
 
-  void Add(IRoutine * pRoutine);
+  void Add(unique_ptr<IRoutine> && routine);
   void Join();
 
   IRoutine * GetRoutine(size_t i) const;
diff --git a/base/thread_pool.cpp b/base/thread_pool.cpp
index 06271ccc54..e546c54dc6 100644
--- a/base/thread_pool.cpp
+++ b/base/thread_pool.cpp
@@ -11,11 +11,12 @@ namespace threads
 {
   namespace
   {
-    typedef function<threads::IRoutine * ()> pop_routine_fn;
+    typedef function<threads::IRoutine *()> TPopRoutineFn;
+
     class PoolRoutine : public IRoutine
     {
     public:
-      PoolRoutine(const pop_routine_fn & popFn, const finish_routine_fn & finishFn)
+      PoolRoutine(const TPopRoutineFn & popFn, const TFinishRoutineFn & finishFn)
         : m_popFn(popFn)
         , m_finishFn(finishFn)
       {
@@ -39,24 +40,20 @@ namespace threads
       }
 
     private:
-      pop_routine_fn m_popFn;
-      finish_routine_fn m_finishFn;
+      TPopRoutineFn m_popFn;
+      TFinishRoutineFn m_finishFn;
     };
   }
 
   class ThreadPool::Impl
   {
   public:
-    Impl(size_t size, const finish_routine_fn & finishFn)
-      : m_finishFn(finishFn)
+    Impl(size_t size, const TFinishRoutineFn & finishFn) : m_finishFn(finishFn), m_threads(size)
     {
-      m_threads.resize(size);
-      for (size_t i = 0; i < size; ++i)
+      for (auto & thread : m_threads)
       {
-        thread_info_t info = make_pair(new threads::Thread(), new PoolRoutine(bind(&ThreadPool::Impl::PopFront, this),
-                                                                              m_finishFn));
-        info.first->Create(info.second);
-        m_threads[i] = info;
+        thread.reset(new threads::Thread());
+        thread->Create(make_unique<PoolRoutine>(bind(&ThreadPool::Impl::PopFront, this), m_finishFn));
       }
     }
 
@@ -84,18 +81,14 @@ namespace threads
     {
       m_tasks.Cancel();
 
-      for (size_t i = 0; i < m_threads.size(); ++i)
-        m_threads[i].second->Cancel();
-
-      for (size_t i = 0; i < m_threads.size(); ++i)
-      {
-        m_threads[i].first->Cancel();
-        delete m_threads[i].second;
-        delete m_threads[i].first;
-      }
-
+      for (auto & thread : m_threads)
+        thread->Cancel();
       m_threads.clear();
-      m_tasks.ProcessList([this] (list<threads::IRoutine *> & tasks) { FinishTasksOnStop(tasks); });
+
+      m_tasks.ProcessList([this](list<threads::IRoutine *> & tasks)
+                          {
+                            FinishTasksOnStop(tasks);
+                          });
       m_tasks.Clear();
     }
 
@@ -112,13 +105,12 @@ namespace threads
 
   private:
     ThreadedList<threads::IRoutine *> m_tasks;
-    finish_routine_fn m_finishFn;
+    TFinishRoutineFn m_finishFn;
 
-    typedef pair<threads::Thread *, threads::IRoutine *> thread_info_t;
-    vector<thread_info_t> m_threads;
+    vector<unique_ptr<threads::Thread>> m_threads;
   };
 
-  ThreadPool::ThreadPool(size_t size, const finish_routine_fn & finishFn)
+  ThreadPool::ThreadPool(size_t size, const TFinishRoutineFn & finishFn)
     : m_impl(new Impl(size, finishFn)) {}
 
   ThreadPool::~ThreadPool()
diff --git a/base/thread_pool.hpp b/base/thread_pool.hpp
index 2de3f5dc67..58ac247ff6 100644
--- a/base/thread_pool.hpp
+++ b/base/thread_pool.hpp
@@ -8,12 +8,12 @@ namespace threads
 {
   class IRoutine;
 
-  typedef function<void (threads::IRoutine *)> finish_routine_fn;
+  typedef function<void(threads::IRoutine *)> TFinishRoutineFn;
 
   class ThreadPool
   {
   public:
-    ThreadPool(size_t size, const finish_routine_fn & finishFn);
+    ThreadPool(size_t size, const TFinishRoutineFn & finishFn);
     ~ThreadPool();
 
     // ThreadPool will not delete routine. You can delete it in finish_routine_fn if need
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index de19ea017c..d620e4c8fc 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -86,28 +86,16 @@ void BackendRenderer::AcceptMessage(dp::RefPointer<Message> message)
 /////////////////////////////////////////
 void BackendRenderer::StartThread()
 {
-  m_selfThread.Create(this);
+  m_selfThread.Create(make_unique<Routine>(*this));
 }
 
 void BackendRenderer::StopThread()
 {
-  IRoutine::Cancel();
+  m_selfThread.GetRoutine()->Cancel();
   CloseQueue();
   m_selfThread.Join();
 }
 
-void BackendRenderer::ThreadMain()
-{
-  m_contextFactory->getResourcesUploadContext()->makeCurrent();
-
-  InitGLDependentResource();
-
-  while (!IsCancelled())
-    ProcessSingleMessage();
-
-  ReleaseResources();
-}
-
 void BackendRenderer::ReleaseResources()
 {
   m_readManager->Stop();
@@ -119,9 +107,17 @@ void BackendRenderer::ReleaseResources()
   m_textures.Destroy();
 }
 
-void BackendRenderer::Do()
+BackendRenderer::Routine::Routine(BackendRenderer & renderer) : m_renderer(renderer) {}
+
+void BackendRenderer::Routine::Do()
 {
-  ThreadMain();
+  m_renderer.m_contextFactory->getResourcesUploadContext()->makeCurrent();
+  m_renderer.InitGLDependentResource();
+
+  while (!IsCancelled())
+    m_renderer.ProcessSingleMessage();
+
+  m_renderer.ReleaseResources();
 }
 
 void BackendRenderer::InitGLDependentResource()
diff --git a/drape_frontend/backend_renderer.hpp b/drape_frontend/backend_renderer.hpp
index 4a85778498..562ee120b2 100644
--- a/drape_frontend/backend_renderer.hpp
+++ b/drape_frontend/backend_renderer.hpp
@@ -25,15 +25,14 @@ class ThreadsCommutator;
 class BatchersPool;
 class ReadManager;
 
-class BackendRenderer : public MessageAcceptor,
-                        public threads::IRoutine
+class BackendRenderer : public MessageAcceptor
 {
 public:
   BackendRenderer(dp::RefPointer<ThreadsCommutator> commutator,
                   dp::RefPointer<dp::OGLContextFactory> oglcontextfactory,
                   MapDataProvider const & model);
 
-  ~BackendRenderer();
+  ~BackendRenderer() override;
 
 private:
   MapDataProvider m_model;
@@ -51,11 +50,21 @@ private:
     //             ThreadPart              //
     /////////////////////////////////////////
 private:
+  class Routine : public threads::IRoutine
+  {
+   public:
+    Routine(BackendRenderer & renderer);
+
+    // threads::IRoutine overrides:
+    void Do() override;
+
+   private:
+    BackendRenderer & m_renderer;
+  };
+
   void StartThread();
   void StopThread();
-  void ThreadMain();
   void ReleaseResources();
-  virtual void Do();
 
   void InitGLDependentResource();
   void FlushGeometry(dp::TransferPointer<Message> message);
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index aaadba48ef..fbbc1ba2d2 100644
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -303,29 +303,32 @@ set<TileKey> & FrontendRenderer::GetTileKeyStorage()
 
 void FrontendRenderer::StartThread()
 {
-  m_selfThread.Create(this);
+  m_selfThread.Create(make_unique<Routine>(*this));
 }
 
 void FrontendRenderer::StopThread()
 {
-  IRoutine::Cancel();
+  m_selfThread.GetRoutine()->Cancel();
   CloseQueue();
   m_selfThread.Join();
 }
 
-void FrontendRenderer::ThreadMain()
+FrontendRenderer::Routine::Routine(FrontendRenderer & renderer) : m_renderer(renderer) {}
+
+void FrontendRenderer::Routine::Do()
 {
-  dp::OGLContext * context = m_contextFactory->getDrawContext();
+  dp::OGLContext * context = m_renderer.m_contextFactory->getDrawContext();
   context->makeCurrent();
 
   my::Timer timer;
-  //double processingTime = InitAvarageTimePerMessage; // By init we think that one message processed by 1ms
+  // double processingTime = InitAvarageTimePerMessage; // By init we think that one message
+  // processed by 1ms
 
   timer.Reset();
   while (!IsCancelled())
   {
     context->setDefaultFramebuffer();
-    RenderScene();
+    m_renderer.RenderScene();
 
     double availableTime = VSyncInterval - (timer.ElapsedSeconds() /*+ avarageMessageTime*/);
 
@@ -334,18 +337,18 @@ void FrontendRenderer::ThreadMain()
 
     while (availableTime > 0)
     {
-      ProcessSingleMessage(availableTime * 1000.0);
+      m_renderer.ProcessSingleMessage(availableTime * 1000.0);
       availableTime = VSyncInterval - (timer.ElapsedSeconds() /*+ avarageMessageTime*/);
-      //messageCount++;
+      // messageCount++;
     }
 
-    //processingTime = (timer.ElapsedSeconds() - processingTime) / messageCount;
+    // processingTime = (timer.ElapsedSeconds() - processingTime) / messageCount;
 
     context->present();
     timer.Reset();
   }
 
-  ReleaseResources();
+  m_renderer.ReleaseResources();
 }
 
 void FrontendRenderer::ReleaseResources()
@@ -354,11 +357,6 @@ void FrontendRenderer::ReleaseResources()
   m_gpuProgramManager.Destroy();
 }
 
-void FrontendRenderer::Do()
-{
-  ThreadMain();
-}
-
 void FrontendRenderer::DeleteRenderData()
 {
   (void)GetRangeDeletor(m_renderGroups, DeleteFunctor())();
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 33b6360bc4..19504da46a 100644
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -32,15 +32,14 @@ namespace dp { class RenderBucket; }
 namespace df
 {
 
-class FrontendRenderer : public MessageAcceptor,
-                         public threads::IRoutine
+class FrontendRenderer : public MessageAcceptor
 {
 public:
   FrontendRenderer(dp::RefPointer<ThreadsCommutator> commutator,
                    dp::RefPointer<dp::OGLContextFactory> oglcontextfactory,
                    Viewport viewport);
 
-  ~FrontendRenderer();
+  ~FrontendRenderer() override;
 
 #ifdef DRAW_INFO
   double m_tpf;
@@ -71,13 +70,22 @@ private:
   void InvalidateRenderGroups(set<TileKey> & keyStorage);
 
 private:
+  class Routine : public threads::IRoutine
+  {
+   public:
+    Routine(FrontendRenderer & renderer);
+
+    // threads::IRoutine overrides:
+    void Do() override;
+
+   private:
+    FrontendRenderer & m_renderer;
+  };
+
   void StartThread();
   void StopThread();
-  void ThreadMain();
   void ReleaseResources();
 
-  virtual void Do();
-
 private:
   void DeleteRenderData();
 
diff --git a/drape_frontend/message_acceptor.hpp b/drape_frontend/message_acceptor.hpp
index 99360d727f..56b6dfa6a0 100644
--- a/drape_frontend/message_acceptor.hpp
+++ b/drape_frontend/message_acceptor.hpp
@@ -11,6 +11,9 @@ class Message;
 
 class MessageAcceptor
 {
+public:
+  virtual ~MessageAcceptor() {}
+
 protected:
   virtual void AcceptMessage(dp::RefPointer<Message> message) = 0;
 
diff --git a/map/benchmark_engine.cpp b/map/benchmark_engine.cpp
index 3f7863b931..50598c3493 100644
--- a/map/benchmark_engine.cpp
+++ b/map/benchmark_engine.cpp
@@ -243,29 +243,31 @@ bool BenchmarkEngine::NextBenchmarkCommand()
 
 void BenchmarkEngine::Start()
 {
-  m_thread.Create(this);
+  m_thread.Create(make_unique<Routine>(*this));
 }
 
-void BenchmarkEngine::Do()
+BenchmarkEngine::Routine::Routine(BenchmarkEngine & engine) : m_engine(engine) {}
+
+void BenchmarkEngine::Routine::Do()
 {
-  PrepareMaps();
+  m_engine.PrepareMaps();
 
   int benchMarkCount = 1;
   (void) Settings::Get("BenchmarkCyclesCount", benchMarkCount);
 
   for (int i = 0; i < benchMarkCount; ++i)
   {
-    DoGetBenchmarks doGet(*this);
+    DoGetBenchmarks doGet(m_engine);
     ForEachBenchmarkRecord(doGet);
 
-    m_curBenchmark = 0;
+    m_engine.m_curBenchmark = 0;
 
-    m_benchmarksTimer.Reset();
-    m_startTime = my::FormatCurrentTime();
+    m_engine.m_benchmarksTimer.Reset();
+    m_engine.m_startTime = my::FormatCurrentTime();
 
-    MarkBenchmarkResultsStart();
-    while (NextBenchmarkCommand()){};
+    m_engine.MarkBenchmarkResultsStart();
+    while (m_engine.NextBenchmarkCommand()){};
 
-    m_benchmarks.clear();
+    m_engine.m_benchmarks.clear();
   }
 }
diff --git a/map/benchmark_engine.hpp b/map/benchmark_engine.hpp
index 08e5354f83..357a778751 100644
--- a/map/benchmark_engine.hpp
+++ b/map/benchmark_engine.hpp
@@ -18,7 +18,7 @@ class Framework;
 /// - Feeds the Framework with the paint tasks he wants to performs
 /// - Wait until each tasks completion
 /// - Measure the time of each task and save the result
-class BenchmarkEngine : public threads::IRoutine
+class BenchmarkEngine
 {
   threads::Thread m_thread;
 
@@ -45,6 +45,18 @@ class BenchmarkEngine : public threads::IRoutine
     string m_name;
   };
 
+  class Routine : public threads::IRoutine
+  {
+   public:
+    Routine(BenchmarkEngine & engine);
+
+    // threads::IRoutine overrides:
+    void Do() override;
+
+   private:
+    BenchmarkEngine & m_engine;
+  };
+
   vector<Benchmark> m_benchmarks;
   size_t m_curBenchmark;
 
@@ -60,8 +72,6 @@ class BenchmarkEngine : public threads::IRoutine
 
   void PrepareMaps();
 
-  void Do();
-
   friend class DoGetBenchmarks;
 
 public:
diff --git a/map/mwm_tests/multithread_mwm_test.cpp b/map/mwm_tests/multithread_mwm_test.cpp
index 5d222ebbca..d4b0b4c609 100644
--- a/map/mwm_tests/multithread_mwm_test.cpp
+++ b/map/mwm_tests/multithread_mwm_test.cpp
@@ -79,7 +79,7 @@ namespace
     threads::SimpleThreadPool pool(count);
 
     for (size_t i = 0; i < count; ++i)
-      pool.Add(new FeaturesLoader(src));
+      pool.Add(make_unique<FeaturesLoader>(src));
 
     pool.Join();
   }
diff --git a/platform/platform_android.cpp b/platform/platform_android.cpp
index 90ece32cd0..957fb04bc4 100644
--- a/platform/platform_android.cpp
+++ b/platform/platform_android.cpp
@@ -256,26 +256,23 @@ Platform::EError Platform::MkDir(string const & dirName) const
 
 namespace
 {
-  class SelfDeleteRoutine : public threads::IRoutine
-  {
-    typedef Platform::TFunctor FnT;
-    FnT m_fn;
+class FunctorWrapper : public threads::IRoutine
+{
+  Platform::TFunctor m_fn;
 
-  public:
-    SelfDeleteRoutine(FnT const & fn) : m_fn(fn) {}
+public:
+  FunctorWrapper(Platform::TFunctor const & fn) : m_fn(fn) {}
 
-    virtual void Do()
-    {
-      m_fn();
-      delete this;
-    }
-  };
+  void Do() override { m_fn(); }
+};
 }
 
 void Platform::RunAsync(TFunctor const & fn, Priority p)
 {
   UNUSED_VALUE(p);
 
-  // We don't need to store thread handler in POSIX. Just create and run.
-  threads::Thread().Create(new SelfDeleteRoutine(fn));
+  // We don't need to store thread handler in POSIX, just create and
+  // run.  Unfortunately we can't use std::async() here since it
+  // doesn't attach to JVM threads.
+  threads::Thread().Create(make_unique<FunctorWrapper>(fn));
 }
diff --git a/platform/platform_tests/apk_test.cpp b/platform/platform_tests/apk_test.cpp
index 53d7e285f4..d0612e7ff7 100644
--- a/platform/platform_tests/apk_test.cpp
+++ b/platform/platform_tests/apk_test.cpp
@@ -111,7 +111,7 @@ UNIT_TEST(ApkReader_Multithreaded)
   threads::SimpleThreadPool pool(count);
 
   for (size_t i = 0; i < count; ++i)
-    pool.Add(new ApkTester(path));
+    pool.Add(make_unique<ApkTester>(path));
 
   pool.Join();
 
diff --git a/std/unique_ptr.hpp b/std/unique_ptr.hpp
index e0f9f2e16b..0d647a4df5 100644
--- a/std/unique_ptr.hpp
+++ b/std/unique_ptr.hpp
@@ -8,6 +8,14 @@
 #include <memory>
 using std::unique_ptr;
 
+/// @todo(y): replace this hand-written helper function by
+/// std::make_unique when it will be available.
+template <typename T, typename... Args>
+unique_ptr<T> make_unique(Args &&... args)
+{
+  return unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
 #ifdef DEBUG_NEW
 #define new DEBUG_NEW
 #endif