diff --git a/drape_frontend/read_manager.cpp b/drape_frontend/read_manager.cpp
index 5eb84d879b..b6820cb348 100644
--- a/drape_frontend/read_manager.cpp
+++ b/drape_frontend/read_manager.cpp
@@ -12,165 +12,165 @@
 
 namespace df
 {
-namespace
-{
-struct LessCoverageCell
-{
-  bool operator()(shared_ptr<TileInfo> const & l, TileKey const & r) const
+  namespace
   {
-    return l->GetTileKey() < r;
+    struct LessCoverageCell
+    {
+      bool operator()(shared_ptr<TileInfo> const & l, TileKey const & r) const
+      {
+        return l->GetTileKey() < r;
+      }
+
+      bool operator()(TileKey const & l, shared_ptr<TileInfo> const & r) const
+      {
+        return l < r->GetTileKey();
+      }
+    };
+
+    TileKey TileInfoPtrToTileKey(shared_ptr<TileInfo> const & p)
+    {
+      return p->GetTileKey();
+    }
   }
 
-  bool operator()(TileKey const & l, shared_ptr<TileInfo> const & r) const
+  ReadManager::ReadManager(double visualScale, int w, int h,
+                           EngineContext & context,
+                           model::FeaturesFetcher & model)
+    : m_context(context)
+    , m_model(model)
   {
-    return l < r->GetTileKey();
+    m_scalesProcessor.SetParams(visualScale, ScalesProcessor::CalculateTileSize(w, h));
+    m_pool.Reset(new threads::ThreadPool(ReadCount(), bind(&ReadManager::OnTaskFinished, this, _1)));
   }
-};
 
-TileKey TileInfoPtrToTileKey(shared_ptr<TileInfo> const & p)
-{
-  return p->GetTileKey();
-}
-}
-
-ReadManager::ReadManager(double visualScale, int w, int h,
-                             EngineContext & context,
-                             model::FeaturesFetcher & model)
-  : m_context(context)
-  , m_model(model)
-{
-  m_scalesProcessor.SetParams(visualScale, ScalesProcessor::CalculateTileSize(w, h));
-  m_pool.Reset(new threads::ThreadPool(ReadCount(), bind(&ReadManager::OnTaskFinished, this, _1)));
-}
-
-void ReadManager::OnTaskFinished(threads::IRoutine * task)
-{
-  delete task;
-}
-
-void ReadManager::UpdateCoverage(const ScreenBase & screen, CoverageUpdateDescriptor & updateDescr)
-{
-  if (screen == m_currentViewport)
-    return;
-
-  set<TileKey> tiles;
-  GetTileKeys(tiles, screen);
-
-  if (MustDropAllTiles(screen))
+  void ReadManager::OnTaskFinished(threads::IRoutine * task)
   {
+    delete task;
+  }
+
+  void ReadManager::UpdateCoverage(const ScreenBase & screen, CoverageUpdateDescriptor & updateDescr)
+  {
+    if (screen == m_currentViewport)
+      return;
+
+    set<TileKey> tiles;
+    GetTileKeys(tiles, screen);
+
+    if (MustDropAllTiles(screen))
+    {
       for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::CancelTileInfo, this, _1));
+      m_tileInfos.clear();
+
+      for_each(tiles.begin(), tiles.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1));
+
+      updateDescr.DoDropAll();
+    }
+    else
+    {
+      // Find rects that go out from viewport
+      buffer_vector<tileinfo_ptr, 8> outdatedTiles;
+      set_difference(m_tileInfos.begin(), m_tileInfos.end(),
+                     tiles.begin(), tiles.end(),
+                     back_inserter(outdatedTiles), LessCoverageCell());
+
+      // Find rects that go in into viewport
+      buffer_vector<TileKey, 8> inputRects;
+      set_difference(tiles.begin(), tiles.end(),
+                     m_tileInfos.begin(), m_tileInfos.end(),
+                     back_inserter(inputRects), LessCoverageCell());
+
+      for_each(outdatedTiles.begin(), outdatedTiles.end(), bind(&ReadManager::ClearTileInfo, this, _1));
+
+      buffer_vector<TileKey, 16> outdatedTileKeys;
+      transform(outdatedTiles.begin(), outdatedTiles.end(),
+                back_inserter(outdatedTileKeys), &TileInfoPtrToTileKey);
+
+      updateDescr.DropTiles(outdatedTileKeys.data(), outdatedTileKeys.size());
+
+      for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::PushTaskFront, this, _1));
+      for_each(inputRects.begin(),  inputRects.end(),  bind(&ReadManager::PushTaskBackForTileKey, this, _1));
+    }
+    m_currentViewport = screen;
+  }
+
+  void ReadManager::Resize(const m2::RectI & rect)
+  {
+    m_currentViewport.OnSize(rect);
+  }
+
+  void ReadManager::Stop()
+  {
+    for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::CancelTileInfo, this, _1));
     m_tileInfos.clear();
 
