diff --git a/map/basic_tiling_render_policy.hpp b/map/basic_tiling_render_policy.hpp
index c420d93ba9..835a015ac8 100644
--- a/map/basic_tiling_render_policy.hpp
+++ b/map/basic_tiling_render_policy.hpp
@@ -3,7 +3,7 @@
 #include "render_policy.hpp"
 
 #include "../std/shared_ptr.hpp"
-#include "../yg/info_layer.hpp"
+#include "../yg/overlay.hpp"
 
 class TileRenderer;
 class CoverageGenerator;
diff --git a/map/coverage_generator.hpp b/map/coverage_generator.hpp
index 0377994ce0..83e4cad880 100644
--- a/map/coverage_generator.hpp
+++ b/map/coverage_generator.hpp
@@ -7,7 +7,7 @@
 
 #include "../geometry/screenbase.hpp"
 
-#include "../yg/info_layer.hpp"
+#include "../yg/overlay.hpp"
 
 #include "../base/thread.hpp"
 #include "../base/threaded_list.hpp"
diff --git a/map/framework.hpp b/map/framework.hpp
index e6b7202d5f..49f7c22f3b 100644
--- a/map/framework.hpp
+++ b/map/framework.hpp
@@ -29,7 +29,7 @@
 #include "../yg/render_state.hpp"
 #include "../yg/skin.hpp"
 #include "../yg/resource_manager.hpp"
-#include "../yg/info_layer.hpp"
+#include "../yg/overlay.hpp"
 
 #include "../coding/file_reader.hpp"
 #include "../coding/file_writer.hpp"
diff --git a/map/render_queue_routine.cpp b/map/render_queue_routine.cpp
index 18df5482d3..fed92fd0a5 100644
--- a/map/render_queue_routine.cpp
+++ b/map/render_queue_routine.cpp
@@ -295,9 +295,9 @@ void RenderQueueRoutine::Do()
   m2::RectI  surfaceRect;
   m2::RectI  textureRect;
 
-  shared_ptr<yg::InfoLayer> infoLayer(new yg::InfoLayer());
-  infoLayer->setCouldOverlap(false);
-  m_threadDrawer->screen()->setInfoLayer(infoLayer);
+  shared_ptr<yg::Overlay> overlay(new yg::Overlay());
+  overlay->setCouldOverlap(false);
+  m_threadDrawer->screen()->setOverlay(overlay);
 
   while (!IsCancelled())
   {
@@ -348,7 +348,7 @@ void RenderQueueRoutine::Do()
           areas.clear();
           areas.push_back(curRect);
           fullRectRepaint = true;
-          m_threadDrawer->screen()->infoLayer()->clear();
+          m_threadDrawer->screen()->overlay()->clear();
           m_renderState->m_doRepaintAll = false;
         }
         else
@@ -374,14 +374,14 @@ void RenderQueueRoutine::Do()
           if (!redrawTextRect.Intersect(oldRect))
             redrawTextRect = m2::RectD(0, 0, 0, 0);
 
-          m_threadDrawer->screen()->infoLayer()->offset(
+          m_threadDrawer->screen()->overlay()->offset(
                 m2::PointD(0, 0) * offsetM,
                 redrawTextRect
                 );
         }
         else
         {
-          m_threadDrawer->screen()->infoLayer()->clear();
+          m_threadDrawer->screen()->overlay()->clear();
           m_renderState->m_isEmptyModelCurrent = true;
         }
       }
@@ -480,7 +480,7 @@ void RenderQueueRoutine::Do()
 
       m_threadDrawer->beginFrame();
 
-      m_threadDrawer->screen()->infoLayer()->draw(m_threadDrawer->screen().get(), math::Identity<double, 3>());
+      m_threadDrawer->screen()->overlay()->draw(m_threadDrawer->screen().get(), math::Identity<double, 3>());
 
       m_threadDrawer->endFrame();
     }
diff --git a/map/screen_coverage.cpp b/map/screen_coverage.cpp
index f89af8ff84..b4fe1dc798 100644
--- a/map/screen_coverage.cpp
+++ b/map/screen_coverage.cpp
@@ -19,12 +19,12 @@
 
 ScreenCoverage::ScreenCoverage()
   : m_tiler(),
