diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index 4db2d97631..b17b4b5065 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -26,6 +26,7 @@ BackendRenderer::BackendRenderer(Params const & params)
   : BaseRenderer(ThreadsCommutator::ResourceUploadThread, params)
   , m_model(params.m_model)
   , m_readManager(make_unique_dp<ReadManager>(params.m_commutator, m_model))
+  , m_requestedTiles(params.m_requestedTiles)
 {
   gui::DrapeGui::Instance().SetRecacheCountryStatusSlot([this]()
   {
@@ -80,17 +81,18 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
   {
   case Message::UpdateReadManager:
     {
-      ref_ptr<UpdateReadManagerMessage> msg = message;
-      ScreenBase const & screen = msg->GetScreen();
-      TTilesCollection const & tiles = msg->GetTiles();
-      m_readManager->UpdateCoverage(screen, tiles, m_texMng);
-
-      gui::CountryStatusHelper & helper = gui::DrapeGui::Instance().GetCountryStatusHelper();
-      if (!tiles.empty() && (*tiles.begin()).m_zoomLevel > scales::GetUpperWorldScale())
-        m_model.UpdateCountryIndex(helper.GetCountryIndex(), screen.ClipRect().Center());
-      else
-        helper.Clear();
+      TTilesCollection tiles = m_requestedTiles->GetTiles();
+      if (!tiles.empty())
+      {
+        ScreenBase screen = m_requestedTiles->GetScreen();
+        m_readManager->UpdateCoverage(screen, tiles, m_texMng);
 
+        gui::CountryStatusHelper & helper = gui::DrapeGui::Instance().GetCountryStatusHelper();
+        if ((*tiles.begin()).m_zoomLevel > scales::GetUpperWorldScale())
+          m_model.UpdateCountryIndex(helper.GetCountryIndex(), screen.ClipRect().Center());
+        else
+          helper.Clear();
+      }
       break;
     }
   case Message::InvalidateReadManagerRect:
@@ -141,9 +143,13 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
   case Message::MapShapeReaded:
     {
       ref_ptr<MapShapeReadedMessage> msg = message;
-      ref_ptr<dp::Batcher> batcher = m_batchersPool->GetTileBatcher(msg->GetKey());
-      for (drape_ptr<MapShape> const & shape : msg->GetShapes())
-        shape->Draw(batcher, m_texMng);
+      auto const & tileKey = msg->GetKey();
+      if (m_requestedTiles->CheckTileKey(tileKey) && m_readManager->CheckTileKey(tileKey))
+      {
+        ref_ptr<dp::Batcher> batcher = m_batchersPool->GetTileBatcher(tileKey);
+        for (drape_ptr<MapShape> const & shape : msg->GetShapes())
+          shape->Draw(batcher, m_texMng);
+      }
       break;
     }
   case Message::UpdateUserMarkLayer:
diff --git a/drape_frontend/backend_renderer.hpp b/drape_frontend/backend_renderer.hpp
index faa545b65a..42505baf11 100644
--- a/drape_frontend/backend_renderer.hpp
+++ b/drape_frontend/backend_renderer.hpp
@@ -4,6 +4,7 @@
 
 #include "drape_frontend/base_renderer.hpp"
 #include "drape_frontend/map_data_provider.hpp"
+#include "drape_frontend/requested_tiles.hpp"
 #include "drape_frontend/viewport.hpp"
 
 #include "drape/pointers.hpp"
@@ -30,12 +31,15 @@ public:
   struct Params : BaseRenderer::Params
   {
     Params(ref_ptr<ThreadsCommutator> commutator, ref_ptr<dp::OGLContextFactory> factory,
-           ref_ptr<dp::TextureManager> texMng, MapDataProvider const & model)
+           ref_ptr<dp::TextureManager> texMng, MapDataProvider const & model,
+           ref_ptr<RequestedTiles> requestedTiles)
       : BaseRenderer::Params(commutator, factory, texMng)
       , m_model(model)
+      , m_requestedTiles(requestedTiles)
     {}
 
     MapDataProvider const & m_model;
+    ref_ptr<RequestedTiles> m_requestedTiles;
   };
 
   BackendRenderer(Params const & params);
@@ -73,6 +77,8 @@ private:
   drape_ptr<ReadManager> m_readManager;
   drape_ptr<RouteBuilder> m_routeBuilder;
   gui::LayerCacher m_guiCacher;
+
+  ref_ptr<RequestedTiles> m_requestedTiles;
 };
 
 } // namespace df
diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index 7d77d1fac1..e746532a78 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -49,6 +49,7 @@ DrapeEngine::DrapeEngine(Params && params)
 
   m_textureManager = make_unique_dp<dp::TextureManager>();
   m_threadCommutator = make_unique_dp<ThreadsCommutator>();
+  m_requestedTiles = make_unique_dp<RequestedTiles>();
 
   location::EMyPositionMode mode = params.m_initialMyPositionMode.first;
   if (!params.m_initialMyPositionMode.second && !Settings::Get(LocationStateMode, mode))
@@ -61,12 +62,12 @@ DrapeEngine::DrapeEngine(Params && params)
                                     bind(&DrapeEngine::TapEvent, this, _1, _2, _3, _4),
                                     bind(&DrapeEngine::UserPositionChanged, this, _1),
                                     bind(&DrapeEngine::MyPositionModeChanged, this, _1),
-                                    mode);
+                                    mode, make_ref(m_requestedTiles));
 
   m_frontend = make_unique_dp<FrontendRenderer>(frParams);
 
   BackendRenderer::Params brParams(frParams.m_commutator, frParams.m_oglContextFactory,
-                                   frParams.m_texMng, params.m_model);
+                                   frParams.m_texMng, params.m_model, make_ref(m_requestedTiles));
   m_backend = make_unique_dp<BackendRenderer>(brParams);
 
   m_widgetsInfo = move(params.m_info);
