diff --git a/android/UnitTests/jni/mock.cpp b/android/UnitTests/jni/mock.cpp
index 8b65b31899..8fc72e3039 100644
--- a/android/UnitTests/jni/mock.cpp
+++ b/android/UnitTests/jni/mock.cpp
@@ -217,11 +217,6 @@ void AndroidThreadDetachFromJVM()
   LOG(LWARNING, ("AndroidThreadDetachFromJVM() is not implemented."));
 }
 
-void Platform::RunOnGuiThread(TFunctor const & fn)
-{
-  LOG(LWARNING, ("Platform::RunOnGuiThread() is not implemented."));
-}
-
 Platform::EConnectionType Platform::ConnectionStatus()
 {
   LOG(LWARNING, ("Platform::ConnectionStatus() is not implemented."));
diff --git a/android/jni/com/mapswithme/platform/GuiThread.cpp b/android/jni/com/mapswithme/platform/GuiThread.cpp
index c59ba05141..e3e5cd7275 100644
--- a/android/jni/com/mapswithme/platform/GuiThread.cpp
+++ b/android/jni/com/mapswithme/platform/GuiThread.cpp
@@ -30,19 +30,19 @@ void GuiThread::ProcessTask(jlong task)
   (*t)();
 }
 
-base::TaskLoop::TaskId GuiThread::Push(Task && task)
+base::TaskLoop::PushResult GuiThread::Push(Task && task)
 {
   // Pointer will be deleted in ProcessTask.
   auto t = new Task(std::move(task));
   jni::GetEnv()->CallVoidMethod(m_object, m_method, reinterpret_cast<jlong>(t));
-  return kIncorrectId;
+  return {true, kIncorrectId};
 }
 
-base::TaskLoop::TaskId GuiThread::Push(Task const & task)
+base::TaskLoop::PushResult GuiThread::Push(Task const & task)
 {
   // Pointer will be deleted in ProcessTask.
   auto t = new Task(task);
   jni::GetEnv()->CallVoidMethod(m_object, m_method, reinterpret_cast<jlong>(t));
-  return kIncorrectId;
+  return {true, kIncorrectId};
 }
 }  // namespace android
diff --git a/android/jni/com/mapswithme/platform/GuiThread.hpp b/android/jni/com/mapswithme/platform/GuiThread.hpp
index 3da822040b..d4cddd8420 100644
--- a/android/jni/com/mapswithme/platform/GuiThread.hpp
+++ b/android/jni/com/mapswithme/platform/GuiThread.hpp
@@ -15,8 +15,8 @@ public:
   static void ProcessTask(jlong task);
 
   // TaskLoop overrides:
-  TaskId Push(Task && task) override;
-  TaskId Push(Task const & task) override;
+  PushResult Push(Task && task) override;
+  PushResult Push(Task const & task) override;
 
 private:
   jobject m_object = nullptr;
diff --git a/android/jni/com/mapswithme/platform/Platform.cpp b/android/jni/com/mapswithme/platform/Platform.cpp
index 9fd5c27f6e..af2ebd288c 100644
--- a/android/jni/com/mapswithme/platform/Platform.cpp
+++ b/android/jni/com/mapswithme/platform/Platform.cpp
@@ -103,16 +103,6 @@ std::string Platform::DeviceModel() const
   return jni::ToNativeString(env, deviceModel);
 }
 
-void Platform::RunOnGuiThread(base::TaskLoop::Task && task)
-{
-  android::Platform::Instance().RunOnGuiThread(std::move(task));
-}
-
-void Platform::RunOnGuiThread(base::TaskLoop::Task const & task)
-{
-  android::Platform::Instance().RunOnGuiThread(task);
-}
-
 Platform::EConnectionType Platform::ConnectionStatus()
 {
   JNIEnv * env = jni::GetEnv();
@@ -158,11 +148,6 @@ uint8_t Platform::GetBatteryLevel()
   return static_cast<uint8_t>(env->CallStaticIntMethod(clazzBatteryState, getLevelMethodId));
 }
 
-void Platform::SetGuiThread(std::unique_ptr<base::TaskLoop> guiThread)
-{
-  android::Platform::Instance().SetGuiThread(move(guiThread));
-}
-
 namespace platform
 {
 platform::NetworkPolicy GetCurrentNetworkPolicy()
@@ -310,11 +295,6 @@ void Platform::SendMarketingEvent(std::string const & tag,
                       jni::TScopedLocalObjectArrayRef(env, jni::ToKeyValueArray(env, params)).get());
 }
 