-    m_infoLayer(new yg::InfoLayer()),
+    m_overlay(new yg::Overlay()),
     m_isEmptyDrawingCoverage(false),
     m_isEmptyModelAtCoverageCenter(true),
     m_leafTilesToRender(0)
 {
-  m_infoLayer->setCouldOverlap(false);
+  m_overlay->setCouldOverlap(false);
 }
 
 ScreenCoverage::ScreenCoverage(TileRenderer * tileRenderer,
@@ -32,13 +32,13 @@ ScreenCoverage::ScreenCoverage(TileRenderer * tileRenderer,
                                shared_ptr<yg::gl::Screen> const & cacheScreen)
   : m_tileRenderer(tileRenderer),
     m_coverageGenerator(coverageGenerator),
-    m_infoLayer(new yg::InfoLayer()),
+    m_overlay(new yg::Overlay()),
     m_isEmptyDrawingCoverage(false),
     m_isEmptyModelAtCoverageCenter(true),
     m_leafTilesToRender(0),
     m_cacheScreen(cacheScreen)
 {
-  m_infoLayer->setCouldOverlap(false);
+  m_overlay->setCouldOverlap(false);
 }
 
 void ScreenCoverage::CopyInto(ScreenCoverage & cvg)
@@ -68,7 +68,7 @@ void ScreenCoverage::CopyInto(ScreenCoverage & cvg)
 
   tileCache->Unlock();
 
-  cvg.m_infoLayer.reset(m_infoLayer->clone());
+  cvg.m_overlay.reset(m_overlay->clone());
 }
 
 void ScreenCoverage::Clear()
@@ -76,7 +76,7 @@ void ScreenCoverage::Clear()
   m_tileRects.clear();
   m_newTileRects.clear();
   m_newLeafTileRects.clear();
-  m_infoLayer->clear();
+  m_overlay->clear();
   m_isEmptyDrawingCoverage = false;
   m_isEmptyModelAtCoverageCenter = true;
   m_leafTilesToRender = 0;
@@ -144,11 +144,11 @@ void ScreenCoverage::Merge(Tiler::RectInfo const & ri)
   {
     if (m_tiler.isLeaf(ri))
     {
-      yg::InfoLayer * tileInfoLayerCopy = tile->m_infoLayer->clone();
-      m_infoLayer->merge(*tileInfoLayerCopy,
-                          tile->m_tileScreen.PtoGMatrix() * m_screen.GtoPMatrix());
+      yg::Overlay * tileOverlayCopy = tile->m_overlay->clone();
+      m_overlay->merge(*tileOverlayCopy,
+                        tile->m_tileScreen.PtoGMatrix() * m_screen.GtoPMatrix());
 
-      delete tileInfoLayerCopy;
+      delete tileOverlayCopy;
     }
   }
 }
@@ -185,7 +185,7 @@ void ScreenCoverage::Cache()
   if (!infos.empty())
     m_cacheScreen->blit(&infos[0], infos.size(), true);
 
-  m_infoLayer->draw(m_cacheScreen.get(), math::Identity<double, 3>());
+  m_overlay->draw(m_cacheScreen.get(), math::Identity<double, 3>());
 
   m_cacheScreen->setDisplayList(0);
   m_cacheScreen->endFrame();
@@ -256,7 +256,7 @@ void ScreenCoverage::SetScreen(ScreenBase const & screen)
   {
     Tiler::RectInfo ri = (*it)->m_rectInfo;
     tileCache->UnlockTile((*it)->m_rectInfo);
-    /// here we should "unmerge" erasedTiles[i].m_infoLayer from m_infoLayer
+    /// here we should "unmerge" erasedTiles[i].m_overlay from m_overlay
   }
 
   for (TTileSet::const_iterator it = addedTiles.begin(); it != addedTiles.end(); ++it)
@@ -269,7 +269,7 @@ void ScreenCoverage::SetScreen(ScreenBase const & screen)
 
   m_tiles = tiles;
 
-  MergeInfoLayer();
+  MergeOverlay();
 
   set<Tiler::RectInfo> drawnTiles;
 