diff --git a/drape_frontend/drape_engine.hpp b/drape_frontend/drape_engine.hpp
index 437341f822..c7b10e4e5b 100644
--- a/drape_frontend/drape_engine.hpp
+++ b/drape_frontend/drape_engine.hpp
@@ -130,6 +130,7 @@ private:
   drape_ptr<BackendRenderer> m_backend;
   drape_ptr<ThreadsCommutator> m_threadCommutator;
   drape_ptr<dp::TextureManager> m_textureManager;
+  drape_ptr<RequestedTiles> m_requestedTiles;
 
   Viewport m_viewport;
 
diff --git a/drape_frontend/drape_frontend.pro b/drape_frontend/drape_frontend.pro
index f0e0740776..e67ab21921 100755
--- a/drape_frontend/drape_frontend.pro
+++ b/drape_frontend/drape_frontend.pro
@@ -55,6 +55,7 @@ SOURCES += \
     read_mwm_task.cpp \
     render_group.cpp \
     render_node.cpp \
+    requested_tiles.cpp \
     route_builder.cpp \
     route_renderer.cpp \
     route_shape.cpp \
@@ -136,6 +137,7 @@ HEADERS += \
     read_mwm_task.hpp \
     render_group.hpp \
     render_node.hpp \
+    requested_tiles.hpp \
     route_builder.hpp \
     route_renderer.hpp \
     route_shape.hpp \
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index ff2310ecfa..fdec5c78e1 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -31,7 +31,7 @@ namespace df
 namespace
 {
 
-const double VSyncInterval = 0.030;
+const double VSyncInterval = 0.06;
 //const double VSyncInterval = 0.014;
 
 } // namespace
@@ -47,9 +47,10 @@ FrontendRenderer::FrontendRenderer(Params const & params)
   , m_tapEventInfoFn(params.m_tapEventFn)
   , m_userPositionChangedFn(params.m_positionChangedFn)
   , m_tileTree(new TileTree())
+  , m_requestedTiles(params.m_requestedTiles)
 {
 #ifdef DRAW_INFO
-  m_tpf = 0,0;
+  m_tpf = 0.0;
   m_fps = 0.0;
 #endif
 
@@ -164,8 +165,9 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
                                   make_unique_dp<InvalidateReadManagerRectMessage>(tiles),
                                   MessagePriority::Normal);
 
+        m_requestedTiles->Set(screen, move(tiles));
         m_commutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
