diff --git a/android/src/com/mapswithme/maps/routing/RoutingController.java b/android/src/com/mapswithme/maps/routing/RoutingController.java
index ba411b4ee2..e6adf59afe 100644
--- a/android/src/com/mapswithme/maps/routing/RoutingController.java
+++ b/android/src/com/mapswithme/maps/routing/RoutingController.java
@@ -122,34 +122,36 @@ public class RoutingController implements TaxiManager.TaxiListener
     public void onRoutingEvent(final int resultCode, @Nullable final String[] missingMaps)
     {
       mLogger.d(TAG, "onRoutingEvent(resultCode: " + resultCode + ")");
-      UiThread.run(() -> {
-        mLastResultCode = resultCode;
-        mLastMissingMaps = missingMaps;
-        mContainsCachedResult = true;
+      mLastResultCode = resultCode;
+      mLastMissingMaps = missingMaps;
+      mContainsCachedResult = true;
 
-        if (mLastResultCode == ResultCodesHelper.NO_ERROR
-            || ResultCodesHelper.isMoreMapsNeeded(mLastResultCode))
-        {
-          mCachedRoutingInfo = Framework.nativeGetRouteFollowingInfo();
-          if (mLastRouterType == Framework.ROUTER_TYPE_TRANSIT)
-            mCachedTransitRouteInfo = Framework.nativeGetTransitRouteInfo();
-          setBuildState(BuildState.BUILT);
-          mLastBuildProgress = 100;
-          if (mContainer != null)
-            mContainer.onBuiltRoute();
-        }
+      if (mLastResultCode == ResultCodesHelper.NO_ERROR
+        || ResultCodesHelper.isMoreMapsNeeded(mLastResultCode))
+      {
+        mCachedRoutingInfo = Framework.nativeGetRouteFollowingInfo();
+        if (mLastRouterType == Framework.ROUTER_TYPE_TRANSIT)
+          mCachedTransitRouteInfo = Framework.nativeGetTransitRouteInfo();
+        setBuildState(BuildState.BUILT);
+        mLastBuildProgress = 100;
+        if (mContainer != null)
+          mContainer.onBuiltRoute();
+      }
 
-        processRoutingEvent();
-      });
+      processRoutingEvent();
     }
   };
 
   @SuppressWarnings("FieldCanBeLocal")
-  private final Framework.RoutingProgressListener mRoutingProgressListener =
-    progress -> UiThread.run(() -> {
+  private final Framework.RoutingProgressListener mRoutingProgressListener = new Framework.RoutingProgressListener()
+  {
+    @Override
+    public void onRouteBuildingProgress(float progress)
+    {
       mLastBuildProgress = (int) progress;
       updateProgress();
-    });
+    }
+  };
 
   @SuppressWarnings("FieldCanBeLocal")
   private final Framework.RoutingRecommendationListener mRoutingRecommendationListener =