@@ -364,9 +364,9 @@ void ScreenCoverage::Draw(yg::gl::Screen * s, ScreenBase const & screen)
     m_displayList->draw(m_screen.PtoGMatrix() * screen.GtoPMatrix());
 }
 
-yg::InfoLayer * ScreenCoverage::GetInfoLayer() const
+yg::Overlay * ScreenCoverage::GetOverlay() const
 {
-  return m_infoLayer.get();
+  return m_overlay.get();
 }
 
 int ScreenCoverage::GetDrawScale() const
@@ -427,20 +427,20 @@ void ScreenCoverage::RemoveTiles(m2::AnyRectD const & r, int startScale)
     m_tileRects.erase(ri);
   }
 
-  MergeInfoLayer();
+  MergeOverlay();
 }
 
-void ScreenCoverage::MergeInfoLayer()
+void ScreenCoverage::MergeOverlay()
 {
-  m_infoLayer->clear();
+  m_overlay->clear();
 
   for (TTileSet::const_iterator it = m_tiles.begin(); it != m_tiles.end(); ++it)
   {
     Tiler::RectInfo const & ri = (*it)->m_rectInfo;
     if (m_tiler.isLeaf(ri))
     {
-      scoped_ptr<yg::InfoLayer> copy((*it)->m_infoLayer->clone());
-      m_infoLayer->merge(*copy.get(), (*it)->m_tileScreen.PtoGMatrix() * m_screen.GtoPMatrix());
+      scoped_ptr<yg::Overlay> copy((*it)->m_overlay->clone());
+      m_overlay->merge(*copy.get(), (*it)->m_tileScreen.PtoGMatrix() * m_screen.GtoPMatrix());
     }
   }
 }
diff --git a/map/screen_coverage.hpp b/map/screen_coverage.hpp
index 0753e0972c..a974447044 100644
--- a/map/screen_coverage.hpp
+++ b/map/screen_coverage.hpp
@@ -4,7 +4,7 @@
 
 #include "../geometry/screenbase.hpp"
 
-#include "../yg/info_layer.hpp"
+#include "../yg/overlay.hpp"
 
 #include "tile.hpp"
 #include "tiler.hpp"
@@ -51,8 +51,8 @@ private:
   /// Tiles in this set are locked to prevent their deletion
   /// from TileCache while drawing them
   TTileSet m_tiles;
-  /// InfoLayer composed of infoLayers for visible tiles
-  scoped_ptr<yg::InfoLayer> m_infoLayer;
+  /// Overlay composed of overlays for visible tiles
+  scoped_ptr<yg::Overlay> m_overlay;
 
   /// State flags
 
@@ -73,8 +73,8 @@ private:
   ScreenCoverage(ScreenCoverage const & src);
   ScreenCoverage const & operator=(ScreenCoverage const & src);
 
-  /// For each tile in m_tiles merge it's infoLayer into the big one.
-  void MergeInfoLayer();
+  /// For each tile in m_tiles merge it's overlay into the big one.
+  void MergeOverlay();
 
 public:
 
@@ -102,8 +102,8 @@ public:
   bool IsEmptyModelAtCoverageCenter() const;
   /// Check, whether the model is empty at the center of the coverage.
   void CheckEmptyModelAtCoverageCenter();
-  /// Getter for InfoLayer
-  yg::InfoLayer * GetInfoLayer() const;
+  /// Getter for Overlay
+  yg::Overlay * GetOverlay() const;
   /// Cache coverage in display list
   void Cache();
   /// add rendered tile to coverage. Tile is locked, so make sure to unlock it in case it's not needed.
diff --git a/map/simple_render_policy.cpp b/map/simple_render_policy.cpp
index 379ddbb1c3..efaa209554 100644
--- a/map/simple_render_policy.cpp
+++ b/map/simple_render_policy.cpp
@@ -2,7 +2,7 @@
 #include "events.hpp"
 #include "drawer_yg.hpp"
 #include "window_handle.hpp"
-#include "../yg/info_layer.hpp"
+#include "../yg/overlay.hpp"
 #include "../yg/internal/opengl.hpp"
 #include "../yg/skin.hpp"
 