-                                  make_unique_dp<UpdateReadManagerMessage>(screen, move(tiles)),
+                                  make_unique_dp<UpdateReadManagerMessage>(),
                                   MessagePriority::Normal);
       }
       break;
@@ -422,8 +424,9 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
       }
 
       // Request new tiles.
+      m_requestedTiles->Set(screen, move(tiles));
       m_commutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
-                                make_unique_dp<UpdateReadManagerMessage>(screen, move(tiles)),
+                                make_unique_dp<UpdateReadManagerMessage>(),
                                 MessagePriority::Normal);
 
       RefreshBgColor();
@@ -1035,8 +1038,27 @@ void FrontendRenderer::UpdateScene(ScreenBase const & modelView)
   TTilesCollection tiles;
   ResolveTileKeys(modelView, tiles);
 
+  m_overlayTree->ForceUpdate();
+  auto removePredicate = [this](drape_ptr<RenderGroup> const & group)
+  {
+    return group->IsOverlay() && group->GetTileKey().m_zoomLevel > GetCurrentZoomLevel();
+  };
+  for (auto const & group : m_renderGroups)
+  {
+    if (removePredicate(group))
+    {
+      group->DeleteLater();
+      group->Disappear();
+    }
+  }
+  m_deferredRenderGroups.erase(remove_if(m_deferredRenderGroups.begin(),
+                                         m_deferredRenderGroups.end(),
+                                         removePredicate),
+                               m_deferredRenderGroups.end());
+
+  m_requestedTiles->Set(modelView, move(tiles));
   m_commutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
-                            make_unique_dp<UpdateReadManagerMessage>(modelView, move(tiles)),
+                            make_unique_dp<UpdateReadManagerMessage>(),
                             MessagePriority::High);
 }
 
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 45f6cbb7eb..cc4b0ec549 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -15,6 +15,7 @@
 #include "drape_frontend/my_position_controller.hpp"
 #include "drape_frontend/navigator.hpp"
 #include "drape_frontend/render_group.hpp"
+#include "drape_frontend/requested_tiles.hpp"
 #include "drape_frontend/route_renderer.hpp"
 #include "drape_frontend/threads_commutator.hpp"
 #include "drape_frontend/tile_info.hpp"
@@ -76,7 +77,8 @@ public:
            TTapEventInfoFn const & tapEventFn,
            TUserPositionChangedFn const & positionChangedFn,
            location::TMyPositionModeChanged myPositionModeCallback,
-           location::EMyPositionMode initMode)
+           location::EMyPositionMode initMode,
+           ref_ptr<RequestedTiles> requestedTiles)
       : BaseRenderer::Params(commutator, factory, texMng)
       , m_viewport(viewport)
       , m_modelViewChangedFn(modelViewChangedFn)
@@ -85,6 +87,7 @@ public:
       , m_positionChangedFn(positionChangedFn)
       , m_myPositionModeCallback(myPositionModeCallback)
       , m_initMyPositionMode(initMode)
+      , m_requestedTiles(requestedTiles)
     {}
 
     Viewport m_viewport;
@@ -94,6 +97,7 @@ public:
     TUserPositionChangedFn m_positionChangedFn;
     location::TMyPositionModeChanged m_myPositionModeCallback;
     location::EMyPositionMode m_initMyPositionMode;
+    ref_ptr<RequestedTiles> m_requestedTiles;
   };
 
   FrontendRenderer(Params const & params);
@@ -161,13 +165,13 @@ private:
 
   class Routine : public threads::IRoutine
   {
-   public:
+  public:
     Routine(FrontendRenderer & renderer);
 
     // threads::IRoutine overrides:
     void Do() override;
 
-   private:
+  private:
     FrontendRenderer & m_renderer;
   };
 
@@ -219,6 +223,7 @@ private:
 
   unique_ptr<TileTree> m_tileTree;
   int m_currentZoomLevel = -1;
+  ref_ptr<RequestedTiles> m_requestedTiles;
 };
 
 } // namespace df