-void Platform::SetGuiThread(std::unique_ptr<base::TaskLoop> guiThread)
-{
-  m_guiThread = std::move(guiThread);
-}
-
 void Platform::AndroidSecureStorage::Init(JNIEnv * env)
 {
   if (m_secureStorageClass != nullptr)
diff --git a/android/jni/com/mapswithme/platform/Platform.hpp b/android/jni/com/mapswithme/platform/Platform.hpp
index e11e851cf3..27f1ddeae7 100644
--- a/android/jni/com/mapswithme/platform/Platform.hpp
+++ b/android/jni/com/mapswithme/platform/Platform.hpp
@@ -35,13 +35,6 @@ public:
 
   bool HasAvailableSpaceForWriting(uint64_t size) const;
 
-  template <typename Task>
-  void RunOnGuiThread(Task && task)
-  {
-    ASSERT(m_guiThread, ());
-    m_guiThread->Push(std::forward<Task>(task));
-  }
-
   void SendPushWooshTag(std::string const & tag, std::vector<std::string> const & values);
   void SendMarketingEvent(std::string const & tag, std::map<std::string, std::string> const & params);
 
@@ -71,8 +64,6 @@ private:
   jmethodID m_sendPushWooshTagsMethod = nullptr;
   jmethodID m_sendAppsFlyerTagsMethod = nullptr;
   AndroidSecureStorage m_secureStorage;
-
-  std::unique_ptr<base::TaskLoop> m_guiThread;
 };
 
 extern int GetAndroidSdkVersion();
diff --git a/base/base_tests/thread_pool_delayed_tests.cpp b/base/base_tests/thread_pool_delayed_tests.cpp
index f4ea43e97a..48dcc4df79 100644
--- a/base/base_tests/thread_pool_delayed_tests.cpp
+++ b/base/base_tests/thread_pool_delayed_tests.cpp
@@ -40,14 +40,25 @@ UNIT_TEST(ThreadPoolDelayed_SimpleSync)
   bool done = false;
 
   ThreadPool thread;