@@ -125,18 +125,18 @@ void SimpleRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
                    pxCenter + m2::PointD(scaleEtalonSize / 2, scaleEtalonSize / 2)),
          glbRect);
 
-  shared_ptr<yg::InfoLayer> infoLayer(new yg::InfoLayer());
+  shared_ptr<yg::Overlay> overlay(new yg::Overlay());
 
   DrawerYG * pDrawer = e->drawer();
 
-  pDrawer->screen()->setInfoLayer(infoLayer);
+  pDrawer->screen()->setOverlay(overlay);
   pDrawer->screen()->beginFrame();
   pDrawer->screen()->clear(m_bgColor);
 
   m_renderFn(e, s, s.ClipRect(), s.ClipRect(), scales::GetScaleLevel(glbRect), false);
 
-  infoLayer->draw(pDrawer->screen().get(), math::Identity<double, 3>());
-  pDrawer->screen()->resetInfoLayer();
+  overlay->draw(pDrawer->screen().get(), math::Identity<double, 3>());
+  pDrawer->screen()->resetOverlay();
 
   pDrawer->screen()->endFrame();
 }
diff --git a/map/tile.cpp b/map/tile.cpp
index c5c31b75b1..b880f90992 100644
--- a/map/tile.cpp
+++ b/map/tile.cpp
@@ -8,13 +8,13 @@ Tile::Tile()
 {}
 
 Tile::Tile(shared_ptr<yg::gl::BaseTexture> const & renderTarget,
-           shared_ptr<yg::InfoLayer> const & infoLayer,
+           shared_ptr<yg::Overlay> const & overlay,
            ScreenBase const & tileScreen,
            Tiler::RectInfo const & rectInfo,
            double duration,
            bool isEmptyDrawing)
   : m_renderTarget(renderTarget),
-    m_infoLayer(infoLayer),
+    m_overlay(overlay),
     m_tileScreen(tileScreen),
     m_rectInfo(rectInfo),
     m_duration(duration),
diff --git a/map/tile.hpp b/map/tile.hpp
index 775fd1b22b..c0715c40c2 100644
--- a/map/tile.hpp
+++ b/map/tile.hpp
@@ -12,13 +12,13 @@ namespace yg
   {
     class BaseTexture;
   }