diff --git a/drape_frontend/message_acceptor.cpp b/drape_frontend/message_acceptor.cpp
index e09e47e148..21fb3dba7c 100644
--- a/drape_frontend/message_acceptor.cpp
+++ b/drape_frontend/message_acceptor.cpp
@@ -45,9 +45,14 @@ bool MessageAcceptor::IsInInfinityWaiting() const
   return m_infinityWaiting;
 }
 
-bool MessageAcceptor::IsQueueEmpty()
+bool MessageAcceptor::IsQueueEmpty() const
 {
   return m_messageQueue.IsEmpty();
 }
 
+bool MessageAcceptor::GetQueueSize() const
+{
+  return m_messageQueue.GetSize();
+}
+
 } // namespace df
diff --git a/drape_frontend/message_acceptor.hpp b/drape_frontend/message_acceptor.hpp
index c3bdfe2f66..a63cd1d7f2 100644
--- a/drape_frontend/message_acceptor.hpp
+++ b/drape_frontend/message_acceptor.hpp
@@ -28,7 +28,8 @@ protected:
   void CloseQueue();
 
   bool IsInInfinityWaiting() const;
-  bool IsQueueEmpty();
+  bool IsQueueEmpty() const;
+  bool GetQueueSize() const;
 
 private:
   friend class ThreadsCommutator;
diff --git a/drape_frontend/message_queue.cpp b/drape_frontend/message_queue.cpp
index 6b22769287..d661d17737 100644
--- a/drape_frontend/message_queue.cpp
+++ b/drape_frontend/message_queue.cpp
@@ -60,12 +60,18 @@ void MessageQueue::PushMessage(drape_ptr<Message> && message, MessagePriority pr
   CancelWaitImpl();
 }
 
-bool MessageQueue::IsEmpty()
+bool MessageQueue::IsEmpty() const
 {
   lock_guard<mutex> lock(m_mutex);
   return m_messages.empty();
 }
 
+size_t MessageQueue::GetSize() const
+{
+  lock_guard<mutex> lock(m_mutex);
+  return m_messages.size();
+}
+
 void MessageQueue::CancelWait()
 {
   lock_guard<mutex> lock(m_mutex);
diff --git a/drape_frontend/message_queue.hpp b/drape_frontend/message_queue.hpp
index 5eef064ad6..dee9cd1b7d 100644
--- a/drape_frontend/message_queue.hpp
+++ b/drape_frontend/message_queue.hpp
@@ -24,12 +24,13 @@ public:
   void PushMessage(drape_ptr<Message> && message, MessagePriority priority);
   void CancelWait();
   void ClearQuery();
-  bool IsEmpty();
+  bool IsEmpty() const;
+  size_t GetSize() const;
 
 private:
   void CancelWaitImpl();
 
-  mutex m_mutex;
+  mutable mutex m_mutex;
   condition_variable m_condition;
   bool m_isWaiting;
   deque<drape_ptr<Message> > m_messages;
diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp
index 586ccec0aa..2e08a2ebc8 100644
--- a/drape_frontend/message_subclasses.hpp
+++ b/drape_frontend/message_subclasses.hpp
@@ -154,19 +154,8 @@ private:
 class UpdateReadManagerMessage : public Message
 {
 public:
-  UpdateReadManagerMessage(ScreenBase const & screen, TTilesCollection && tiles)
-    : m_tiles(move(tiles))
-    , m_screen(screen)
-  {}
-
+  UpdateReadManagerMessage(){}
   Type GetType() const override { return Message::UpdateReadManager; }
-
-  TTilesCollection const & GetTiles() const { return m_tiles; }
-  ScreenBase const & GetScreen() const { return m_screen; }
-
-private:
-  TTilesCollection m_tiles;
-  ScreenBase m_screen;
 };
 
 class InvalidateReadManagerRectMessage : public Message
diff --git a/drape_frontend/path_text_shape.cpp b/drape_frontend/path_text_shape.cpp
index 03f42e75e4..cc43581112 100644
--- a/drape_frontend/path_text_shape.cpp
+++ b/drape_frontend/path_text_shape.cpp
@@ -40,7 +40,6 @@ public:
   {
     m_centerPointIter = m_spline.CreateIterator();
     m_centerPointIter.Advance(mercatorOffset);
-    m_normals.resize(4 * m_layout->GetGlyphCount());
   }
 
   bool Update(ScreenBase const & screen) override
@@ -48,6 +47,9 @@ public:
     if (!df::TextHandle::Update(screen))
       return false;
 
+    if (m_normals.empty())
+      m_normals.resize(4 * m_layout->GetGlyphCount());
+
     return m_layout->CacheDynamicGeometry(m_centerPointIter, screen, m_normals);
   }
 