diff --git a/iphone/Maps/Core/Routing/MWMRouter.mm b/iphone/Maps/Core/Routing/MWMRouter.mm
index 446e567099..ae71f5914d 100644
--- a/iphone/Maps/Core/Routing/MWMRouter.mm
+++ b/iphone/Maps/Core/Routing/MWMRouter.mm
@@ -518,13 +518,24 @@ void logPointEvent(MWMRoutePoint * point, NSString * eventType)
 + (void)routeAltitudeImageForSize:(CGSize)size completion:(MWMImageHeightBlock)block
 {
   auto router = self.router;
+  // @TODO The method below is implemented on render renderAltitudeImagesQueue to prevent ui thread
+  // from heavy methods. On the other hand some of calls of the method should be done on ui thread.
+  // This method should be rewritten to perform on renderAltitudeImagesQueue only the heavest
+  // functions. Or all the method should be done on ui thread.
   dispatch_async(router.renderAltitudeImagesQueue, ^{
     auto router = self.router;
-    if (![self hasRouteAltitude])
+
+    bool hasAltitude = false;
+    dispatch_sync(dispatch_get_main_queue(), [self, &hasAltitude]{
+      hasAltitude = [self hasRouteAltitude];
+    });
+    if (!hasAltitude)
       return;
+
     CGFloat const screenScale = [UIScreen mainScreen].scale;
-    CGSize const scaledSize = {.width = size.width * screenScale,
-                               .height = size.height * screenScale};
+    CGSize const scaledSize = {size.width * screenScale, size.height * screenScale};
+    CHECK_GREATER_OR_EQUAL(scaledSize.width, 0.0, ());
+    CHECK_GREATER_OR_EQUAL(scaledSize.height, 0.0, ());
     uint32_t const width = static_cast<uint32_t>(scaledSize.width);
     uint32_t const height = static_cast<uint32_t>(scaledSize.height);
     if (width == 0 || height == 0)
@@ -538,11 +549,17 @@ void logPointEvent(MWMRoutePoint * point, NSString * eventType)
       int32_t minRouteAltitude = 0;
       int32_t maxRouteAltitude = 0;
       measurement_utils::Units units = measurement_utils::Units::Metric;
-      if (!GetFramework().GetRoutingManager().GenerateRouteAltitudeChart(
-              width, height, imageRGBAData, minRouteAltitude, maxRouteAltitude, units))
-      {
+      bool result = false;
+      dispatch_sync(dispatch_get_main_queue(), [&] {
+        result = GetFramework().GetRoutingManager().GenerateRouteAltitudeChart(width, height,
+                                                                               imageRGBAData,
+                                                                               minRouteAltitude,
+                                                                               maxRouteAltitude, units);
+      });
+
+      if (!result)
         return;
-      }
+
       if (imageRGBAData.empty())
         return;
       imageData = [NSData dataWithBytes:imageRGBAData.data() length:imageRGBAData.size()];
diff --git a/map/bookmark_manager.hpp b/map/bookmark_manager.hpp
index 35608df90e..8d2bf50d93 100644
--- a/map/bookmark_manager.hpp
+++ b/map/bookmark_manager.hpp
@@ -368,7 +368,8 @@ private:
     auto const markId = m->GetId();
     auto const groupId = static_cast<kml::MarkGroupId>(m->GetMarkType());
     CHECK_EQUAL(m_userMarks.count(markId), 0, ());
-    ASSERT_LESS(groupId, m_userMarkLayers.size(), ());
+    ASSERT_GREATER(groupId, 0, ());
+    ASSERT_LESS(groupId - 1, m_userMarkLayers.size(), ());
     m_userMarks.emplace(markId, std::move(mark));
     m_changesTracker.OnAddMark(markId);
     m_userMarkLayers[groupId - 1]->AttachUserMark(markId);
diff --git a/map/routing_manager.cpp b/map/routing_manager.cpp
index edbb0612fa..17a65a559c 100644
--- a/map/routing_manager.cpp
+++ b/map/routing_manager.cpp
@@ -48,8 +48,6 @@ using namespace std;
 
 namespace
 {
-//#define SHOW_ROUTE_DEBUG_MARKS
-
 char const kRouterTypeKey[] = "router";
 
 double const kRouteScaleMultiplier = 1.5;
@@ -229,17 +227,19 @@ RoutingManager::RoutingManager(Callbacks && callbacks, Delegate & delegate)
     GetPlatform().GetMarketingService().SendMarketingEvent(marketing::kRoutingCalculatingRoute, {});
   };
 
-  m_routingSession.Init(routingStatisticsFn, [this](m2::PointD const & pt)
-  {
-    UNUSED_VALUE(this);
+  m_routingSession.Init(routingStatisticsFn,
 #ifdef SHOW_ROUTE_DEBUG_MARKS
-    if (m_bmManager == nullptr)
-      return;
-    auto editSession = m_bmManager->GetEditSession();
-    editSession.SetIsVisible(UserMark::Type::DEBUG_MARK, true);
-    editSession.CreateUserMark<DebugMarkPoint>(pt);
+                        [this](m2::PointD const & pt) {
+                          if (m_bmManager == nullptr)
+                            return;
+                          auto editSession = m_bmManager->GetEditSession();
+                          editSession.SetIsVisible(UserMark::Type::DEBUG_MARK, true);
+                          editSession.CreateUserMark<DebugMarkPoint>(pt);
+                        }
+#else
+                        nullptr
 #endif
-  });
+  );
 
   m_routingSession.SetReadyCallbacks(
       [this](Route const & route, RouterResultCode code) { OnBuildRouteReady(route, code); },
diff --git a/routing/async_router.cpp b/routing/async_router.cpp
index 08af0bc7d3..dd0bf29a42 100644
--- a/routing/async_router.cpp
+++ b/routing/async_router.cpp
@@ -1,7 +1,5 @@
 #include "routing/async_router.hpp"
 
-#include "platform/platform.hpp"
-
 #include "geometry/mercator.hpp"
 
 #include "base/logging.hpp"
@@ -37,6 +35,37 @@ map<string, string> PrepareStatisticsData(string const & routerName,
           {"finalLat", strings::to_string_dac(MercatorBounds::YToLat(finalPoint.y), precision)}};
 }
 
+void SendStatistics(m2::PointD const & startPoint, m2::PointD const & startDirection,
+                    m2::PointD const & finalPoint, RouterResultCode resultCode, double routeLenM,
+                    double elapsedSec, RoutingStatisticsCallback const & routingStatisticsCallback,
+                    string const & routerName)
+{
+  if (nullptr == routingStatisticsCallback)
+    return;
+
+  map<string, string> statistics = PrepareStatisticsData(routerName, startPoint, startDirection, finalPoint);
+  statistics.emplace("result", DebugPrint(resultCode));
+  statistics.emplace("elapsed", strings::to_string(elapsedSec));
+
+  if (RouterResultCode::NoError == resultCode)
+    statistics.emplace("distance", strings::to_string(routeLenM));
+
+  routingStatisticsCallback(statistics);
+}
+
+void SendStatistics(m2::PointD const & startPoint, m2::PointD const & startDirection,
+                    m2::PointD const & finalPoint, string const & exceptionMessage,
+                    RoutingStatisticsCallback const & routingStatisticsCallback,
+                    string const & routerName)
+{
+  if (nullptr == routingStatisticsCallback)
+    return;
+
+  map<string, string> statistics = PrepareStatisticsData(routerName, startPoint, startDirection, finalPoint);
+  statistics.emplace("exception", exceptionMessage);
+
+  routingStatisticsCallback(statistics);
+}
 }  // namespace
 
 // ----------------------------------------------------------------------------------------------------------------------------
@@ -47,7 +76,7 @@ AsyncRouter::RouterDelegateProxy::RouterDelegateProxy(ReadyCallbackOwnership con
                                                       PointCheckCallback const & onPointCheck,
                                                       ProgressCallback const & onProgress,
                                                       uint32_t timeoutSec)
-  : m_onReady(onReady)
+  : m_onReadyOwnership(onReady)
   , m_onNeedMoreMaps(m_onNeedMoreMaps)
   , m_removeRoute(removeRoute)
   , m_onPointCheck(onPointCheck)
@@ -59,16 +88,16 @@ AsyncRouter::RouterDelegateProxy::RouterDelegateProxy(ReadyCallbackOwnership con
   m_delegate.SetTimeout(timeoutSec);
 }
 
-void AsyncRouter::RouterDelegateProxy::OnReady(unique_ptr<Route> route, RouterResultCode resultCode)
+void AsyncRouter::RouterDelegateProxy::OnReady(shared_ptr<Route> route, RouterResultCode resultCode)
 {
-  if (!m_onReady)
+  if (!m_onReadyOwnership)
     return;
   {
     lock_guard<mutex> l(m_guard);
     if (m_delegate.IsCancelled())
       return;
   }
-  m_onReady(move(route), resultCode);
+  m_onReadyOwnership(move(route), resultCode);
 }
 
 void AsyncRouter::RouterDelegateProxy::OnNeedMoreMaps(uint64_t routeId,
@@ -104,35 +133,52 @@ void AsyncRouter::RouterDelegateProxy::Cancel()
 
 void AsyncRouter::RouterDelegateProxy::OnProgress(float progress)
 {
-  if (!m_onProgress)
-    return;
+  ProgressCallback onProgress = nullptr;
+
   {
     lock_guard<mutex> l(m_guard);
+    if (!m_onProgress)
+      return;
+
     if (m_delegate.IsCancelled())
       return;
+
+    onProgress = m_onProgress;
+    GetPlatform().RunTask(Platform::Thread::Gui, [onProgress, progress]() {
+      onProgress(progress);
+    });
   }
-  m_onProgress(progress);
 }
 
 void AsyncRouter::RouterDelegateProxy::OnPointCheck(m2::PointD const & pt)
 {
-  if (!m_onPointCheck)
-    return;
+#ifdef SHOW_ROUTE_DEBUG_MARKS
+  PointCheckCallback onPointCheck = nullptr;
+  m2::PointD point;
   {
     lock_guard<mutex> l(m_guard);
+    CHECK(m_onPointCheck, ());
+
     if (m_delegate.IsCancelled())
       return;
+
+    onPointCheck = m_onPointCheck;
+    point = pt;
   }
-  m_onPointCheck(pt);
+
+  GetPlatform().RunTask(Platform::Thread::Gui, [onPointCheck, point]() { onPointCheck(point); });
+#endif
 }
 
-// ----------------------------------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 
 AsyncRouter::AsyncRouter(RoutingStatisticsCallback const & routingStatisticsCallback,
                          PointCheckCallback const & pointCheckCallback)
-    : m_threadExit(false), m_hasRequest(false), m_clearState(false),
-      m_routingStatisticsCallback(routingStatisticsCallback),
-      m_pointCheckCallback(pointCheckCallback)
+  : m_threadExit(false)
+  , m_hasRequest(false)
+  , m_clearState(false)
+  , m_routingStatisticsCallback(routingStatisticsCallback)
+  , m_pointCheckCallback(pointCheckCallback)
 {
   m_thread = threads::SimpleThread(&AsyncRouter::ThreadFunc, this);
 }
@@ -250,6 +296,12 @@ void AsyncRouter::LogCode(RouterResultCode code, double const elapsedSec)
   }
 }
 
+void AsyncRouter::RunOnReadyOnGuiThread(shared_ptr<RouterDelegateProxy> delegate,
+                                        shared_ptr<Route> route, RouterResultCode code)
+{
+  RunOnGuiThread([delegate, route, code]() {delegate->OnReady(route, code);});
+}
+
 void AsyncRouter::ResetDelegate()
 {
   if (m_delegate)
@@ -293,6 +345,8 @@ void AsyncRouter::CalculateRoute()
   shared_ptr<IOnlineFetcher> absentFetcher;
   shared_ptr<IRouter> router;
   uint64_t routeId = m_routeCounter;
+  RoutingStatisticsCallback routingStatisticsCallback = nullptr;
+  string routerName;
 
   {
     unique_lock<mutex> ul(m_guard);
@@ -313,9 +367,12 @@ void AsyncRouter::CalculateRoute()
     router = m_router;
     absentFetcher = m_absentFetcher;
     routeId = ++m_routeCounter;
+
+    routingStatisticsCallback = m_routingStatisticsCallback;
+    routerName = router->GetName();
   }
 
-  unique_ptr<Route> route = make_unique<Route>(router->GetName(), routeId);
+  shared_ptr<Route> route = make_shared<Route>(router->GetName(), routeId);
   RouterResultCode code;
 
   my::Timer timer;
@@ -340,17 +397,30 @@ void AsyncRouter::CalculateRoute()
   {
     code = RouterResultCode::InternalError;
     LOG(LERROR, ("Exception happened while calculating route:", e.Msg()));
-    SendStatistics(checkpoints.GetStart(), startDirection, checkpoints.GetFinish(), e.Msg());
-    delegate->OnReady(move(route), code);
+    RunOnGuiThread([checkpoints, startDirection, e, routingStatisticsCallback, routerName]() {
+      SendStatistics(checkpoints.GetStart(), startDirection, checkpoints.GetFinish(), e.Msg(),
+                     routingStatisticsCallback, routerName);
+    });
+    // Note. After call of this method |route| should be used only on ui thread.
+    // And |route| should stop using on routing background thread, in this method.
+    RunOnReadyOnGuiThread(delegate, route, code);
     return;
   }
 
-  SendStatistics(checkpoints.GetStart(), startDirection, checkpoints.GetFinish(), code, *route,
-                 elapsedSec);
+  double const routeLengthM = route->GetTotalDistanceMeters();
+  RunOnGuiThread([checkpoints, startDirection, code, routeLengthM, elapsedSec,
+                    routingStatisticsCallback, routerName]() {
+    SendStatistics(checkpoints.GetStart(), startDirection, checkpoints.GetFinish(), code,
+                   routeLengthM, elapsedSec, routingStatisticsCallback, routerName);
+  });
 
   // Draw route without waiting network latency.
   if (code == RouterResultCode::NoError)
-    delegate->OnReady(move(route), code);
+  {
+    // Note. After call of this method |route| should be used only on ui thread.
+    // And |route| should stop using on routing background thread, in this method.
+    RunOnReadyOnGuiThread(delegate, route, code);
+  }
 
   bool const needFetchAbsent = (code != RouterResultCode::Cancelled);
 
@@ -369,42 +439,9 @@ void AsyncRouter::CalculateRoute()
   if (code != RouterResultCode::NoError)
   {
     if (code == RouterResultCode::NeedMoreMaps)
-      delegate->OnNeedMoreMaps(routeId, absent);
+       RunOnGuiThread([delegate, routeId, absent]() { delegate->OnNeedMoreMaps(routeId, absent); });
     else
-      delegate->OnRemoveRoute(code);
+      RunOnGuiThread([delegate, code]() { delegate->OnRemoveRoute(code); });
   }
 }
-
-void AsyncRouter::SendStatistics(m2::PointD const & startPoint, m2::PointD const & startDirection,
-                                 m2::PointD const & finalPoint,
-                                 RouterResultCode resultCode,
-                                 Route const & route,
-                                 double elapsedSec)
-{
-  if (nullptr == m_routingStatisticsCallback)
-    return;
-
-  map<string, string> statistics = PrepareStatisticsData(m_router->GetName(), startPoint, startDirection, finalPoint);
-  statistics.emplace("result", DebugPrint(resultCode));
-  statistics.emplace("elapsed", strings::to_string(elapsedSec));
-
-  if (RouterResultCode::NoError == resultCode)
-    statistics.emplace("distance", strings::to_string(route.GetTotalDistanceMeters()));
-
-  m_routingStatisticsCallback(statistics);
-}
-
-void AsyncRouter::SendStatistics(m2::PointD const & startPoint, m2::PointD const & startDirection,
-                                 m2::PointD const & finalPoint,
-                                 string const & exceptionMessage)
-{
-  if (nullptr == m_routingStatisticsCallback)
-    return;
-
-  map<string, string> statistics = PrepareStatisticsData(m_router->GetName(), startPoint, startDirection, finalPoint);
-  statistics.emplace("exception", exceptionMessage);
-
-  m_routingStatisticsCallback(statistics);
-}
-
 }  // namespace routing