-  class InfoLayer;
+  class Overlay;
 }
 
 struct Tile
 {
   shared_ptr<yg::gl::BaseTexture> m_renderTarget; //< taken from resource manager
-  shared_ptr<yg::InfoLayer> m_infoLayer;  //< text and POI's
+  shared_ptr<yg::Overlay> m_overlay;  //< text and POI's
   ScreenBase m_tileScreen; //< cached to calculate it once, cause tile blitting
                            //< is performed on GUI thread.
   Tiler::RectInfo m_rectInfo; //< taken from tiler
@@ -28,7 +28,7 @@ struct Tile
   Tile();
 
   Tile(shared_ptr<yg::gl::BaseTexture> const & renderTarget,
-       shared_ptr<yg::InfoLayer> const & infoLayer,
+       shared_ptr<yg::Overlay> const & overlay,
        ScreenBase const & tileScreen,
        Tiler::RectInfo const & rectInfo,
        double duration,
diff --git a/map/tile_renderer.cpp b/map/tile_renderer.cpp
index c1ca3c200d..147a0bf52d 100644
--- a/map/tile_renderer.cpp
+++ b/map/tile_renderer.cpp
@@ -179,10 +179,10 @@ void TileRenderer::DrawTile(core::CommandsQueue::Environment const & env,
 
   drawer->screen()->setRenderTarget(tileTarget);
 
-  shared_ptr<yg::InfoLayer> tileInfoLayer(new yg::InfoLayer());
-  tileInfoLayer->setCouldOverlap(true);
+  shared_ptr<yg::Overlay> tileOverlay(new yg::Overlay());
+  tileOverlay->setCouldOverlap(true);
 
-  drawer->screen()->setInfoLayer(tileInfoLayer);
+  drawer->screen()->setOverlay(tileOverlay);
 
   /// ensuring, that the render target is not bound as a texture
 
@@ -224,11 +224,11 @@ void TileRenderer::DrawTile(core::CommandsQueue::Environment const & env,
 
   drawer->endFrame();
 
-  drawer->screen()->resetInfoLayer();
+  drawer->screen()->resetOverlay();
 
   /// filter out the overlay elements that are out of the bound rect for the tile
   if (!env.isCancelled())
-    tileInfoLayer->clip(renderRect);
+    tileOverlay->clip(renderRect);
 
   ReadPixels(glQueue, env);
   drawer->screen()->finish();
@@ -257,7 +257,7 @@ void TileRenderer::DrawTile(core::CommandsQueue::Environment const & env,
   else
   {
     AddActiveTile(Tile(tileTarget,
-                 tileInfoLayer,
+                 tileOverlay,
                  frameScreen,
                  rectInfo,
                  0,
diff --git a/yg/info_layer.cpp b/yg/overlay.cpp
similarity index 86%
rename from yg/info_layer.cpp
rename to yg/overlay.cpp
index 52722a7590..5a04f9508c 100644
--- a/yg/info_layer.cpp
+++ b/yg/overlay.cpp
@@ -1,6 +1,6 @@
 #include "../base/SRC_FIRST.hpp"
 
-#include "info_layer.hpp"
+#include "overlay.hpp"
 #include "text_element.hpp"
 
 #include "../base/logging.hpp"
@@ -28,16 +28,16 @@ namespace yg
     return elem->roughBoundRect();
   }
 
-  void InfoLayer::draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m)
+  void Overlay::draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m)
   {
     m_tree.ForEach(bind(&OverlayElement::draw, _1, r, cref(m)));
   }
 
-  InfoLayer::InfoLayer()
+  Overlay::Overlay()
     : m_couldOverlap(true)
   {}
 
-  InfoLayer::InfoLayer(InfoLayer const & src)
+  Overlay::Overlay(Overlay const & src)
   {
     m_couldOverlap = src.m_couldOverlap;
 
@@ -57,7 +57,7 @@ namespace yg
     }
   }
 
-  void InfoLayer::setCouldOverlap(bool flag)
+  void Overlay::setCouldOverlap(bool flag)
   {
     m_couldOverlap = flag;
   }
@@ -138,17 +138,17 @@ namespace yg
     }
   }
 
-  void InfoLayer::offset(m2::PointD const & offs, m2::RectD const & rect)
+  void Overlay::offset(m2::PointD const & offs, m2::RectD const & rect)
   {
     offsetTree(m_tree, offs, rect);
   }
 
-  void InfoLayer::clear()
+  void Overlay::clear()
   {
     m_tree.Clear();
   }
 
-  void InfoLayer::addOverlayElement(shared_ptr<OverlayElement> const & oe)
+  void Overlay::addOverlayElement(shared_ptr<OverlayElement> const & oe)
   {
     m_tree.Add(oe);
   }
@@ -183,7 +183,7 @@ namespace yg
     }
   };
 
-  void InfoLayer::replaceOverlayElement(shared_ptr<OverlayElement> const & oe)
+  void Overlay::replaceOverlayElement(shared_ptr<OverlayElement> const & oe)
   {
     bool isIntersect = false;
     DoPreciseIntersect fn(oe, &isIntersect);
@@ -194,7 +194,7 @@ namespace yg
       m_tree.Add(oe);
   }
 
-  void InfoLayer::processOverlayElement(shared_ptr<OverlayElement> const & oe, math::Matrix<double, 3, 3> const & m)
+  void Overlay::processOverlayElement(shared_ptr<OverlayElement> const & oe, math::Matrix<double, 3, 3> const & m)
   {
     if (m != math::Identity<double, 3>())
       processOverlayElement(make_shared_ptr(oe->clone(m)));
@@ -202,7 +202,7 @@ namespace yg
       processOverlayElement(oe);
   }
 