-    for_each(tiles.begin(), tiles.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1));
-
-    updateDescr.DoDropAll();
+    m_pool->Stop();
+    m_pool.Destroy();
   }
-  else
+
+  size_t ReadManager::ReadCount()
   {
-    // Find rects that go out from viewport
-    buffer_vector<tileinfo_ptr, 8> outdatedTiles;
-    set_difference(m_tileInfos.begin(), m_tileInfos.end(),
-                   tiles.begin(), tiles.end(),
-                   back_inserter(outdatedTiles), LessCoverageCell());
-
-    // Find rects that go in into viewport
-    buffer_vector<TileKey, 8> inputRects;
-    set_difference(tiles.begin(), tiles.end(),
-                   m_tileInfos.begin(), m_tileInfos.end(),
-                   back_inserter(inputRects), LessCoverageCell());
-
-    for_each(outdatedTiles.begin(), outdatedTiles.end(), bind(&ReadManager::ClearTileInfo, this, _1));
-
-    buffer_vector<TileKey, 16> outdatedTileKeys;
-    transform(outdatedTiles.begin(), outdatedTiles.end(),
-              back_inserter(outdatedTileKeys), &TileInfoPtrToTileKey);
-
-    updateDescr.DropTiles(outdatedTileKeys.data(), outdatedTileKeys.size());
-
-    for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::PushTaskFront, this, _1));
-    for_each(inputRects.begin(),  inputRects.end(),  bind(&ReadManager::PushTaskBackForTileKey, this, _1));
+    return max(GetPlatform().CpuCores() - 2, 1);
   }
-  m_currentViewport = screen;
-}
 
-void ReadManager::Resize(const m2::RectI & rect)
-{
-  m_currentViewport.OnSize(rect);
-}
+  void ReadManager::GetTileKeys(set<TileKey> & out, ScreenBase const & screen) const
+  {
+    out.clear();
 
-void ReadManager::Stop()
-{
-    for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::CancelTileInfo, this, _1));
-  m_tileInfos.clear();
+    int const tileScale = m_scalesProcessor.GetTileScaleBase(screen);
+    // equal for x and y
+    double const range = MercatorBounds::maxX - MercatorBounds::minX;
+    double const rectSize = range / (1 << tileScale);
 
-  m_pool->Stop();
-  m_pool.Destroy();
-}
+    m2::AnyRectD const & globalRect = screen.GlobalRect();
+    m2::RectD    const & clipRect   = globalRect.GetGlobalRect();
 
-size_t ReadManager::ReadCount()
-{
-  return max(GetPlatform().CpuCores() - 2, 1);
-}
+    int const minTileX = static_cast<int>(floor(clipRect.minX() / rectSize));
+    int const maxTileX = static_cast<int>(ceil(clipRect.maxX() / rectSize));
+    int const minTileY = static_cast<int>(floor(clipRect.minY() / rectSize));
+    int const maxTileY = static_cast<int>(ceil(clipRect.maxY() / rectSize));
 