diff --git a/routing/async_router.hpp b/routing/async_router.hpp
index 84d897dc77..3c253e9952 100644
--- a/routing/async_router.hpp
+++ b/routing/async_router.hpp
@@ -7,6 +7,8 @@
 #include "routing/router_delegate.hpp"
 #include "routing/routing_callbacks.hpp"
 
+#include "platform/platform.hpp"
+
 #include "base/thread.hpp"
 
 #include "std/cstdint.hpp"
@@ -16,6 +18,7 @@
 #include "std/shared_ptr.hpp"
 #include "std/string.hpp"
 #include "std/unique_ptr.hpp"
+#include "std/utility.hpp"
 
 namespace routing
 {
@@ -61,19 +64,7 @@ private:
 
   /// This function is called in worker thread
   void CalculateRoute();
-
   void ResetDelegate();
-
-  /// These functions are called to send statistics about the routing
-  void SendStatistics(m2::PointD const & startPoint, m2::PointD const & startDirection,
-                      m2::PointD const & finalPoint,
-                      RouterResultCode resultCode,
-                      Route const & route,
-                      double elapsedSec);
-  void SendStatistics(m2::PointD const & startPoint, m2::PointD const & startDirection,
-                      m2::PointD const & finalPoint,
-                      string const & exceptionMessage);
-
   void LogCode(RouterResultCode code, double const elapsedSec);
 
   /// Blocks callbacks when routing has been cancelled
@@ -87,8 +78,8 @@ private:
                         ProgressCallback const & onProgress,
                         uint32_t timeoutSec);
 