-  void InfoLayer::processOverlayElement(shared_ptr<OverlayElement> const & oe)
+  void Overlay::processOverlayElement(shared_ptr<OverlayElement> const & oe)
   {
     if (oe->isVisible())
     {
@@ -219,7 +219,7 @@ namespace yg
     return l->visualRank() > r->visualRank();
   }
 
-  void InfoLayer::merge(InfoLayer const & layer, math::Matrix<double, 3, 3> const & m)
+  void Overlay::merge(Overlay const & layer, math::Matrix<double, 3, 3> const & m)
   {
     vector<shared_ptr<OverlayElement> > v;
 
@@ -231,10 +231,10 @@ namespace yg
 
     /// 3. merging them into the infoLayer starting from most
     /// important one to optimize the space usage.
-    for_each(v.begin(), v.end(), bind(&InfoLayer::processOverlayElement, this, _1, cref(m)));
+    for_each(v.begin(), v.end(), bind(&Overlay::processOverlayElement, this, _1, cref(m)));
   }
 
-  void InfoLayer::clip(m2::RectI const & r)
+  void Overlay::clip(m2::RectI const & r)
   {
     vector<shared_ptr<OverlayElement> > v;
     m_tree.ForEach(MakeBackInsertFunctor(v));
@@ -278,7 +278,7 @@ namespace yg
 //    LOG(LINFO, ("clipped out", clippedCnt, "elements,", elemCnt, "elements total"));
   }
 
-  bool InfoLayer::checkHasEquals(InfoLayer const * l) const
+  bool Overlay::checkHasEquals(Overlay const * l) const
   {
     vector<shared_ptr<OverlayElement> > v0;
     m_tree.ForEach(MakeBackInsertFunctor(v0));
@@ -297,9 +297,9 @@ namespace yg
     return !res.empty();
   }
 
-  InfoLayer * InfoLayer::clone() const
+  Overlay * Overlay::clone() const
   {
-    InfoLayer * res = new InfoLayer(*this);
+    Overlay * res = new Overlay(*this);
     return res;
   }
 }
diff --git a/yg/info_layer.hpp b/yg/overlay.hpp
similarity index 82%
rename from yg/info_layer.hpp
rename to yg/overlay.hpp
index 42587d2dee..e092fc1ba5 100644
--- a/yg/info_layer.hpp
+++ b/yg/overlay.hpp
@@ -19,7 +19,7 @@ namespace yg
     static m2::RectD const LimitRect(shared_ptr<OverlayElement> const & elem);
   };
 
-  class InfoLayer
+  class Overlay
   {
   private:
 
@@ -32,8 +32,8 @@ namespace yg
 
   public:
 
-    InfoLayer();
-    InfoLayer(InfoLayer const & src);
+    Overlay();
+    Overlay(Overlay const & src);
 
     void draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m);
 
@@ -47,12 +47,12 @@ namespace yg
 
     void setCouldOverlap(bool flag);
 
-    void merge(InfoLayer const & infoLayer, math::Matrix<double, 3, 3> const & m);
+    void merge(Overlay const & infoLayer, math::Matrix<double, 3, 3> const & m);
 
     void clip(m2::RectI const & r);
 
-    bool checkHasEquals(InfoLayer const * l) const;
+    bool checkHasEquals(Overlay const * l) const;
 
-    InfoLayer * clone() const;
+    Overlay * clone() const;
   };
 }
diff --git a/yg/overlay_renderer.cpp b/yg/overlay_renderer.cpp
index f21c8a3f41..aa92a81a1b 100644
--- a/yg/overlay_renderer.cpp
+++ b/yg/overlay_renderer.cpp
@@ -7,7 +7,7 @@
 #include "symbol_element.hpp"
 #include "circle_element.hpp"
 #include "render_state.hpp"
-#include "info_layer.hpp"
+#include "overlay.hpp"
 #include "resource_manager.hpp"
 #include "skin.hpp"
 
@@ -25,7 +25,7 @@ namespace yg
       : TextRenderer(p),
         m_drawTexts(p.m_drawTexts),
         m_drawSymbols(p.m_drawSymbols),
-        m_infoLayer(p.m_infoLayer)
+        m_overlay(p.m_overlay)
     {
     }
 
@@ -48,10 +48,10 @@ namespace yg
 
       math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
 
-      if (!m_infoLayer.get())
+      if (!m_overlay.get())
         oe->draw(this, id);
       else