diff --git a/drape_frontend/read_manager.cpp b/drape_frontend/read_manager.cpp
index 29ca1bae37..39f91ff588 100755
--- a/drape_frontend/read_manager.cpp
+++ b/drape_frontend/read_manager.cpp
@@ -139,6 +139,15 @@ void ReadManager::Stop()
   m_pool.reset();
 }
 
+bool ReadManager::CheckTileKey(TileKey const & tileKey) const
+{
+  for (auto const & tileInfo : m_tileInfos)
+    if (tileInfo->GetTileKey() == tileKey)
+      return !tileInfo->IsCancelled();
+
+  return false;
+}
+
 size_t ReadManager::ReadCount()
 {
   return max(static_cast<int>(GetPlatform().CpuCores()) - 2, 1);
diff --git a/drape_frontend/read_manager.hpp b/drape_frontend/read_manager.hpp
index 600986c4d3..0e33c9656a 100755
--- a/drape_frontend/read_manager.hpp
+++ b/drape_frontend/read_manager.hpp
@@ -34,6 +34,8 @@ public:
   void Invalidate(TTilesCollection const & keyStorage);
   void Stop();
 
+  bool CheckTileKey(TileKey const & tileKey) const;
+
   static size_t ReadCount();
 
 private:
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index f1e3cb6b29..f14cfa3ef1 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -34,6 +34,11 @@ void BaseRenderGroup::Render(const ScreenBase &)
   dp::ApplyUniforms(*(m_generalUniforms.get()), m_shader);
 }
 
+bool BaseRenderGroup::IsOverlay() const
+{
+  return m_state.GetDepthLayer() == dp::GLState::OverlayLayer;
+}
+
 RenderGroup::RenderGroup(dp::GLState const & state, df::TileKey const & tileKey)
   : TBase(state, tileKey)
   , m_pendingOnDelete(false)