-    void OnReady(unique_ptr<Route> route, RouterResultCode resultCode);
-    void OnNeedMoreMaps(uint64_t routeId, std::vector<std::string> const & absentCounties);
+    void OnReady(shared_ptr<Route> route, RouterResultCode resultCode);
+    void OnNeedMoreMaps(uint64_t routeId, vector<std::string> const & absentCounties);
     void OnRemoveRoute(RouterResultCode resultCode);
     void Cancel();
 
@@ -99,8 +90,8 @@ private:
     void OnPointCheck(m2::PointD const & pt);
 
     mutex m_guard;
-    ReadyCallbackOwnership const m_onReady;
-    // |m_onNeedMoreMaps| may be called after |m_onReady| if
+    ReadyCallbackOwnership const m_onReadyOwnership;
+    // |m_onNeedMoreMaps| may be called after |m_onReadyOwnership| if
     // - it's possible to build route only if to load some maps
     // - there's a faster route, but it's necessary to load some more maps to build it
     NeedMoreMapsCallback const m_onNeedMoreMaps;
@@ -110,6 +101,15 @@ private:
     RouterDelegate m_delegate;
   };
 
+  void RunOnReadyOnGuiThread(shared_ptr<RouterDelegateProxy> delegate, shared_ptr<Route> route,
+                             RouterResultCode code);
+
+  template <typename Task>
+  void RunOnGuiThread(Task && task)
+  {
+    GetPlatform().RunTask(Platform::Thread::Gui, std::forward<Task>(task));
+  }
+
 private:
   mutex m_guard;
 
diff --git a/routing/routing_callbacks.hpp b/routing/routing_callbacks.hpp
index fa9d694c2b..9d46010158 100644
--- a/routing/routing_callbacks.hpp
+++ b/routing/routing_callbacks.hpp
@@ -44,7 +44,7 @@ using NeedMoreMapsCallback = std::function<void(uint64_t, std::vector<std::strin
 using PointCheckCallback = std::function<void(m2::PointD const &)>;
 using ProgressCallback = std::function<void(float)>;
 using ReadyCallback = std::function<void(Route const &, RouterResultCode)>;
-using ReadyCallbackOwnership = std::function<void(std::unique_ptr<Route>, RouterResultCode)>;
+using ReadyCallbackOwnership = std::function<void(std::shared_ptr<Route>, RouterResultCode)>;
 using RemoveRouteCallback = std::function<void(RouterResultCode)>;
 using RouteCallback = std::function<void(Route const &)>;
 using RoutingStatisticsCallback = std::function<void(std::map<std::string, std::string> const &)>;
@@ -75,4 +75,7 @@ inline std::string DebugPrint(RouterResultCode code)
   ASSERT(false, (result));
   return result;
 }