-  TEST_NOT_EQUAL(thread.Push([&value]() { ++value; }), ThreadPool::kIncorrectId,  ());
-  TEST_NOT_EQUAL(thread.Push([&value]() { value *= 2; }), ThreadPool::kIncorrectId, ());
-  TEST_NOT_EQUAL(thread.Push([&value]() { value = value * value * value; }), ThreadPool::kIncorrectId, ());
-  TEST_NOT_EQUAL(thread.Push([&]() {
+  auto pushResult = thread.Push([&value]() { ++value; });
+  TEST(pushResult.m_isSuccess, ());
+  TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
+
+  pushResult = thread.Push([&value]() { value *= 2; });
+  TEST(pushResult.m_isSuccess, ());
+  TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
+
+  pushResult = thread.Push([&value]() { value = value * value * value; });
+  TEST(pushResult.m_isSuccess, ());
+  TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
+
+  pushResult = thread.Push([&]() {
     lock_guard<mutex> lk(mu);
     done = true;
     cv.notify_one();
-  }), ThreadPool::kIncorrectId, ());
+  });
+  TEST(pushResult.m_isSuccess, ());
+  TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
 
   {
     unique_lock<mutex> lk(mu);
@@ -62,11 +73,17 @@ UNIT_TEST(ThreadPoolDelayed_SimpleFlush)
   int value = 0;
   {
     ThreadPool thread;
-    TEST_NOT_EQUAL(thread.Push([&value]() { ++value; }), ThreadPool::kIncorrectId, ());
-    TEST_NOT_EQUAL(thread.Push([&value]() {
+    auto pushResult = thread.Push([&value]() { ++value; });
+    TEST(pushResult.m_isSuccess, ());
+    TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
+
+    pushResult = thread.Push([&value]() {
       for (int i = 0; i < 10; ++i)
         value *= 2;
-    }), ThreadPool::kIncorrectId, ());
+    });
+    TEST(pushResult.m_isSuccess, ());
+    TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
+
     TEST(thread.Shutdown(ThreadPool::Exit::ExecPending), ());
   }
   TEST_EQUAL(value, 1024, ());
@@ -80,12 +97,15 @@ UNIT_TEST(ThreadPoolDelayed_PushFromPendingTask)
   auto f = p.get_future();
 
   ThreadPool thread;
-  auto const id = thread.Push([&f, &thread]() {
+  auto const pushResult = thread.Push([&f, &thread]() {
     f.get();
-    auto const id = thread.Push([]() { TEST(false, ("This task should not be executed")); });
-    TEST_EQUAL(id, ThreadPool::kIncorrectId, ());
+    auto const pushResult = thread.Push([]() { TEST(false, ("This task should not be executed")); });
+    TEST(!pushResult.m_isSuccess, ());
+    TEST_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
   });
-  TEST_NOT_EQUAL(id, ThreadPool::kIncorrectId, ());
+  TEST(pushResult.m_isSuccess, ());
+  TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
+
   thread.Shutdown(ThreadPool::Exit::ExecPending);
   p.set_value();
 }
@@ -112,15 +132,19 @@ UNIT_TEST(ThreadPoolDelayed_DelayedAndImmediateTasks)
       auto & entry = delayedEntries[i];
       entry.m_start = thread.Now();
       entry.m_delay = milliseconds(i + 1);
-      auto const id = thread.PushDelayed(entry.m_delay, [&]() { entry.m_end = thread.Now(); });
-      TEST_NOT_EQUAL(id, ThreadPool::kIncorrectId, ());
+
+      auto const pushResult = thread.PushDelayed(entry.m_delay, [&]() { entry.m_end = thread.Now(); });
+      TEST(pushResult.m_isSuccess, ());
+      TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
     }
 
     for (int i = 0; i < kNumTasks; ++i)
     {
       auto & entry = immediateEntries[i];
-      auto const id = thread.Push([&]() { entry = thread.Now(); });
-      TEST_NOT_EQUAL(id, ThreadPool::kIncorrectId, ());
+      auto const pushResult = thread.Push([&]() { entry = thread.Now(); });
+
+      TEST(pushResult.m_isSuccess, ());
+      TEST_NOT_EQUAL(pushResult.m_id, ThreadPool::kIncorrectId, ());
     }
 
     thread.Shutdown(ThreadPool::Exit::ExecPending);
@@ -147,23 +171,26 @@ UNIT_TEST(ThreadPoolDelayed_CancelImmediate)
     TaskLoop::TaskId cancelTaskId;
     ThreadPool thread;
     {
-      auto const id = thread.Push([&value]() {
+      auto const pushResult = thread.Push([&value]() {
         ++value;
         testing::Wait();
       });
-      TEST_EQUAL(id, ThreadPool::kImmediateMinId, ());
+      TEST(pushResult.m_isSuccess, ());
+      TEST_EQUAL(pushResult.m_id, ThreadPool::kImmediateMinId, ());
     }
 
     {
-      cancelTaskId = thread.Push([&]() { value += 1023; });
+      auto const pushResult = thread.Push([&]() { value += 1023; });
+      TEST(pushResult.m_isSuccess, ());
+      TEST_EQUAL(pushResult.m_id, ThreadPool::kImmediateMinId + 1, ());
 
-      TEST_EQUAL(cancelTaskId, ThreadPool::kImmediateMinId + 1, ());
+      cancelTaskId = pushResult.m_id;
     }
 
     {
-      auto const id = thread.Push([&]() { ++value; });
-
-      TEST_EQUAL(id, ThreadPool::kImmediateMinId + 2, ());
+      auto const pushResult = thread.Push([&]() { ++value; });
+      TEST(pushResult.m_isSuccess, ());
+      TEST_EQUAL(pushResult.m_id, ThreadPool::kImmediateMinId + 2, ());
     }
 
     TEST(thread.Cancel(cancelTaskId), ());
@@ -184,23 +211,29 @@ UNIT_TEST(ThreadPoolDelayed_CancelDelayed)
     TaskLoop::TaskId cancelTaskId;
     ThreadPool thread;
     {
-      auto const id = thread.Push([]() { testing::Wait(); });
-      TEST_EQUAL(id, ThreadPool::kImmediateMinId, ());
+      auto const pushResult = thread.Push([]() { testing::Wait(); });
+      TEST(pushResult.m_isSuccess, ());
+      TEST_EQUAL(pushResult.m_id, ThreadPool::kImmediateMinId, ());
     }
 
     {
-      auto const delayedId = thread.PushDelayed(milliseconds(1), [&value]() { ++value; });
-      TEST_EQUAL(delayedId, ThreadPool::kDelayedMinId, ());
+      auto const pushResult = thread.PushDelayed(milliseconds(1), [&value]() { ++value; });
+      TEST(pushResult.m_isSuccess, ());
+      TEST_EQUAL(pushResult.m_id, ThreadPool::kDelayedMinId, ());
     }
 
     {
-      cancelTaskId = thread.PushDelayed(milliseconds(2), [&]() { value += 1023; });
-      TEST_EQUAL(cancelTaskId, ThreadPool::kDelayedMinId + 1, ());
+      auto const pushResult = thread.PushDelayed(milliseconds(2), [&]() { value += 1023; });
+      TEST(pushResult.m_isSuccess, ());
+      TEST_EQUAL(pushResult.m_id, ThreadPool::kDelayedMinId + 1, ());
+
+      cancelTaskId = pushResult.m_id;
     }
 
     {
-      auto const delayedId = thread.PushDelayed(milliseconds(3), [&value]() { ++value; });
-      TEST_EQUAL(delayedId, ThreadPool::kDelayedMinId + 2, ());
+      auto const pushResult = thread.PushDelayed(milliseconds(3), [&value]() { ++value; });
+      TEST(pushResult.m_isSuccess, ());
+      TEST_EQUAL(pushResult.m_id, ThreadPool::kDelayedMinId + 2, ());
     }
 
     TEST(thread.Cancel(cancelTaskId), ());
diff --git a/base/task_loop.hpp b/base/task_loop.hpp
index ae3f3c9dba..fee08aa393 100644
--- a/base/task_loop.hpp
+++ b/base/task_loop.hpp
@@ -13,9 +13,17 @@ public:
 
   static TaskId constexpr kIncorrectId = 0;
 
+  struct PushResult
+  {
+    // Contains true when task is posted successfully.
+    bool m_isSuccess = false;
+    // Contains id of posted task.
+    TaskId m_id = kIncorrectId;
+  };
+
   virtual ~TaskLoop() = default;
 
-  virtual TaskId Push(Task && task) = 0;
-  virtual TaskId Push(Task const & task) = 0;
+  virtual PushResult Push(Task && task) = 0;
+  virtual PushResult Push(Task const & task) = 0;
 };
 }  // namespace base
diff --git a/base/thread_pool_delayed.cpp b/base/thread_pool_delayed.cpp
index 9af9a89af1..3cfc91ee1c 100644
--- a/base/thread_pool_delayed.cpp
+++ b/base/thread_pool_delayed.cpp
@@ -35,28 +35,28 @@ ThreadPool::~ThreadPool()
   ShutdownAndJoin();
 }
 
