diff --git a/drape_frontend/batchers_pool.cpp b/drape_frontend/batchers_pool.cpp
index 629d36e681..c2c99f0045 100644
--- a/drape_frontend/batchers_pool.cpp
+++ b/drape_frontend/batchers_pool.cpp
@@ -4,16 +4,19 @@
 #include "../drape/batcher.hpp"
 
 #include "../base/assert.hpp"
+#include "../base/logging.hpp"
 
 #include "../std/bind.hpp"
 
 namespace df
 {
 
+using dp::Batcher;
+
 namespace
 {
 
-void FlushGeometry(BatchersPool::send_message_fn const & sendMessage,
+void FlushGeometry(BatchersPool::TSendMessageFn const & sendMessage,
                    TileKey const & key,
                    dp::GLState const & state,
                    dp::TransferPointer<dp::RenderBucket> buffer)
@@ -24,71 +27,45 @@ void FlushGeometry(BatchersPool::send_message_fn const & sendMessage,
 
 } // namespace
 
-BatchersPool::BatchersPool(int initBatcherCount, send_message_fn const & sendMessageFn)
+BatchersPool::BatchersPool(int initBatcherCount, TSendMessageFn const & sendMessageFn)
   : m_sendMessageFn(sendMessageFn)
-{
-  for (int i = 0; i < initBatcherCount; ++i)
-    m_batchers.push(dp::MasterPointer<dp::Batcher>(new dp::Batcher()));
-}
+  , m_factory()
+  , m_pool(initBatcherCount, m_factory)
+{}
 
-BatchersPool::~BatchersPool()
-{
-  for (reserved_batchers_t::iterator it = m_reservedBatchers.begin();
-       it != m_reservedBatchers.end(); ++it)
-  {
-    it->second.first.Destroy();
-  }
-  m_reservedBatchers.clear();
-
-  while (!m_batchers.empty())
-  {
-    m_batchers.top().Destroy();
-    m_batchers.pop();
-  }
-}
+BatchersPool::~BatchersPool() {}
 
 void BatchersPool::ReserveBatcher(TileKey const & key)
 {
-  reserved_batchers_t::iterator it = m_reservedBatchers.find(key);
-  if (it != m_reservedBatchers.end())
+  TIterator it = m_batchs.find(key);
+  if (it != m_batchs.end())
   {
     it->second.second++;
     return;
   }
-
-  dp::MasterPointer<dp::Batcher> reserved;
-  if (m_batchers.empty())
-    reserved.Reset(new dp::Batcher());
-  else
-  {
-    reserved = m_batchers.top();
-    m_batchers.pop();
-  }
-
-  reserved->StartSession(bind(&FlushGeometry, m_sendMessageFn, key, _1, _2));
-  VERIFY(m_reservedBatchers.insert(make_pair(key, make_pair(reserved, 1))).second, ());
+  Batcher * B = m_pool.Get();
+  m_batchs.insert(make_pair(key, make_pair(B, 1)));
+  B->StartSession(bind(&FlushGeometry, m_sendMessageFn, key, _1, _2));
 }
 
 dp::RefPointer<dp::Batcher> BatchersPool::GetTileBatcher(TileKey const & key)
 {
-  reserved_batchers_t::iterator it = m_reservedBatchers.find(key);
-
-  ASSERT(it != m_reservedBatchers.end(), ());
-  return it->second.first.GetRefPointer();
+  TIterator it = m_batchs.find(key);
+  ASSERT(it != m_batchs.end(), ());
+  return dp::MakeStackRefPointer(it->second.first);
 }
 
 void BatchersPool::ReleaseBatcher(TileKey const & key)
 {
-  reserved_batchers_t::iterator it = m_reservedBatchers.find(key);
-
-  ASSERT(it != m_reservedBatchers.end(), ());
+  TIterator it = m_batchs.find(key);
+  ASSERT(it != m_batchs.end(), ());
   ASSERT_GREATER(it->second.second, 0, ());
   if ((--it->second.second)== 0)
   {
-    dp::MasterPointer<dp::Batcher> batcher = it->second.first;
-    batcher->EndSession();
-    m_reservedBatchers.erase(it);
-    m_batchers.push(batcher);
+    Batcher * B = it->second.first;
+    B->EndSession();
+    m_pool.Return(B);
+    m_batchs.erase(it);
   }
 }
 
diff --git a/drape_frontend/batchers_pool.hpp b/drape_frontend/batchers_pool.hpp
index 6e582a5a38..bbda69de3d 100644
--- a/drape_frontend/batchers_pool.hpp
+++ b/drape_frontend/batchers_pool.hpp
@@ -3,13 +3,13 @@
 #include "tile_info.hpp"
 
 #include "../drape/pointers.hpp"
+#include "../drape/object_pool.hpp"
+#include "../drape/batcher.hpp"
 
 #include "../std/map.hpp"
 #include "../std/stack.hpp"
 #include "../std/function.hpp"
 
-namespace dp { class Batcher; }
-
 namespace df
 {
 
@@ -18,9 +18,9 @@ class Message;
 class BatchersPool
 {
 public:
-  typedef function<void (dp::TransferPointer<Message>)> send_message_fn;
+  typedef function<void (dp::TransferPointer<Message>)> TSendMessageFn;
 
-  BatchersPool(int initBatcherCount, send_message_fn const & sendMessageFn);
+  BatchersPool(int initBatcherCount, TSendMessageFn const & sendMessageFn);
   ~BatchersPool();
 
   void ReserveBatcher(TileKey const & key);
@@ -28,15 +28,14 @@ public:
   void ReleaseBatcher(TileKey const & key);
 
 private:
-  typedef dp::MasterPointer<dp::Batcher> batcher_ptr;
-  typedef stack<batcher_ptr> batchers_pool_t;
-  typedef pair<batcher_ptr, int> counted_batcher_t;
-  typedef map<TileKey, counted_batcher_t> reserved_batchers_t;
+  typedef pair<dp::Batcher *, int> TBatcherPair;
+  typedef map<TileKey, TBatcherPair> TBatcherMap;
+  typedef TBatcherMap::iterator TIterator;
+  TSendMessageFn m_sendMessageFn;
 
-  batchers_pool_t m_batchers;
-  reserved_batchers_t m_reservedBatchers;
-
-  send_message_fn m_sendMessageFn;
+  dp::BatcherFactory m_factory;
+  ObjectPool<dp::Batcher, dp::BatcherFactory> m_pool;
+  TBatcherMap m_batchs;
 };
 
 } // namespace df