+
+// This define should be set to see the spread of A* waves on the map.
+// #define SHOW_ROUTE_DEBUG_MARKS
 }  // namespace routing
diff --git a/routing/routing_session.cpp b/routing/routing_session.cpp
index 09a20f9b1d..edf794ff1f 100644
--- a/routing/routing_session.cpp
+++ b/routing/routing_session.cpp
@@ -76,22 +76,20 @@ RoutingSession::RoutingSession()
 void RoutingSession::Init(RoutingStatisticsCallback const & routingStatisticsFn,
                           PointCheckCallback const & pointCheckCallback)
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
-  ASSERT(m_router == nullptr, ());
-  m_router.reset(new AsyncRouter(routingStatisticsFn, pointCheckCallback));
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
+  CHECK(!m_router, ());
+  m_router = make_unique<AsyncRouter>(routingStatisticsFn, pointCheckCallback);
 }
 
 void RoutingSession::BuildRoute(Checkpoints const & checkpoints,
                                 uint32_t timeoutSec)
 {
-  {
-    threads::MutexGuard guard(m_routingSessionMutex);
-    ASSERT(m_router != nullptr, ());
-    m_checkpoints = checkpoints;
-    m_router->ClearState();
-    m_isFollowing = false;
-    m_routingRebuildCount = -1; // -1 for the first rebuild.
-  }
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
+  CHECK(m_router, ());
+  m_checkpoints = checkpoints;
+  m_router->ClearState();
+  m_isFollowing = false;
+  m_routingRebuildCount = -1; // -1 for the first rebuild.
 
   RebuildRoute(checkpoints.GetStart(), m_buildReadyCallback, m_needMoreMapsCallback,
                m_removeRouteCallback, timeoutSec, RouteBuilding, false /* adjust */);
@@ -104,50 +102,44 @@ void RoutingSession::RebuildRoute(m2::PointD const & startPoint,
                                   uint32_t timeoutSec, State routeRebuildingState,
                                   bool adjustToPrevRoute)
 {
-  {
-    // @TODO(bykoianko) After moving all routing callbacks to single thread this guard can be
-    // removed.
-    threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
+  CHECK(m_router, ());
+  RemoveRoute();
+  SetState(routeRebuildingState);
 
-    CHECK(m_router, ());
-    RemoveRoute();
-    SetState(routeRebuildingState);
-
-    ++m_routingRebuildCount;
-    m_lastCompletionPercent = 0;
-    m_checkpoints.SetPointFrom(startPoint);
-  }
+  ++m_routingRebuildCount;
+  m_lastCompletionPercent = 0;
+  m_checkpoints.SetPointFrom(startPoint);
 
   // Use old-style callback construction, because lambda constructs buggy function on Android
   // (callback param isn't captured by value).
   m_router->CalculateRoute(m_checkpoints, m_currentDirection, adjustToPrevRoute,
-                           DoReadyCallback(*this, readyCallback, m_routingSessionMutex),
+                           DoReadyCallback(*this, readyCallback),
                            needMoreMapsCallback, removeRouteCallback, m_progressCallback, timeoutSec);
 }
 
 m2::PointD RoutingSession::GetStartPoint() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_checkpoints.GetStart();
 }
 
 m2::PointD RoutingSession::GetEndPoint() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_checkpoints.GetFinish();
 }
 
-void RoutingSession::DoReadyCallback::operator()(unique_ptr<Route> route, RouterResultCode e)
+void RoutingSession::DoReadyCallback::operator()(shared_ptr<Route> route, RouterResultCode e)
 {
-  threads::MutexGuard guard(m_routeSessionMutexInner);
-
   ASSERT(m_rs.m_route, ());
-  m_rs.AssignRoute(move(route), e);
+  m_rs.AssignRoute(route, e);
   m_callback(*m_rs.m_route, e);
 }
 
 void RoutingSession::RemoveRoute()
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   SetState(RoutingNotActive);
   m_lastDistance = 0.0;
   m_moveAwayCounter = 0;
@@ -158,12 +150,10 @@ void RoutingSession::RemoveRoute()
 
 void RoutingSession::RebuildRouteOnTrafficUpdate()
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   m2::PointD startPoint;
 
   {
-    // @TODO(bykoianko) After moving all routing callbacks to single thread this guard can be
-    // removed.
-    threads::MutexGuard guard(m_routingSessionMutex);
     startPoint = m_lastGoodPosition;
 
     switch (m_state)
@@ -192,78 +182,79 @@ void RoutingSession::RebuildRouteOnTrafficUpdate()
 
 bool RoutingSession::IsActive() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return (m_state != RoutingNotActive);
 }
 
 bool RoutingSession::IsNavigable() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return IsNavigableImpl();
 }
 
 bool RoutingSession::IsBuilt() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return (IsNavigableImpl() || m_state == RouteNeedRebuild);
 }
 
 bool RoutingSession::IsBuilding() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return (m_state == RouteBuilding || m_state == RouteRebuilding);
 }
 
 bool RoutingSession::IsBuildingOnly() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_state == RouteBuilding;
 }
 
 bool RoutingSession::IsRebuildingOnly() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_state == RouteRebuilding;
 }
 
 bool RoutingSession::IsNotReady() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_state == RouteNotReady;
 }
 
 bool RoutingSession::IsFinished() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_state == RouteFinished;
 }
 
 bool RoutingSession::IsNoFollowing() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_state == RouteNoFollowing;
 }
 
 bool RoutingSession::IsOnRoute() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return (m_state == OnRoute);
 }
 
 bool RoutingSession::IsFollowing() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_isFollowing;
 }
 
 void RoutingSession::Reset()
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ResetImpl();
 }
 
 void RoutingSession::ResetImpl()
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_router != nullptr, ());
 
   RemoveRoute();