-void ReadManager::GetTileKeys(set<TileKey> & out, ScreenBase const & screen) const
-{
-  out.clear();
+    for (int tileY = minTileY; tileY < maxTileY; ++tileY)
+      for (int tileX = minTileX; tileX < maxTileX; ++tileX)
+      {
+        double const left = tileX * rectSize;
+        double const top  = tileY * rectSize;
 
-  int const tileScale = m_scalesProcessor.GetTileScaleBase(screen);
-  // equal for x and y
-  double const range = MercatorBounds::maxX - MercatorBounds::minX;
-  double const rectSize = range / (1 << tileScale);
+        m2::RectD currentTileRect(left, top,
+                                  left + rectSize, top + rectSize);
 
-  m2::AnyRectD const & globalRect = screen.GlobalRect();
-  m2::RectD    const & clipRect   = globalRect.GetGlobalRect();
+        if (globalRect.IsIntersect(m2::AnyRectD(currentTileRect)))
+          out.insert(TileKey(tileX, tileY, tileScale));
+      }
+  }
 
-  int const minTileX = static_cast<int>(floor(clipRect.minX() / rectSize));
-  int const maxTileX = static_cast<int>(ceil(clipRect.maxX() / rectSize));
-  int const minTileY = static_cast<int>(floor(clipRect.minY() / rectSize));
-  int const maxTileY = static_cast<int>(ceil(clipRect.maxY() / rectSize));
+  bool ReadManager::MustDropAllTiles(ScreenBase const & screen) const
+  {
+    const int oldScale = m_scalesProcessor.GetTileScaleBase(m_currentViewport);
+    const int newScale = m_scalesProcessor.GetTileScaleBase(screen);
+    return (oldScale != newScale) || !m_currentViewport.GlobalRect().IsIntersect(screen.GlobalRect());
+  }
 
-  for (int tileY = minTileY; tileY < maxTileY; ++tileY)
-    for (int tileX = minTileX; tileX < maxTileX; ++tileX)
-    {
-      double const left = tileX * rectSize;
-      double const top  = tileY * rectSize;
-
-      m2::RectD currentTileRect(left, top,
-                                left + rectSize, top + rectSize);
-
-      if (globalRect.IsIntersect(m2::AnyRectD(currentTileRect)))
-        out.insert(TileKey(tileX, tileY, tileScale));
-    }
-}
-
-bool ReadManager::MustDropAllTiles(ScreenBase const & screen) const
-{
-  const int oldScale = m_scalesProcessor.GetTileScaleBase(m_currentViewport);
-  const int newScale = m_scalesProcessor.GetTileScaleBase(screen);
-  return (oldScale != newScale) || !m_currentViewport.GlobalRect().IsIntersect(screen.GlobalRect());
-}
-
-void ReadManager::PushTaskBackForTileKey(TileKey const & tileKey)
-{
+  void ReadManager::PushTaskBackForTileKey(TileKey const & tileKey)
+  {
     tileinfo_ptr tileInfo(new TileInfo(tileKey));
-  m_tileInfos.insert(tileInfo);
-  m_pool->PushBack(new ReadMWMTask(tileInfo, m_memIndex, m_model, m_context));
-}
+    m_tileInfos.insert(tileInfo);
+    m_pool->PushBack(new ReadMWMTask(tileInfo, m_memIndex, m_model, m_context));
+  }
 
   void ReadManager::PushTaskFront(tileinfo_ptr const & tileToReread)
-{
-  m_pool->PushFront(new ReadMWMTask(tileToReread, m_memIndex, m_model, m_context));
-}
+  {
+    m_pool->PushFront(new ReadMWMTask(tileToReread, m_memIndex, m_model, m_context));
+  }
 
   void ReadManager::CancelTileInfo(tileinfo_ptr tileToCancel)
-{
+  {
     tileToCancel->Cancel(m_memIndex);
   }
 
   void ReadManager::ClearTileInfo(tileinfo_ptr & tileToClear)
   {
     CancelTileInfo(tileToClear);
-  m_tileInfos.erase(tileToClear);
-}
+    m_tileInfos.erase(tileToClear);
+  }
 }
 