-        m_infoLayer->processOverlayElement(oe);
+        m_overlay->processOverlayElement(oe);
     }
 
     void OverlayRenderer::drawCircle(m2::PointD const & pt,
@@ -70,10 +70,10 @@ namespace yg
 
       math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
 
-      if (!m_infoLayer.get())
+      if (!m_overlay.get())
         oe->draw(this, id);
       else
-        m_infoLayer->processOverlayElement(oe);
+        m_overlay->processOverlayElement(oe);
     }
 
     void OverlayRenderer::drawText(FontDesc const & fontDesc,
@@ -102,10 +102,10 @@ namespace yg
 
       math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
 
-      if (!m_infoLayer.get())
+      if (!m_overlay.get())
         oe->draw(this, id);
       else
-        m_infoLayer->processOverlayElement(oe);
+        m_overlay->processOverlayElement(oe);
     }
 
     void OverlayRenderer::drawTextEx(FontDesc const & primaryFont,
@@ -138,10 +138,10 @@ namespace yg
 
       math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
 
-      if (!m_infoLayer.get())
+      if (!m_overlay.get())
         oe->draw(this, id);
       else
-        m_infoLayer->processOverlayElement(oe);
+        m_overlay->processOverlayElement(oe);
     }
 
     bool OverlayRenderer::drawPathText(
@@ -169,27 +169,27 @@ namespace yg
 
       math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
 
-      if (!m_infoLayer.get())
+      if (!m_overlay.get())
         pte->draw(this, id);
       else
-        m_infoLayer->processOverlayElement(pte);
+        m_overlay->processOverlayElement(pte);
 
       return true;
     }
 
-    void OverlayRenderer::setInfoLayer(shared_ptr<InfoLayer> const & infoLayer)
+    void OverlayRenderer::setOverlay(shared_ptr<Overlay> const & overlay)
     {
-      m_infoLayer = infoLayer;
+      m_overlay = overlay;
     }
 
-    shared_ptr<InfoLayer> const & OverlayRenderer::infoLayer() const
+    shared_ptr<Overlay> const & OverlayRenderer::overlay() const
     {
-      return m_infoLayer;
+      return m_overlay;
     }
 
-    void OverlayRenderer::resetInfoLayer()
+    void OverlayRenderer::resetOverlay()
     {
-      m_infoLayer.reset();
+      m_overlay.reset();
     }
   }
 }
diff --git a/yg/overlay_renderer.hpp b/yg/overlay_renderer.hpp
index 1086543e90..6e3a23d071 100644
--- a/yg/overlay_renderer.hpp
+++ b/yg/overlay_renderer.hpp
@@ -2,7 +2,7 @@
 
 #include "text_renderer.hpp"
 #include "../std/shared_ptr.hpp"
-#include "info_layer.hpp"
+#include "overlay.hpp"
 
 namespace yg
 {
@@ -14,7 +14,7 @@ namespace yg
 
       bool m_drawTexts;
       bool m_drawSymbols;
-      shared_ptr<yg::InfoLayer> m_infoLayer;
+      shared_ptr<yg::Overlay> m_overlay;
 
       typedef map<m2::PointI, shared_ptr<OverlayElement> > TElements;
 
@@ -26,7 +26,7 @@ namespace yg
       {
         bool m_drawTexts;
         bool m_drawSymbols;
-        shared_ptr<yg::InfoLayer> m_infoLayer;
+        shared_ptr<yg::Overlay> m_overlay;
         Params();
       };
 
@@ -67,11 +67,11 @@ namespace yg
                         yg::EPosition pos,
                         double depth);
 
-      void setInfoLayer(shared_ptr<InfoLayer> const & infoLayer);
+      void setOverlay(shared_ptr<Overlay> const & overlay);
 
-      shared_ptr<InfoLayer> const & infoLayer() const;
+      shared_ptr<Overlay> const & overlay() const;
 
-      void resetInfoLayer();
+      void resetOverlay();
     };
   }
 }
diff --git a/yg/render_state.cpp b/yg/render_state.cpp
index 04ca2c96c6..49ad5f9a6e 100644
--- a/yg/render_state.cpp
+++ b/yg/render_state.cpp
@@ -3,16 +3,16 @@
 
 #include "render_state.hpp"
 #include "renderbuffer.hpp"