@@ -281,7 +272,7 @@ void RoutingSession::ResetImpl()
 RoutingSession::State RoutingSession::OnLocationPositionChanged(GpsInfo const & info,
                                                                 DataSource const & dataSource)
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_state != RoutingNotActive, ());
   ASSERT(m_router != nullptr, ());
 
@@ -376,7 +367,7 @@ RoutingSession::State RoutingSession::OnLocationPositionChanged(GpsInfo const &
 
 void RoutingSession::GetRouteFollowingInfo(FollowingInfo & info) const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
 
   ASSERT(m_route, ());
 
@@ -448,6 +439,7 @@ void RoutingSession::GetRouteFollowingInfo(FollowingInfo & info) const
 
 double RoutingSession::GetCompletionPercent() const
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_route, ());
 
   double const denominator = m_passedDistanceOnRouteMeters + m_route->GetTotalDistanceMeters();
@@ -471,6 +463,7 @@ double RoutingSession::GetCompletionPercent() const
 
 void RoutingSession::PassCheckpoints()
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   while (!m_checkpoints.IsFinished() && m_route->IsSubroutePassed(m_checkpoints.GetPassedIdx()))
   {
     m_route->PassNextSubroute();
@@ -482,10 +475,9 @@ void RoutingSession::PassCheckpoints()
 
 void RoutingSession::GenerateTurnNotifications(vector<string> & turnNotifications)
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   turnNotifications.clear();
 
-  threads::MutexGuard guard(m_routingSessionMutex);
-
   ASSERT(m_route, ());
 
   // Voice turn notifications.
@@ -500,8 +492,9 @@ void RoutingSession::GenerateTurnNotifications(vector<string> & turnNotification
     m_turnNotificationsMgr.GenerateTurnNotifications(turns, turnNotifications);
 }
 
-void RoutingSession::AssignRoute(unique_ptr<Route> route, RouterResultCode e)
+void RoutingSession::AssignRoute(shared_ptr<Route> route, RouterResultCode e)
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   if (e != RouterResultCode::Cancelled)
   {
     if (route->IsValid())
@@ -520,7 +513,7 @@ void RoutingSession::AssignRoute(unique_ptr<Route> route, RouterResultCode e)
   ASSERT(m_route, ());
 
   route->SetRoutingSettings(m_routingSettings);
-  m_route = move(route);
+  m_route = route;
   m_lastWarnedSpeedCameraIndex = 0;
   m_lastCheckedSpeedCameraIndex = 0;
   m_lastFoundCamera = SpeedCameraRestriction();
@@ -529,7 +522,7 @@ void RoutingSession::AssignRoute(unique_ptr<Route> route, RouterResultCode e)
 void RoutingSession::SetRouter(unique_ptr<IRouter> && router,
                                unique_ptr<OnlineAbsentCountriesFetcher> && fetcher)
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_router != nullptr, ());
   ResetImpl();
   m_router->SetRouter(move(router), move(fetcher));
@@ -538,11 +531,10 @@ void RoutingSession::SetRouter(unique_ptr<IRouter> && router,
 void RoutingSession::MatchLocationToRoute(location::GpsInfo & location,
                                           location::RouteMatchingInfo & routeMatchingInfo) const
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   if (!IsOnRoute())
     return;
 
-  threads::MutexGuard guard(m_routingSessionMutex);
-
   ASSERT(m_route, ());
 
   m_route->MatchLocationToRoute(location, routeMatchingInfo);
@@ -551,19 +543,19 @@ void RoutingSession::MatchLocationToRoute(location::GpsInfo & location,
 traffic::SpeedGroup RoutingSession::MatchTraffic(
     location::RouteMatchingInfo const & routeMatchingInfo) const
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   if (!routeMatchingInfo.IsMatched())
     return SpeedGroup::Unknown;
 
   size_t const index = routeMatchingInfo.GetIndexInRoute();
-  threads::MutexGuard guard(m_routingSessionMutex);
 
   return m_route->GetTraffic(index);
 }
 
 bool RoutingSession::DisableFollowMode()
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   LOG(LINFO, ("Routing disables a following mode. State: ", m_state));
-  threads::MutexGuard guard(m_routingSessionMutex);
   if (m_state == RouteNotStarted || m_state == OnRoute)
   {
     SetState(RouteNoFollowing);
@@ -575,8 +567,8 @@ bool RoutingSession::DisableFollowMode()
 
 bool RoutingSession::EnableFollowMode()
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   LOG(LINFO, ("Routing enables a following mode. State: ", m_state));
-  threads::MutexGuard guard(m_routingSessionMutex);
   if (m_state == RouteNotStarted || m_state == OnRoute)
   {
     SetState(OnRoute);
@@ -587,7 +579,7 @@ bool RoutingSession::EnableFollowMode()
 
 void RoutingSession::SetRoutingSettings(RoutingSettings const & routingSettings)
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   m_routingSettings = routingSettings;
 }
 
@@ -596,6 +588,7 @@ void RoutingSession::SetReadyCallbacks(ReadyCallback const & buildReadyCallback,
                                        NeedMoreMapsCallback const & needMoreMapsCallback,
                                        RemoveRouteCallback const & removeRouteCallback)
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   m_buildReadyCallback = buildReadyCallback;
   // m_rebuildReadyCallback used from multiple threads but it's the only place we write m_rebuildReadyCallback
   // and this method is called from RoutingManager constructor before it can be used from any other place.
@@ -611,17 +604,19 @@ void RoutingSession::SetReadyCallbacks(ReadyCallback const & buildReadyCallback,
 
 void RoutingSession::SetProgressCallback(ProgressCallback const & progressCallback)
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   m_progressCallback = progressCallback;
 }
 
 void RoutingSession::SetCheckpointCallback(CheckpointCallback const & checkpointCallback)
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   m_checkpointCallback = checkpointCallback;
 }
 
 void RoutingSession::SetUserCurrentPosition(m2::PointD const & position)
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   // All methods which read/write m_userCurrentPosition*, m_userFormerPosition*  work in RoutingManager thread
   m_userFormerPosition = m_userCurrentPosition;
   m_userFormerPositionValid = m_userCurrentPositionValid;
@@ -632,38 +627,39 @@ void RoutingSession::SetUserCurrentPosition(m2::PointD const & position)
 
 void RoutingSession::EnableTurnNotifications(bool enable)
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   m_turnNotificationsMgr.Enable(enable);
 }
 
 bool RoutingSession::AreTurnNotificationsEnabled() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_turnNotificationsMgr.IsEnabled();
 }
 
 void RoutingSession::SetTurnNotificationsUnits(measurement_utils::Units const units)
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   m_turnNotificationsMgr.SetLengthUnits(units);
 }
 
 void RoutingSession::SetTurnNotificationsLocale(string const & locale)
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   LOG(LINFO, ("The language for turn notifications is", locale));
-  threads::MutexGuard guard(m_routingSessionMutex);
   m_turnNotificationsMgr.SetLocale(locale);
 }
 
 string RoutingSession::GetTurnNotificationsLocale() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_turnNotificationsMgr.GetLocale();
 }
 
 double RoutingSession::GetDistanceToCurrentCamM(SpeedCameraRestriction & camera,
                                                 DataSource const & dataSource)
 {
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_route, ());
 
   auto const & m_poly = m_route->GetFollowedPolyline();