diff --git a/drape_frontend/read_manager.hpp b/drape_frontend/read_manager.hpp
index d181c5ae48..ec7dcdbdde 100644
--- a/drape_frontend/read_manager.hpp
+++ b/drape_frontend/read_manager.hpp
@@ -45,7 +45,6 @@ namespace df
     void PushTaskFront(tileinfo_ptr const & tileToReread);
 
   private:
-
     MemoryFeatureIndex m_memIndex;
     EngineContext & m_context;
 
diff --git a/drape_frontend/read_mwm_task.cpp b/drape_frontend/read_mwm_task.cpp
index 3f4aed6fad..b9c2f6db85 100644
--- a/drape_frontend/read_mwm_task.cpp
+++ b/drape_frontend/read_mwm_task.cpp
@@ -4,7 +4,6 @@
 
 namespace df
 {
-
   ReadMWMTask::ReadMWMTask(weak_ptr<TileInfo> const & tileInfo,
                            MemoryFeatureIndex & memIndex,
                            model::FeaturesFetcher & model,
diff --git a/drape_frontend/tile_info.cpp b/drape_frontend/tile_info.cpp
index 54093d8641..2edf5be4e4 100644
--- a/drape_frontend/tile_info.cpp
+++ b/drape_frontend/tile_info.cpp
@@ -38,7 +38,7 @@ namespace
   }
 
   df::LineShape * CreateFakeLine1()
-{
+  {
     vector<m2::PointF> points;
     const float magn = 4;
 
@@ -60,11 +60,28 @@ namespace
     points.push_back(m2::PointF(0,0));
     return new df::LineShape(points, Extract(0xFF00FF00), .5f, 0.5f);
   }
-  }
+
+  struct IDsAccumulator
+  {
+    IDsAccumulator(vector<FeatureID> & ids, vector<df::FeatureInfo> const & src)
+      : m_ids(ids)
+      , m_src(src)
+    {
+    }
+
+    void operator()(size_t index)
+    {
+      ASSERT_LESS(index, m_src.size(), ());
+      m_ids.push_back(m_src[index].m_id);
+    }
+
+    vector<FeatureID> & m_ids;
+    vector<df::FeatureInfo> const & m_src;
+  };
+}
 
 namespace df
-  {
-
+{
   TileInfo::TileInfo(TileKey const & key)
     : m_key(key)
   {}
@@ -94,27 +111,6 @@ namespace df
     }
   }
 
-  namespace
-  {
-    struct IDsAccumulator
-    {
-      IDsAccumulator(vector<FeatureID> & ids, vector<FeatureInfo> const & src)
-        : m_ids(ids)
-        , m_src(src)
-      {
-      }
-
-      void operator()(size_t index)
-      {
-        ASSERT_LESS(index, m_src.size(), ());
-        m_ids.push_back(m_src[index].m_id);
-      }
-
-      vector<FeatureID> & m_ids;
-      vector<FeatureInfo> const & m_src;
-    };
-  }
-
   void TileInfo::ReadFeatures(model::FeaturesFetcher const & model, 
                               MemoryFeatureIndex & memIndex,
                               EngineContext & context)
@@ -123,10 +119,22 @@ namespace df
     vector<size_t> indexes;
     RequestFeatures(memIndex, indexes);
 
-    vector<FeatureID> featuresToRead;
-    for_each(indexes.begin(), indexes.end(), IDsAccumulator(featuresToRead, m_featureInfo));
+    if (!indexes.empty() && m_key == TileKey(0,0,3))
+    {
+      context.BeginReadTile(m_key);
+      {
+        context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeShape1()));
+        context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeShape2()));
+        context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeLine1()));
+        context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeLine2()));
+      }
+      context.EndReadTile(m_key);
+    }
 
-    model.ReadFeatures(*this, featuresToRead);
+//    vector<FeatureID> featuresToRead;
+//    for_each(indexes.begin(), indexes.end(), IDsAccumulator(featuresToRead, m_featureInfo));
+
+//    model.ReadFeatures(*this, featuresToRead);
   }
 
   void TileInfo::Cancel(MemoryFeatureIndex & memIndex)