-#include "info_layer.hpp"
+#include "overlay.hpp"
 
 namespace yg
 {
   namespace gl
   {
     RenderState::RenderState()
-    : m_actualInfoLayer(new yg::InfoLayer()),
+    : m_actualOverlay(new yg::Overlay()),
       m_isEmptyModelActual(false),
-      m_currentInfoLayer(new yg::InfoLayer()),
+      m_currentOverlay(new yg::Overlay()),
       m_isEmptyModelCurrent(false),
       m_isResized(false),
       m_doRepaintAll(false),
diff --git a/yg/render_state.hpp b/yg/render_state.hpp
index 5576be9b4c..a06288d4ea 100644
--- a/yg/render_state.hpp
+++ b/yg/render_state.hpp
@@ -10,7 +10,7 @@
 
 namespace yg
 {
-  class InfoLayer;
+  class Overlay;
 
   namespace gl
   {
@@ -28,7 +28,7 @@ namespace yg
       /// Bitmap
       shared_ptr<BaseTexture> m_actualTarget;
       /// Information layer
-      shared_ptr<yg::InfoLayer> m_actualInfoLayer;
+      shared_ptr<yg::Overlay> m_actualOverlay;
       /// Screen parameters
       ScreenBase m_actualScreen;
       /// Empty-model flag of the actual target
@@ -40,7 +40,7 @@ namespace yg
       /// Screen of the rendering operation in progress.
       ScreenBase m_currentScreen;
       /// information layer
-      shared_ptr<yg::InfoLayer> m_currentInfoLayer;
+      shared_ptr<yg::Overlay> m_currentOverlay;
       /// at least one backBuffer layer
       shared_ptr<BaseTexture> m_backBuffer;
       /// depth buffer used for rendering
diff --git a/yg/text_renderer.cpp b/yg/text_renderer.cpp
index 46efdf9fc0..5350f816fa 100644
--- a/yg/text_renderer.cpp
+++ b/yg/text_renderer.cpp
@@ -1,6 +1,6 @@
 #include "text_renderer.hpp"
 #include "render_state.hpp"
-#include "info_layer.hpp"
+#include "overlay.hpp"
 #include "resource_style.hpp"
 #include "resource_manager.hpp"
 
diff --git a/yg/yg.pro b/yg/yg.pro
index 53adc0c53b..e055003b3a 100644
--- a/yg/yg.pro
+++ b/yg/yg.pro
@@ -47,7 +47,7 @@ SOURCES += \
     glyph_layout.cpp \
     text_element.cpp \
     text_path.cpp \
-    info_layer.cpp \
+    overlay.cpp \
     overlay_element.cpp \
     symbol_element.cpp \
     overlay_renderer.cpp \
@@ -105,7 +105,7 @@ HEADERS += \
     glyph_layout.hpp \
     text_element.hpp \
     text_path.hpp \
-    info_layer.hpp \
+    overlay.hpp \
     overlay_element.hpp \
     symbol_element.hpp \
     overlay_renderer.hpp \
diff --git a/yg/yg_tests/screengl_test.cpp b/yg/yg_tests/screengl_test.cpp
index 173c79ef82..09712efead 100644
--- a/yg/yg_tests/screengl_test.cpp
+++ b/yg/yg_tests/screengl_test.cpp
@@ -1131,8 +1131,8 @@ namespace
   public:
     void DoDraw(shared_ptr<yg::gl::Screen> p)
     {
-      p->setInfoLayer(make_shared_ptr(new yg::InfoLayer()));
-      p->infoLayer()->setCouldOverlap(false);
+      p->setOverlay(make_shared_ptr(new yg::Overlay()));
+      p->overlay()->setCouldOverlap(false);
 
       p->drawSymbol(m2::PointD(200, 200), "current-position", yg::EPosUnder, yg::maxDepth);
       p->drawText(yg::FontDesc(), m2::PointD(200, 200), yg::EPosAbove, "Test Text", yg::maxDepth, true);
@@ -1143,8 +1143,8 @@ namespace
       p->endFrame();
       p->beginFrame();
 
-      p->infoLayer()->draw(p.get(), math::Identity<double, 3>());
-      p->resetInfoLayer();
+      p->overlay()->draw(p.get(), math::Identity<double, 3>());
+      p->resetOverlay();
     }
   };