@@ -691,14 +687,14 @@ double RoutingSession::GetDistanceToCurrentCamM(SpeedCameraRestriction & camera,
 
 void RoutingSession::ProtectedCall(RouteCallback const & callback) const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   CHECK(m_route, ());
   callback(*m_route);
 }
 
 void RoutingSession::EmitCloseRoutingEvent() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_route, ());
 
   if (!m_route->IsValid())
@@ -720,21 +716,21 @@ void RoutingSession::EmitCloseRoutingEvent() const
 
 bool RoutingSession::HasRouteAltitude() const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_route, ());
   return m_route->HaveAltitudes();
 }
 
 bool RoutingSession::IsRouteId(uint64_t routeId) const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return m_route->IsRouteId(routeId);
 }
 
 bool RoutingSession::GetRouteAltitudesAndDistancesM(vector<double> & routeSegDistanceM,
                                                     feature::TAltitudes & routeAltitudesM) const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   ASSERT(m_route, ());
 
   if (!m_route->IsValid() || !m_route->HaveAltitudes())
@@ -748,48 +744,49 @@ bool RoutingSession::GetRouteAltitudesAndDistancesM(vector<double> & routeSegDis
 
 void RoutingSession::OnTrafficInfoClear()
 {
-  {
-    threads::MutexGuard guard(m_routingSessionMutex);
-    Clear();
-  }
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
+  Clear();
   RebuildRouteOnTrafficUpdate();
 }
 
 void RoutingSession::OnTrafficInfoAdded(TrafficInfo && info)
 {
   TrafficInfo::Coloring const & fullColoring = info.GetColoring();
-  TrafficInfo::Coloring coloring;
+  auto coloring = make_shared<TrafficInfo::Coloring>();
   for (auto const & kv : fullColoring)
   {
     ASSERT_NOT_EQUAL(kv.second, SpeedGroup::Unknown, ());
-    coloring.insert(kv);
+    coloring->insert(kv);
   }
 
-  {
-    threads::MutexGuard guard(m_routingSessionMutex);
-    Set(info.GetMwmId(), move(coloring));
-  }
-  RebuildRouteOnTrafficUpdate();
+  // Note. |coloring| should not be used after this call on gui thread.
+  auto const mwmId = info.GetMwmId();
+  GetPlatform().RunTask(Platform::Thread::Gui, [this, mwmId, coloring]() {
+    Set(mwmId, coloring);
+    RebuildRouteOnTrafficUpdate();
+  });
 }
 
 void RoutingSession::OnTrafficInfoRemoved(MwmSet::MwmId const & mwmId)
 {
-  {
-    threads::MutexGuard guard(m_routingSessionMutex);
+  GetPlatform().RunTask(Platform::Thread::Gui, [this, mwmId]() {
+    CHECK_THREAD_CHECKER(m_threadChecker, ());
     Remove(mwmId);
-  }
-  RebuildRouteOnTrafficUpdate();
+    RebuildRouteOnTrafficUpdate();
+  });
 }
 
 shared_ptr<TrafficInfo::Coloring> RoutingSession::GetTrafficInfo(MwmSet::MwmId const & mwmId) const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  CHECK_THREAD_CHECKER(m_threadChecker, ());
   return TrafficCache::GetTrafficInfo(mwmId);
 }
 
 void RoutingSession::CopyTraffic(std::map<MwmSet::MwmId, std::shared_ptr<traffic::TrafficInfo::Coloring>> & trafficColoring) const
 {
-  threads::MutexGuard guard(m_routingSessionMutex);
+  // @TODO(bykoianko) Should be called form gui thread before CalculateRoute() to prepare
+  // traffic jams for routing.
+//  CHECK_THREAD_CHECKER(m_threadChecker, ());
   TrafficCache::CopyTraffic(trafficColoring);
 }
 
diff --git a/routing/routing_session.hpp b/routing/routing_session.hpp
index 3478018b76..253ca40285 100644
--- a/routing/routing_session.hpp
+++ b/routing/routing_session.hpp
@@ -18,6 +18,7 @@
 #include "geometry/polyline2d.hpp"
 
 #include "base/mutex.hpp"
+#include "base/thread_checker.hpp"
 
 #include "std/functional.hpp"
 #include "std/limits.hpp"
@@ -43,6 +44,9 @@ struct SpeedCameraRestriction
   SpeedCameraRestriction() : m_index(0), m_maxSpeedKmH(numeric_limits<uint8_t>::max()) {}
 };
 