@@ -139,21 +144,23 @@ bool RenderGroup::IsAnimating() const
 
 void RenderGroup::Appear()
 {
-  if (m_state.GetDepthLayer() == dp::GLState::OverlayLayer)
-  {
-    m_appearAnimation = make_unique<OpacityAnimation>(0.25 /* duration */, 0.0 /* delay */,
-                                                      0.0 /* startOpacity */, 1.0 /* endOpacity */);
-  }
+  // Commented because of perfomance reasons.
+  //if (IsOverlay())
+  //{
+  //  m_appearAnimation = make_unique<OpacityAnimation>(0.25 /* duration */, 0.0 /* delay */,
+  //                                                    0.0 /* startOpacity */, 1.0 /* endOpacity */);
+  //}
 }
 
 void RenderGroup::Disappear()
 {
-  if (m_state.GetDepthLayer() == dp::GLState::OverlayLayer)
-  {
-    m_disappearAnimation = make_unique<OpacityAnimation>(0.1 /* duration */, 0.1 /* delay */,
-                                                         1.0 /* startOpacity */, 0.0 /* endOpacity */);
-  }
-  else
+  // Commented because of perfomance reasons.
+  //if (IsOverlay())
+  //{
+  //  m_disappearAnimation = make_unique<OpacityAnimation>(0.1 /* duration */, 0.1 /* delay */,
+  //                                                       1.0 /* startOpacity */, 0.0 /* endOpacity */);
+  //}
+  //else
   {
     // Create separate disappearing animation for area objects to eliminate flickering.
     if (m_state.GetProgramIndex() == gpu::AREA_PROGRAM)
diff --git a/drape_frontend/render_group.hpp b/drape_frontend/render_group.hpp
index 815a0d8e75..8d8250cd33 100755
--- a/drape_frontend/render_group.hpp
+++ b/drape_frontend/render_group.hpp
@@ -30,6 +30,7 @@ public:
   dp::GLState const & GetState() const { return m_state; }
   TileKey const & GetTileKey() const { return m_tileKey; }
   dp::UniformValuesStorage const & GetUniforms() const { return m_uniforms; }
+  bool IsOverlay() const;
 
   virtual void UpdateAnimation();
   virtual void Render(ScreenBase const & /*screen*/);
diff --git a/drape_frontend/requested_tiles.cpp b/drape_frontend/requested_tiles.cpp
new file mode 100755
index 0000000000..76d0cf4bfe
--- /dev/null
+++ b/drape_frontend/requested_tiles.cpp
@@ -0,0 +1,38 @@
+#include "drape_frontend/requested_tiles.hpp"
+
+namespace df
+{
+
+void RequestedTiles::Set(ScreenBase const & screen, TTilesCollection && tiles)
+{
+  lock_guard<mutex> lock(m_mutex);
+  m_tiles = move(tiles);
+  m_screen = screen;
+}
+
+TTilesCollection RequestedTiles::GetTiles()
+{
+  TTilesCollection tiles;
+  {
+    lock_guard<mutex> lock(m_mutex);
+    m_tiles.swap(tiles);
+  }
+  return tiles;
+}
+
+ScreenBase RequestedTiles::GetScreen()
+{
+  lock_guard<mutex> lock(m_mutex);
+  return m_screen;
+}
+
+bool RequestedTiles::CheckTileKey(TileKey const & tileKey) const
+{
+  lock_guard<mutex> lock(m_mutex);
+  if (m_tiles.empty())
+    return true;
+
+  return m_tiles.find(tileKey) != m_tiles.end();
+}
+
+} //namespace df
diff --git a/drape_frontend/requested_tiles.hpp b/drape_frontend/requested_tiles.hpp
new file mode 100755
index 0000000000..c9bbd22d69
--- /dev/null
+++ b/drape_frontend/requested_tiles.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "drape_frontend/tile_utils.hpp"
+
+#include "geometry/screenbase.hpp"
+
+#include "std/mutex.hpp"
+
+namespace df
+{
+
+class RequestedTiles
+{
+public:
+  RequestedTiles() = default;
+  void Set(ScreenBase const & screen, TTilesCollection && tiles);
+  TTilesCollection GetTiles();
+  ScreenBase GetScreen();
+  bool CheckTileKey(TileKey const & tileKey) const;
+
+private:
+  TTilesCollection m_tiles;
+  ScreenBase m_screen;
+  mutable mutex m_mutex;
+};
+
+} // namespace df
diff --git a/drape_frontend/rule_drawer.cpp b/drape_frontend/rule_drawer.cpp
index d1d287c865..df0610c99a 100644
--- a/drape_frontend/rule_drawer.cpp
+++ b/drape_frontend/rule_drawer.cpp
@@ -33,10 +33,17 @@ size_t kMinFlushSizes[df::PrioritiesCount] =
   10, // LinePriority
 };
 
-RuleDrawer::RuleDrawer(TDrawerCallback const & fn, ref_ptr<EngineContext> context)
+RuleDrawer::RuleDrawer(TDrawerCallback const & fn,
+                       TCheckCancelledCallback const & checkCancelled,
+                       ref_ptr<EngineContext> context)
   : m_callback(fn)
+  , m_checkCancelled(checkCancelled)
   , m_context(context)
+  , m_wasCancelled(false)
 {
+  ASSERT(m_callback != nullptr, ());
+  ASSERT(m_checkCancelled != nullptr, ());
+
   m_globalRect = m_context->GetTileKey().GetGlobalRect();
 
   int32_t tileSize = df::VisualParams::Instance().GetTileSize();
@@ -50,6 +57,9 @@ RuleDrawer::RuleDrawer(TDrawerCallback const & fn, ref_ptr<EngineContext> contex
 
 RuleDrawer::~RuleDrawer()
 {
+  if (m_wasCancelled)
+    return;
+
   for (auto & shapes : m_mapShapes)
   {
     if (shapes.empty())
@@ -62,6 +72,12 @@ RuleDrawer::~RuleDrawer()
   }
 }
 
+bool RuleDrawer::CheckCancelled()
+{
+  m_wasCancelled = m_checkCancelled();
+  return m_wasCancelled;
+}
+
 void RuleDrawer::operator()(FeatureType const & f)
 {
   Stylist s;
@@ -101,6 +117,9 @@ void RuleDrawer::operator()(FeatureType const & f)
     if (s.PointStyleExists())
       apply(feature::GetCenter(f, zoomLevel));
 
+    if (CheckCancelled())
+      return;
+
     s.ForEachRule(bind(&ApplyAreaFeature::ProcessRule, &apply, _1));
     apply.Finish();
   }
@@ -112,6 +131,9 @@ void RuleDrawer::operator()(FeatureType const & f)
                            f.GetPointsCount());
     f.ForEachPointRef(apply, zoomLevel);
 
+    if (CheckCancelled())
+      return;
+
     if (apply.HasGeometry())
       s.ForEachRule(bind(&ApplyLineFeature::ProcessRule, &apply, _1));
     apply.Finish();
@@ -122,6 +144,9 @@ void RuleDrawer::operator()(FeatureType const & f)
     ApplyPointFeature apply(insertShape, f.GetID(), minVisibleScale, f.GetRank(), s.GetCaptionDescription());
     f.ForEachPointRef(apply, zoomLevel);
 
+    if (CheckCancelled())
+      return;
+
     s.ForEachRule(bind(&ApplyPointFeature::ProcessRule, &apply, _1));
     apply.Finish();
   }
@@ -156,9 +181,12 @@ void RuleDrawer::operator()(FeatureType const & f)
 
   tp.m_primaryTextFont = dp::FontDecl(dp::Color::Red(), 30);
 
-  insertShape(make_unique_dp<TextShape>(r.Center(), tp));
+  insertShape(make_unique_dp<TextShape>(r.Center(), tp, false));
 #endif
 
+  if (CheckCancelled())
+    return;
+
   for (size_t i = 0; i < m_mapShapes.size(); i++)
   {
     if (m_mapShapes[i].size() < kMinFlushSizes[i])
diff --git a/drape_frontend/rule_drawer.hpp b/drape_frontend/rule_drawer.hpp
index 730d56bf61..f6d1bdd610 100644
--- a/drape_frontend/rule_drawer.hpp
+++ b/drape_frontend/rule_drawer.hpp
@@ -25,13 +25,18 @@ class RuleDrawer
 {
 public:
   using TDrawerCallback = function<void (FeatureType const &, Stylist &)>;
-  RuleDrawer(TDrawerCallback const & fn, ref_ptr<EngineContext> context);
+  using TCheckCancelledCallback = function<bool ()>;
+  RuleDrawer(TDrawerCallback const & fn, TCheckCancelledCallback const & checkCancelled,
+             ref_ptr<EngineContext> context);
   ~RuleDrawer();
 
   void operator() (FeatureType const & f);
 
 private:
+  bool CheckCancelled();
+
   TDrawerCallback m_callback;
+  TCheckCancelledCallback m_checkCancelled;
   ref_ptr<EngineContext> m_context;
   m2::RectD m_globalRect;
   ScreenBase m_geometryConvertor;
@@ -39,6 +44,7 @@ private:
   set<string> m_coastlines;
 
   array<TMapShapes, df::PrioritiesCount> m_mapShapes;
+  bool m_wasCancelled;
 };
 
 } // namespace dfo
diff --git a/drape_frontend/tile_info.cpp b/drape_frontend/tile_info.cpp
index 549b30634c..5edae3c672 100644
--- a/drape_frontend/tile_info.cpp
+++ b/drape_frontend/tile_info.cpp
@@ -70,7 +70,9 @@ void TileInfo::ReadFeatures(MapDataProvider const & model, MemoryFeatureIndex &
 
   if (!featuresToRead.empty())
   {
-    RuleDrawer drawer(bind(&TileInfo::InitStylist, this, _1 ,_2), make_ref(m_context));
+    RuleDrawer drawer(bind(&TileInfo::InitStylist, this, _1 ,_2),
+                      bind(&TileInfo::IsCancelled, this),
+                      make_ref(m_context));
     model.ReadFeatures(bind<void>(ref(drawer), _1), featuresToRead);
   }
 }