diff --git a/drape_frontend/tile_info.hpp b/drape_frontend/tile_info.hpp
index f3f9373ff6..5d2dd0a15f 100644
--- a/drape_frontend/tile_info.hpp
+++ b/drape_frontend/tile_info.hpp
@@ -19,41 +19,41 @@ class FeatureType;
 
 namespace df
 {
-class EngineContext;
+  class EngineContext;
 
-struct TileKey
-{
-public:
-  TileKey() : m_x(-1), m_y(-1), m_zoomLevel(-1) {}
-  TileKey(int x, int y, int zoomLevel)
-    : m_x(x), m_y(y), m_zoomLevel(zoomLevel) {}
-
-  bool operator < (const TileKey & other) const
+  struct TileKey
   {
-    if (m_zoomLevel != other.m_zoomLevel)
-      return m_zoomLevel < other.m_zoomLevel;
-    if (m_y != other.m_y)
-      return m_y < other.m_y;
+  public:
+    TileKey() : m_x(-1), m_y(-1), m_zoomLevel(-1) {}
+    TileKey(int x, int y, int zoomLevel)
+      : m_x(x), m_y(y), m_zoomLevel(zoomLevel) {}
 
-    return m_x < other.m_x;
-  }
+    bool operator < (const TileKey & other) const
+    {
+      if (m_zoomLevel != other.m_zoomLevel)
+        return m_zoomLevel < other.m_zoomLevel;
+      if (m_y != other.m_y)
+        return m_y < other.m_y;
 
-  bool operator == (const TileKey & other) const
+      return m_x < other.m_x;
+    }
+
+    bool operator == (const TileKey & other) const
+    {
+      return m_x == other.m_x &&
+          m_y == other.m_y &&
+          m_zoomLevel == other.m_zoomLevel;
+    }
+
+    int m_x;
+    int m_y;
+    int m_zoomLevel;
+  };
+
+  class TileInfo : private noncopyable
   {
-    return m_x == other.m_x &&
-        m_y == other.m_y &&
-        m_zoomLevel == other.m_zoomLevel;
-  }
-
-  int m_x;
-  int m_y;
-  int m_zoomLevel;
-};
-
-class TileInfo : private noncopyable
-{
-public:
-  DECLARE_EXCEPTION(ReadCanceledException, RootException);
+  public:
+    DECLARE_EXCEPTION(ReadCanceledException, RootException);
 
     TileInfo(TileKey const & key);
 
@@ -63,23 +63,23 @@ public:
                       EngineContext & context);
     void Cancel(MemoryFeatureIndex & memIndex);
 
-  m2::RectD GetGlobalRect() const;
-  TileKey const & GetTileKey() const { return m_key; }
+    m2::RectD GetGlobalRect() const;
+    TileKey const & GetTileKey() const { return m_key; }
 
     void operator ()(FeatureID const & id);
     bool operator ()(FeatureType const & f);
     bool operator <(TileInfo const & other) const { return m_key < other.m_key; }
 
-private:
+  private:
     void RequestFeatures(MemoryFeatureIndex & memIndex, vector<size_t> & featureIndexes);
-  void CheckCanceled();
-  bool DoNeedReadIndex() const;
+    void CheckCanceled();
+    bool DoNeedReadIndex() const;
 
-private:
-  TileKey m_key;
-  vector<FeatureInfo> m_featureInfo;
+  private:
+    TileKey m_key;
+    vector<FeatureInfo> m_featureInfo;
 
-  bool m_isCanceled;
-  threads::Mutex m_mutex;
-};
+    bool m_isCanceled;
+    threads::Mutex m_mutex;
+  };
 }
diff --git a/drape_head/drape_surface.cpp b/drape_head/drape_surface.cpp
index 3a0e5d0b08..75609ff32f 100644
--- a/drape_head/drape_surface.cpp
+++ b/drape_head/drape_surface.cpp
@@ -65,7 +65,7 @@ void DrapeSurface::CreateEngine()
 
   sizeChanged(0);
 
-  m_timerID = startTimer(1000 / 30);
+  //m_timerID = startTimer(1000 / 30);
 }
 
 void DrapeSurface::sizeChanged(int)