+/// \breaf This class is responsible for the route built in the program.
+/// \note All method of this class should be called from ui thread if there's no
+/// a special note near a method.
 class RoutingSession : public traffic::TrafficObserver, public traffic::TrafficCache
 {
   friend void UnitTest_TestFollowRoutePercentTest();
@@ -167,7 +171,9 @@ public:
 
   // RoutingObserver overrides:
   void OnTrafficInfoClear() override;
+  /// \note. This method may be called from any thread.
   void OnTrafficInfoAdded(traffic::TrafficInfo && info) override;
+  /// \note. This method may be called from any thread.
   void OnTrafficInfoRemoved(MwmSet::MwmId const & mwmId) override;
 
   // TrafficCache overrides:
@@ -181,19 +187,17 @@ private:
   {
     RoutingSession & m_rs;
     ReadyCallback m_callback;
-    threads::Mutex & m_routeSessionMutexInner;
 
-    DoReadyCallback(RoutingSession & rs, ReadyCallback const & cb,
-                    threads::Mutex & routeSessionMutex)
-        : m_rs(rs), m_callback(cb), m_routeSessionMutexInner(routeSessionMutex)
+    DoReadyCallback(RoutingSession & rs, ReadyCallback const & cb)
+        : m_rs(rs), m_callback(cb)
     {
     }
 
-    void operator()(unique_ptr<Route> route, RouterResultCode e);
+    void operator()(shared_ptr<Route> route, RouterResultCode e);
   };
 
   // Should be called with locked m_routingSessionMutex.
-  void AssignRoute(unique_ptr<Route> route, RouterResultCode e);
+  void AssignRoute(shared_ptr<Route> route, RouterResultCode e);
 
   /// Returns a nearest speed camera record on your way and distance to it.
   /// Returns kInvalidSpeedCameraDistance if there is no cameras on your way.
@@ -215,7 +219,7 @@ private:
 
 private:
   unique_ptr<AsyncRouter> m_router;
-  unique_ptr<Route> m_route;
+  shared_ptr<Route> m_route;
   State m_state;
   bool m_isFollowing;
   Checkpoints m_checkpoints;
@@ -229,9 +233,6 @@ private:
   /// about camera will be sent at most once.
   mutable bool m_speedWarningSignal;
 
-  /// |m_routingSessionMutex| should be used for access to all members of RoutingSession class.
-  mutable threads::Mutex m_routingSessionMutex;
-
   /// Current position metrics to check for RouteNeedRebuild state.
   double m_lastDistance;
   int m_moveAwayCounter;
@@ -261,6 +262,8 @@ private:
   // Rerouting count
   int m_routingRebuildCount;
   mutable double m_lastCompletionPercent;
+
+  DECLARE_THREAD_CHECKER(m_threadChecker);
 };
 
 void FormatDistance(double dist, string & value, string & suffix);
diff --git a/routing/routing_tests/async_router_test.cpp b/routing/routing_tests/async_router_test.cpp
index 29e09aa8c5..69754fad05 100644
--- a/routing/routing_tests/async_router_test.cpp
+++ b/routing/routing_tests/async_router_test.cpp
@@ -7,6 +7,8 @@
 
 #include "geometry/point2d.hpp"
 
+#include "platform/platform.hpp"
+
 #include "base/timer.hpp"
 
 #include "std/condition_variable.hpp"
@@ -71,7 +73,7 @@ struct DummyResultCallback
   explicit DummyResultCallback(uint32_t expectedCalls) : m_expected(expectedCalls), m_called(0) {}
 
   // ReadyCallbackOwnership callback
-  void operator()(unique_ptr<Route> route, RouterResultCode code)
+  void operator()(shared_ptr<Route> route, RouterResultCode code)
   {
     CHECK(route, ());
     m_codes.push_back(code);
@@ -130,7 +132,7 @@ UNIT_TEST(NeedMoreMapsSignalTest)
   TEST_EQUAL(resultCallback.m_absent[1], absentData, ());
 }
 
-UNIT_TEST(StandartAsyncFogTest)
+UNIT_TEST(StandardAsyncFogTest)
 {
   unique_ptr<IOnlineFetcher> fetcher(new DummyFetcher({}));
   unique_ptr<IRouter> router(new DummyRouter(RouterResultCode::NoError, {}));
diff --git a/traffic/traffic_cache.cpp b/traffic/traffic_cache.cpp
index e09cfd34bb..0819fd207e 100644
--- a/traffic/traffic_cache.cpp
+++ b/traffic/traffic_cache.cpp
@@ -4,9 +4,9 @@ namespace traffic
 {
 using namespace std;
 
-void TrafficCache::Set(MwmSet::MwmId const & mwmId, TrafficInfo::Coloring && coloring)
+void TrafficCache::Set(MwmSet::MwmId const & mwmId, shared_ptr<TrafficInfo::Coloring> coloring)
 {
-  m_trafficColoring[mwmId] = make_shared<TrafficInfo::Coloring>(move(coloring));
+  m_trafficColoring[mwmId] = coloring;
 }
 
 void TrafficCache::Remove(MwmSet::MwmId const & mwmId) { m_trafficColoring.erase(mwmId); }
diff --git a/traffic/traffic_cache.hpp b/traffic/traffic_cache.hpp
index 9cfb20ac36..815d701a71 100644
--- a/traffic/traffic_cache.hpp
+++ b/traffic/traffic_cache.hpp
@@ -22,7 +22,7 @@ public:
       const;
 
 protected:
-  void Set(MwmSet::MwmId const & mwmId, TrafficInfo::Coloring && mwmIdAndColoring);
+  void Set(MwmSet::MwmId const & mwmId, std::shared_ptr<TrafficInfo::Coloring> coloring);
   void Remove(MwmSet::MwmId const & mwmId);
   void Clear();