-TaskLoop::TaskId ThreadPool::Push(Task && t)
+TaskLoop::PushResult ThreadPool::Push(Task && t)
 {
   return AddImmediate(move(t));
 }
 
-TaskLoop::TaskId ThreadPool::Push(Task const & t)
+TaskLoop::PushResult ThreadPool::Push(Task const & t)
 {
   return AddImmediate(t);
 }
 
-TaskLoop::TaskId ThreadPool::PushDelayed(Duration const & delay, Task && t)
+TaskLoop::PushResult ThreadPool::PushDelayed(Duration const & delay, Task && t)
 {
   return AddDelayed(delay, move(t));
 }
 
-TaskLoop::TaskId ThreadPool::PushDelayed(Duration const & delay, Task const & t)
+TaskLoop::PushResult ThreadPool::PushDelayed(Duration const & delay, Task const & t)
 {
   return AddDelayed(delay, t);
 }
 
 template <typename T>
-TaskLoop::TaskId ThreadPool::AddImmediate(T && task)
+TaskLoop::PushResult ThreadPool::AddImmediate(T && task)
 {
   return AddTask([&]() {
     auto const newId = MakeNextId(m_immediateLastId, kImmediateMinId, kImmediateMaxId);
@@ -67,7 +67,7 @@ TaskLoop::TaskId ThreadPool::AddImmediate(T && task)
 }
 
 template <typename T>
-TaskLoop::TaskId ThreadPool::AddDelayed(Duration const & delay, T && task)
+TaskLoop::PushResult ThreadPool::AddDelayed(Duration const & delay, T && task)
 {
   auto const when = Now() + delay;
   return AddTask([&]() {
@@ -79,15 +79,15 @@ TaskLoop::TaskId ThreadPool::AddDelayed(Duration const & delay, T && task)
 }
 
 template <typename Add>
-TaskLoop::TaskId ThreadPool::AddTask(Add && add)
+TaskLoop::PushResult ThreadPool::AddTask(Add && add)
 {
   lock_guard<mutex> lk(m_mu);
   if (m_shutdown)
-    return kIncorrectId;
+    return {};
 
   auto const newId = add();
   m_cv.notify_one();
-  return newId;
+  return {true, newId};
 }
 
 void ThreadPool::ProcessTasks()
diff --git a/base/thread_pool_delayed.hpp b/base/thread_pool_delayed.hpp
index cd9957fe4d..e90f9f5763 100644
--- a/base/thread_pool_delayed.hpp
+++ b/base/thread_pool_delayed.hpp
@@ -50,17 +50,13 @@ public:
   ~ThreadPool() override;
 
   // Pushes task to the end of the thread's queue of immediate tasks.
-  // Returns task id or |TaskLoop::kIncorrectId| when any error occurs
-  // or the thread is shut down.
   //
   // The task |t| is going to be executed after all immediate tasks
   // that were pushed pushed before it.
-  TaskId Push(Task && t) override;
-  TaskId Push(Task const & t) override;
+  PushResult Push(Task && t) override;
+  PushResult Push(Task const & t) override;
 
   // Pushes task to the thread's queue of delayed tasks.
-  // Returns task id or |TaskLoop::kIncorrectId| when any error occurs
-  // or the thread is shut down.
   //
   // The task |t| is going to be executed not earlier than after
   // |delay|.  No other guarantees about execution order are made.  In
@@ -73,8 +69,8 @@ public:
   //
   // NOTE: current implementation depends on the fact that
   // steady_clock is the same for different threads.
-  TaskId PushDelayed(Duration const & delay, Task && t);
-  TaskId PushDelayed(Duration const & delay, Task const & t);
+  PushResult PushDelayed(Duration const & delay, Task && t);
+  PushResult PushDelayed(Duration const & delay, Task const & t);
 
   // Cancels task if it is in queue and is not running yet.
   // Returns false when thread is shut down,
@@ -146,11 +142,11 @@ private:
   };
 
   template <typename T>
-  TaskId AddImmediate(T && task);
+  PushResult AddImmediate(T && task);
   template <typename T>
-  TaskId AddDelayed(Duration const & delay, T && task);
+  PushResult AddDelayed(Duration const & delay, T && task);
   template <typename Add>
-  TaskId AddTask(Add && add);
+  PushResult AddTask(Add && add);
 
   void ProcessTasks();
 
diff --git a/drape/drape_routine.hpp b/drape/drape_routine.hpp
index 864ed076e9..4a8fb83838 100644
--- a/drape/drape_routine.hpp
+++ b/drape/drape_routine.hpp
@@ -62,13 +62,13 @@ public:
   static ResultPtr Run(Task && t)
   {
     ResultPtr result(new Result(Instance().GetNextId()));
-    auto const id = Instance().m_workerThread.Push([result, t = std::move(t)]() mutable
+    auto const pushResult = Instance().m_workerThread.Push([result, t = std::move(t)]() mutable
     {
       t();
       Instance().Notify(result->Finish());
     });
 
-    if (id == base::TaskLoop::kIncorrectId)
+    if (!pushResult.m_isSuccess)
       return {};
 
     return result;
@@ -78,13 +78,13 @@ public:
   static ResultPtr RunDelayed(base::thread_pool::delayed::ThreadPool::Duration const & duration, Task && t)
   {
     ResultPtr result(new Result(Instance().GetNextId()));
-    auto const id = Instance().m_workerThread.PushDelayed(duration, [result, t = std::move(t)]() mutable
+    auto const pushResult = Instance().m_workerThread.PushDelayed(duration, [result, t = std::move(t)]() mutable
     {
       t();
       Instance().Notify(result->Finish());
     });
 
-    if (id == base::TaskLoop::kIncorrectId)
+    if (!pushResult.m_isSuccess)
       return {};
 
     return result;
@@ -95,13 +95,13 @@ public:
   static ResultPtr RunSequential(Task && t)
   {
     ResultPtr result(new Result(Instance().GetNextId()));
-    auto const id = Instance().m_sequentialWorkerThread.Push([result, t = std::move(t)]() mutable
+    auto const pushResult = Instance().m_sequentialWorkerThread.Push([result, t = std::move(t)]() mutable
     {
       t();
       Instance().Notify(result->Finish());
     });
 
-    if (id == base::TaskLoop::kIncorrectId)
+    if (!pushResult.m_isSuccess)
       return {};
 
     return result;
diff --git a/map/guides_manager.cpp b/map/guides_manager.cpp
index 3374c030b1..048ed18dde 100644
--- a/map/guides_manager.cpp
+++ b/map/guides_manager.cpp
@@ -190,17 +190,17 @@ void GuidesManager::RequestGuides(bool suggestZoom)
     mercator::ClampPoint(p);
 
   auto const requestNumber = ++m_requestCounter;
-  auto const id = m_api.GetGuidesOnMap(
+  auto const pushResult = m_api.GetGuidesOnMap(
       corners, m_zoom, suggestZoom, kRequestingRectIncrease * 100,
       std::bind(&GuidesManager::OnRequestSucceed, this, _1, suggestZoom, requestNumber),
       std::bind(&GuidesManager::OnRequestError, this));
 
-  if (id != base::TaskLoop::kIncorrectId)
+  if (pushResult.m_id != base::TaskLoop::kIncorrectId)
   {
     if (m_previousRequestsId != base::TaskLoop::kIncorrectId)
       GetPlatform().CancelTask(Platform::Thread::Network, m_previousRequestsId);
 
-    m_previousRequestsId = id;
+    m_previousRequestsId = pushResult.m_id;
   }
 }
 
@@ -276,7 +276,7 @@ void GuidesManager::OnRequestError()
 
   ChangeState(GuidesState::NetworkError, true /* force */, !m_silentMode /* needNotify */);
 
-  m_retryAfterErrorRequestId =
+  auto const pushResult =
       GetPlatform().RunDelayedTask(Platform::Thread::Background, kErrorTimeout, [this]() {
         GetPlatform().RunTask(Platform::Thread::Gui, [this]() {
           if (m_state != GuidesState::NetworkError)
@@ -286,6 +286,8 @@ void GuidesManager::OnRequestError()
           RequestGuides();
         });
       });
+
+  m_retryAfterErrorRequestId = pushResult.m_id;
 }
 
 void GuidesManager::Clear()
diff --git a/partners_api/guides_on_map_api.cpp b/partners_api/guides_on_map_api.cpp
index b3a87beabb..1eed1580e2 100644
--- a/partners_api/guides_on_map_api.cpp
+++ b/partners_api/guides_on_map_api.cpp
@@ -133,17 +133,18 @@ void Api::SetDelegate(std::unique_ptr<Delegate> delegate)
   m_delegate = std::move(delegate);
 }
 
-base::TaskLoop::TaskId Api::GetGuidesOnMap(m2::AnyRectD::Corners const & corners, uint8_t zoomLevel,
-                                           bool suggestZoom, uint8_t rectIncreasedPercent,
-                                           GuidesOnMapCallback const & onSuccess,
-                                           OnError const & onError) const
+base::TaskLoop::PushResult Api::GetGuidesOnMap(m2::AnyRectD::Corners const & corners,
+                                               uint8_t zoomLevel, bool suggestZoom,
+                                               uint8_t rectIncreasedPercent,
+                                               GuidesOnMapCallback const & onSuccess,
+                                               OnError const & onError) const
 {
   auto const url = MakeGalleryUrl(m_baseUrl, corners, zoomLevel, suggestZoom, rectIncreasedPercent,
                                   languages::GetCurrentNorm());
   if (url.empty())
   {
     onSuccess({});
-    return base::TaskLoop::kIncorrectId;
+    return {};
   }
 
   auto const headers = m_delegate->GetHeaders();
diff --git a/partners_api/guides_on_map_api.hpp b/partners_api/guides_on_map_api.hpp
index 7e46abb8d0..35123eef55 100644
--- a/partners_api/guides_on_map_api.hpp
+++ b/partners_api/guides_on_map_api.hpp
@@ -67,10 +67,11 @@ public:
 
   void SetDelegate(std::unique_ptr<Delegate> delegate);
 
-  base::TaskLoop::TaskId GetGuidesOnMap(m2::AnyRectD::Corners const & corners, uint8_t zoomLevel,
-                                        bool suggestZoom, uint8_t rectIncreasedPercent,
-                                        GuidesOnMapCallback const & onSuccess,
-                                        OnError const & onError) const;
+  base::TaskLoop::PushResult GetGuidesOnMap(m2::AnyRectD::Corners const & corners,
+                                            uint8_t zoomLevel, bool suggestZoom,
+                                            uint8_t rectIncreasedPercent,
+                                            GuidesOnMapCallback const & onSuccess,
+                                            OnError const & onError) const;
 
 private:
   std::unique_ptr<Delegate> m_delegate;
diff --git a/platform/gui_thread.hpp b/platform/gui_thread.hpp
index b9f8aa3ff8..2bba4b058a 100644
--- a/platform/gui_thread.hpp
+++ b/platform/gui_thread.hpp
@@ -7,7 +7,7 @@ namespace platform
 class GuiThread : public base::TaskLoop
 {
 public:
-  TaskId Push(Task && task) override;
-  TaskId Push(Task const & task) override;
+  PushResult Push(Task && task) override;
+  PushResult Push(Task const & task) override;
 };
 }  // namespace platform
diff --git a/platform/gui_thread_apple.mm b/platform/gui_thread_apple.mm
index 07e8b61647..13e7f5360b 100644
--- a/platform/gui_thread_apple.mm
+++ b/platform/gui_thread_apple.mm
@@ -17,15 +17,15 @@ void PerformImpl(void * task)
 
 namespace platform
 {
-base::TaskLoop::TaskId GuiThread::Push(Task && task)
+base::TaskLoop::PushResult GuiThread::Push(Task && task)
 {
   dispatch_async_f(dispatch_get_main_queue(), new Task(std::move(task)), &PerformImpl);
-  return TaskLoop::kIncorrectId;
+  return {true, TaskLoop::kIncorrectId};
 }
 
-base::TaskLoop::TaskId GuiThread::Push(Task const & task)
+base::TaskLoop::PushResult GuiThread::Push(Task const & task)
 {
   dispatch_async_f(dispatch_get_main_queue(), new Task(task), &PerformImpl);
-  return TaskLoop::kIncorrectId;
+  return {true, TaskLoop::kIncorrectId};
 }
 }  // namespace platform
diff --git a/platform/gui_thread_linux.cpp b/platform/gui_thread_linux.cpp
index 152882e17a..1a347d5862 100644
--- a/platform/gui_thread_linux.cpp
+++ b/platform/gui_thread_linux.cpp
@@ -6,23 +6,23 @@
 
 namespace platform
 {
-base::TaskLoop::TaskId GuiThread::Push(Task && task)
+base::TaskLoop::PushResult GuiThread::Push(Task && task)
 {
   // Following hack is used to post on main message loop |fn| when
   // |source| is destroyed (at the exit of the code block).
   QObject source;
   QObject::connect(&source, &QObject::destroyed, QCoreApplication::instance(), std::move(task));
 
-  return base::TaskLoop::kIncorrectId;
+  return {true, base::TaskLoop::kIncorrectId};
 }
 
-base::TaskLoop::TaskId GuiThread::Push(Task const & task)
+base::TaskLoop::PushResult GuiThread::Push(Task const & task)
 {
   // Following hack is used to post on main message loop |fn| when
   // |source| is destroyed (at the exit of the code block).
   QObject source;
   QObject::connect(&source, &QObject::destroyed, QCoreApplication::instance(), task);
 
-  return base::TaskLoop::kIncorrectId;
+  return {true, base::TaskLoop::kIncorrectId};
 }
 }  // namespace platform
diff --git a/platform/platform.cpp b/platform/platform.cpp
index 60bb85b373..7c693d380b 100644
--- a/platform/platform.cpp
+++ b/platform/platform.cpp
@@ -363,6 +363,11 @@ void Platform::RunThreads()
   m_backgroundThread = make_unique<base::thread_pool::delayed::ThreadPool>();
 }
 
+void Platform::SetGuiThread(std::unique_ptr<base::TaskLoop> guiThread)
+{
+  m_guiThread = std::move(guiThread);
+}
+
 void Platform::CancelTask(Thread thread, base::TaskLoop::TaskId id)
 {
   ASSERT(m_networkThread && m_fileThread && m_backgroundThread, ());
diff --git a/platform/platform.hpp b/platform/platform.hpp
index 79b32ce1b9..9f68c324c3 100644
--- a/platform/platform.hpp
+++ b/platform/platform.hpp
@@ -315,20 +315,20 @@ public:
   /// \note |task| cannot be moved in case of |Thread::Gui|. This way unique_ptr cannot be used
   /// in |task|. Use shared_ptr instead.
   template <typename Task>
-  base::TaskLoop::TaskId RunTask(Thread thread, Task && task)
+  base::TaskLoop::PushResult RunTask(Thread thread, Task && task)
   {
     ASSERT(m_networkThread && m_fileThread && m_backgroundThread, ());
     switch (thread)
     {
     case Thread::File: return m_fileThread->Push(std::forward<Task>(task));
     case Thread::Network: return m_networkThread->Push(std::forward<Task>(task));
-    case Thread::Gui: RunOnGuiThread(std::forward<Task>(task)); return base::TaskLoop::kIncorrectId;
+    case Thread::Gui: return m_guiThread->Push(std::forward<Task>(task));
     case Thread::Background: return m_backgroundThread->Push(std::forward<Task>(task));
     }
   }
 
   template <typename Task>
-  base::TaskLoop::TaskId RunDelayedTask(
+  base::TaskLoop::PushResult RunDelayedTask(
       Thread thread, base::thread_pool::delayed::ThreadPool::Duration const & delay, Task && task)
   {
     ASSERT(m_networkThread && m_fileThread && m_backgroundThread, ());
@@ -338,7 +338,7 @@ public:
     case Thread::Network: return m_networkThread->PushDelayed(delay, std::forward<Task>(task));
     case Thread::Gui:
       CHECK(false, ("Delayed tasks for gui thread are not supported yet"));
-      return base::TaskLoop::kIncorrectId;
+      return {};
     case Thread::Background:
       return m_backgroundThread->PushDelayed(delay, std::forward<Task>(task));
     }
@@ -355,9 +355,6 @@ private:
   void RunThreads();
   void ShutdownThreads();
 
-  void RunOnGuiThread(base::TaskLoop::Task && task);
-  void RunOnGuiThread(base::TaskLoop::Task const & task);
-
   void GetSystemFontNames(FilesList & res) const;
 };
 
diff --git a/platform/platform_android.cpp b/platform/platform_android.cpp
index 475a665834..ef51f23a25 100644
--- a/platform/platform_android.cpp
+++ b/platform/platform_android.cpp
@@ -267,7 +267,3 @@ void Platform::SetupMeasurementSystem() const
   units = measurement_utils::Units::Metric;
   settings::Set(settings::kMeasurementUnits, units);
 }
-
-/// @see implementation of methods below in android/jni/com/.../Platform.cpp
-//  void RunOnGuiThread(base::TaskLoop::Task && task);
-//  void RunOnGuiThread(base::TaskLoop::Task const & task);
diff --git a/platform/platform_ios.mm b/platform/platform_ios.mm
index a6e3525f96..0f48268e2d 100644
--- a/platform/platform_ios.mm
+++ b/platform/platform_ios.mm
@@ -179,18 +179,6 @@ std::string Platform::DeviceModel() const
   return deviceModel.UTF8String;
 }
 
-void Platform::RunOnGuiThread(base::TaskLoop::Task && task)
-{
-  ASSERT(m_guiThread, ());
-  m_guiThread->Push(std::move(task));
-}
-
-void Platform::RunOnGuiThread(base::TaskLoop::Task const & task)
-{
-  ASSERT(m_guiThread, ());
-  m_guiThread->Push(task);
-}
-
 Platform::EConnectionType Platform::ConnectionStatus()
 {
   struct sockaddr_in zero;
@@ -255,11 +243,6 @@ void Platform::SetupMeasurementSystem() const
   settings::Set(settings::kMeasurementUnits, units);
 }
 
-void Platform::SetGuiThread(std::unique_ptr<base::TaskLoop> guiThread)
-{
-  m_guiThread = std::move(guiThread);
-}
-
 ////////////////////////////////////////////////////////////////////////
 extern Platform & GetPlatform()
 {
diff --git a/platform/platform_linux.cpp b/platform/platform_linux.cpp
index b701c6c7c7..f6db34c00d 100644
--- a/platform/platform_linux.cpp
+++ b/platform/platform_linux.cpp
@@ -272,8 +272,3 @@ uint8_t Platform::GetBatteryLevel()
   // This value is always 100 for desktop.
   return 100;
 }
-
-void Platform::SetGuiThread(unique_ptr<base::TaskLoop> guiThread)
-{
-  m_guiThread = move(guiThread);
-}
diff --git a/platform/platform_mac.mm b/platform/platform_mac.mm
index 7ad3fd6c2a..b47ea80107 100644
--- a/platform/platform_mac.mm
+++ b/platform/platform_mac.mm
@@ -139,18 +139,6 @@ std::string Platform::DeviceModel() const
   return {};
 }
 
-void Platform::RunOnGuiThread(base::TaskLoop::Task && task)
-{
-  ASSERT(m_guiThread, ());
-  m_guiThread->Push(std::move(task));
-}
-
-void Platform::RunOnGuiThread(base::TaskLoop::Task const & task)
-{
-  ASSERT(m_guiThread, ());
-  m_guiThread->Push(task);
-}
-
 Platform::EConnectionType Platform::ConnectionStatus()
 {
   struct sockaddr_in zero;
@@ -182,9 +170,3 @@ uint8_t Platform::GetBatteryLevel()
   // This value is always 100 for desktop.
   return 100;
 }
-
-void Platform::SetGuiThread(std::unique_ptr<base::TaskLoop> guiThread)
-{
-  m_guiThread = std::move(guiThread);
-}
-
diff --git a/platform/platform_qt.cpp b/platform/platform_qt.cpp
index 424965725a..7f00af568c 100644
--- a/platform/platform_qt.cpp
+++ b/platform/platform_qt.cpp
@@ -88,20 +88,6 @@ void Platform::SetupMeasurementSystem() const
   settings::Set(settings::kMeasurementUnits, units);
 }
 
-#if defined(OMIM_OS_LINUX)
-void Platform::RunOnGuiThread(base::TaskLoop::Task && task)
-{
-  ASSERT(m_guiThread, ());
-  m_guiThread->Push(std::move(task));
-}
-
-void Platform::RunOnGuiThread(base::TaskLoop::Task const & task)
-{
-  ASSERT(m_guiThread, ());
-  m_guiThread->Push(task);
-}
-#endif  // defined(OMIM_OS_LINUX)
-
 extern Platform & GetPlatform()
 {
   static Platform platform;
diff --git a/platform/platform_win.cpp b/platform/platform_win.cpp
index f3c8f6bb4d..4f56ed96cf 100644
--- a/platform/platform_win.cpp
+++ b/platform/platform_win.cpp
@@ -161,12 +161,6 @@ string Platform::DeviceModel() const
   return {};
 }
 
-void Platform::RunOnGuiThread(TFunctor const & fn)
-{
-  /// @todo
-  fn();
-}
-
 Platform::EConnectionType Platform::ConnectionStatus()
 {
   // @TODO Add implementation