diff --git a/drape/drape_tests/stipple_pen_tests.cpp b/drape/drape_tests/stipple_pen_tests.cpp
index cedce6f8d6..f9a869b140 100644
--- a/drape/drape_tests/stipple_pen_tests.cpp
+++ b/drape/drape_tests/stipple_pen_tests.cpp
@@ -6,14 +6,15 @@
 #include "drape/stipple_pen_resource.hpp"
 #include "drape/texture.hpp"
 
+namespace stipple_pen_tests
+{
 using namespace dp;
 
 namespace
 {
 void TestPacker(StipplePenPacker & packer, uint32_t width, m2::RectU const & expect)
 {
-  m2::RectU rect = packer.PackResource(width);
-  TEST_EQUAL(rect, expect, ());
+  TEST_EQUAL(packer.PackResource(width), expect, ());
 }
 
 bool IsRectsEqual(m2::RectF const & r1, m2::RectF const & r2)
@@ -23,24 +24,9 @@ bool IsRectsEqual(m2::RectF const & r1, m2::RectF const & r2)
          base::AlmostEqualULPs(r1.maxX(), r2.maxX()) &&
          base::AlmostEqualULPs(r1.maxY(), r2.maxY());
 }
-
-class DummyStipplePenIndex : public StipplePenIndex
-{
-  using Base = StipplePenIndex;
-public:
-  explicit DummyStipplePenIndex(m2::PointU const & size)
-    : Base(size)
-  {}
-
-  ref_ptr<Texture::ResourceInfo> MapResource(StipplePenKey const & key)
-  {
-    bool dummy = false;
-    return Base::MapResource(key, dummy);
-  }
-};
 }  // namespace
 
-UNIT_TEST(SimpleStipplePackTest)
+UNIT_TEST(StippleTest_Pack)
 {
   StipplePenPacker packer(m2::PointU(512, 8));
   TestPacker(packer, 30, m2::RectU(0, 0, 30, 1));
@@ -53,34 +39,4 @@ UNIT_TEST(SimpleStipplePackTest)
   TEST(IsRectsEqual(mapped, m2::RectF(0.5f / 512.0f, 0.5f / 8.0f,
                                       255.5f / 512.0f, 0.5f / 8.0f)), ());
 }
-
-UNIT_TEST(SimplePatternKey)
-{
-  {
-    StipplePenKey info;
-    info.m_pattern.push_back(2);
-    info.m_pattern.push_back(21);
-
-    TEST_EQUAL(StipplePenHandle(info), StipplePenHandle(0x204A000000000000), ());
-  }
-
-  {
-    StipplePenKey info;
-    info.m_pattern.push_back(1);
-    info.m_pattern.push_back(1);
-    TEST_EQUAL(StipplePenHandle(info), StipplePenHandle(0x2000000000000000), ());
-  }
-
-  {
-    StipplePenKey info;
-    info.m_pattern.push_back(12);
-    info.m_pattern.push_back(12);
-    info.m_pattern.push_back(8);
-    info.m_pattern.push_back(9);
-    info.m_pattern.push_back(128);
-    info.m_pattern.push_back(128);
-    info.m_pattern.push_back(40);
-    info.m_pattern.push_back(40);
-    TEST_EQUAL(StipplePenHandle(info), StipplePenHandle(0xE2C58711FFFA74E0), ());
-  }
-}
+} // namespace stipple_pen_tests
diff --git a/drape/stipple_pen_resource.cpp b/drape/stipple_pen_resource.cpp
index e183218f2a..885944a94a 100644
--- a/drape/stipple_pen_resource.cpp
+++ b/drape/stipple_pen_resource.cpp
@@ -11,7 +11,7 @@
 
 namespace dp
 {
-uint32_t const kMaxStipplePenLength = 512;
+uint32_t const kMaxStipplePenLength = 512;  /// @todo Should be equal with kStippleTextureWidth?
 uint32_t const kStippleHeight = 1;
 
 StipplePenPacker::StipplePenPacker(m2::PointU const & canvasSize)
@@ -38,51 +38,14 @@ m2::RectF StipplePenPacker::MapTextureCoords(m2::RectU const & pixelRect) const
                    (pixelRect.maxY() - 0.5f) / m_canvasSize.y);
 }
 
-StipplePenHandle::StipplePenHandle(buffer_vector<uint8_t, 8> const & pattern)
-  : m_keyValue(0)
-{
-  Init(pattern);
-}
-
-StipplePenHandle::StipplePenHandle(StipplePenKey const & info)
-  : m_keyValue(0)
-{
-  Init(info.m_pattern);
-}
-
-void StipplePenHandle::Init(buffer_vector<uint8_t, 8> const & pattern)
-{
-  // encoding scheme
-  // 63 - 61 bits = size of pattern in range [0 : 8]
-  // 60 - 53 bits = first value of pattern in range [1 : 128]
-  // 52 - 45 bits = second value of pattern
-  // ....
-  // 0 - 5 bits = reserved
-
-  ASSERT(pattern.size() >= 1 && pattern.size() < 9, (pattern.size()));
-  uint32_t const patternSize = static_cast<uint32_t>(pattern.size());
-
-  m_keyValue = patternSize - 1; // we code value 1 as 000 and value 8 as 111
-  for (size_t i = 0; i < patternSize; ++i)
-  {
-    m_keyValue <<=7;
-    ASSERT_GREATER(pattern[i], 0, ()); // we have 7 bytes for value. value = 1 encode like 0000000
-    ASSERT_LESS(pattern[i], 129, ()); // value = 128 encode like 1111111
-    uint32_t value = pattern[i] - 1;
-    m_keyValue += value;
-  }
-
-  m_keyValue <<= ((8 - patternSize) * 7 + 5);
-}
-
 StipplePenRasterizator::StipplePenRasterizator(StipplePenKey const & key)
   : m_key(key)
 {
-  m_patternLength = std::accumulate(m_key.m_pattern.begin(), m_key.m_pattern.end(), 0);
+  uint32_t const patternLength = std::accumulate(m_key.m_pattern.begin(), m_key.m_pattern.end(), 0);
   uint32_t const availableSize = kMaxStipplePenLength - 2; // the first and the last pixel reserved
-  ASSERT(m_patternLength > 0 && m_patternLength < availableSize, (m_patternLength, availableSize));
-  uint32_t const count = floor(availableSize / m_patternLength);
-  m_pixelLength = count * m_patternLength;
+  ASSERT(patternLength > 0 && patternLength < availableSize, (patternLength, availableSize));
+  uint32_t const count = floor(availableSize / patternLength);
+  m_pixelLength = count * patternLength;
 }
 
 uint32_t StipplePenRasterizator::GetSize() const
@@ -90,31 +53,24 @@ uint32_t StipplePenRasterizator::GetSize() const
   return m_pixelLength;
 }
 
-uint32_t StipplePenRasterizator::GetPatternSize() const
-{
-  return m_patternLength;
-}
-
-void StipplePenRasterizator::Rasterize(void * buffer)
+void StipplePenRasterizator::Rasterize(uint8_t * pixels)
 {
   ASSERT(!m_key.m_pattern.empty(), ());
-  uint8_t * pixels = static_cast<uint8_t *>(buffer);
   uint16_t offset = 1;
-  buffer_vector<uint8_t, 8> pattern = m_key.m_pattern;
-  for (size_t i = 0; i < pattern.size(); ++i)
+  for (size_t i = 0; i < m_key.m_pattern.size(); ++i)
   {
-    uint8_t value = (i & 0x1) == 0 ? 255 : 0;
-    uint8_t length = m_key.m_pattern[i];
-    memset(pixels + offset, value, length * sizeof(uint8_t));
+    uint8_t const value = (i & 0x1) == 0 ? 255 : 0;
+    uint8_t const length = m_key.m_pattern[i];
+    memset(pixels + offset, value, length);
     offset += length;
   }
 
-  uint8_t period = offset - 1;
-
+  // clone pattern
+  uint32_t const patternLength = offset - 1;
   while (offset < m_pixelLength + 1)
   {
-    memcpy(pixels + offset, pixels + 1, period);
-    offset += period;
+    memcpy(pixels + offset, pixels + 1, patternLength);
+    offset += patternLength;
   }
 
   ASSERT_LESS(offset, kMaxStipplePenLength, ());
@@ -126,41 +82,38 @@ void StipplePenRasterizator::Rasterize(void * buffer)
 ref_ptr<Texture::ResourceInfo> StipplePenIndex::ReserveResource(bool predefined, StipplePenKey const & key,
                                                                 bool & newResource)
 {
-  std::lock_guard<std::mutex> g(m_mappingLock);
-
-  newResource = false;
-  StipplePenHandle handle(key);
   TResourceMapping & resourceMapping = predefined ? m_predefinedResourceMapping : m_resourceMapping;
-  TResourceMapping::iterator it = resourceMapping.find(handle);
+  auto it = resourceMapping.find(key);
   if (it != resourceMapping.end())
+  {
+    newResource = false;
     return make_ref(&it->second);
-
+  }
   newResource = true;
 
   StipplePenRasterizator resource(key);
-  m2::RectU pixelRect = m_packer.PackResource(resource.GetSize());
+  m2::RectU const pixelRect = m_packer.PackResource(resource.GetSize());
   {
     std::lock_guard<std::mutex> g(m_lock);
-    m_pendingNodes.push_back(std::make_pair(pixelRect, resource));
+    m_pendingNodes.emplace_back(pixelRect, resource);
   }
 
-  auto res = resourceMapping.emplace(handle, StipplePenResourceInfo(m_packer.MapTextureCoords(pixelRect),
-                                                                    resource.GetSize(),
-                                                                    resource.GetPatternSize()));
+  auto res = resourceMapping.emplace(key, StipplePenResourceInfo(m_packer.MapTextureCoords(pixelRect),
+                                                                 resource.GetSize()));
   ASSERT(res.second, ());
   return make_ref(&res.first->second);
 }
 
 ref_ptr<Texture::ResourceInfo> StipplePenIndex::MapResource(StipplePenKey const & key, bool & newResource)
 {
-  StipplePenHandle handle(key);
-  TResourceMapping::iterator it = m_predefinedResourceMapping.find(handle);
+  auto it = m_predefinedResourceMapping.find(key);
   if (it != m_predefinedResourceMapping.end())
   {
     newResource = false;
     return make_ref(&it->second);
   }
 
+  std::lock_guard<std::mutex> g(m_mappingLock);
   return ReserveResource(false /* predefined */, key, newResource);
 }
 
@@ -175,31 +128,27 @@ void StipplePenIndex::UploadResources(ref_ptr<dp::GraphicsContext> context, ref_
     m_pendingNodes.swap(pendingNodes);
   }
 
-  SharedBufferManager & mng = SharedBufferManager::instance();
+  uint32_t const nodesCount = static_cast<uint32_t>(pendingNodes.size());
   uint32_t const bytesPerNode = kMaxStipplePenLength * kStippleHeight;
-  uint32_t reserveBufferSize = base::NextPowOf2(static_cast<uint32_t>(pendingNodes.size()) * bytesPerNode);
+  uint32_t const reserveBufferSize = base::NextPowOf2(nodesCount * bytesPerNode);
+
+  SharedBufferManager & mng = SharedBufferManager::instance();
   SharedBufferManager::shared_buffer_ptr_t ptr = mng.reserveSharedBuffer(reserveBufferSize);
   uint8_t * rawBuffer = SharedBufferManager::GetRawPointer(ptr);
   memset(rawBuffer, 0, reserveBufferSize);
-  for (size_t i = 0; i < pendingNodes.size(); ++i)
+
+  for (uint32_t i = 0; i < nodesCount; ++i)
     pendingNodes[i].second.Rasterize(rawBuffer + i * bytesPerNode);
 
   texture->UploadData(context, 0, pendingNodes.front().first.minY(), kMaxStipplePenLength,
-                      static_cast<uint32_t>(pendingNodes.size()) * kStippleHeight, make_ref(rawBuffer));
+                      nodesCount * kStippleHeight, make_ref(rawBuffer));
 
   mng.freeSharedBuffer(reserveBufferSize, ptr);
 }
 
-void StipplePenTexture::ReservePattern(buffer_vector<uint8_t, 8> const & pattern)
+void StipplePenTexture::ReservePattern(PenPatternT const & pattern)
 {
   bool newResource = false;
   m_indexer->ReserveResource(true /* predefined */, StipplePenKey(pattern), newResource);
 }
-
-std::string DebugPrint(StipplePenHandle const & key)
-{
-  std::ostringstream out;
-  out << "0x" << std::hex << key.m_keyValue;
-  return out.str();
-}
 }  // namespace dp
diff --git a/drape/stipple_pen_resource.hpp b/drape/stipple_pen_resource.hpp
index 230d64f499..eb08d20b4f 100644
--- a/drape/stipple_pen_resource.hpp
+++ b/drape/stipple_pen_resource.hpp
@@ -17,74 +17,56 @@
 
 namespace dp
 {
+// Based on ./data/patterns.txt, all paterns have 2 entries now.
+using PenPatternT = buffer_vector<uint8_t, 2>;
+
 class StipplePenKey : public Texture::Key
 {
 public:
   StipplePenKey() = default;
-  StipplePenKey(buffer_vector<uint8_t, 8> const & pattern) : m_pattern(pattern) {}
+  explicit StipplePenKey(PenPatternT const & pattern) : m_pattern(pattern) {}
+
   virtual Texture::ResourceType GetType() const { return Texture::ResourceType::StipplePen; }
 
-  buffer_vector<uint8_t, 8> m_pattern;
-};
+  bool operator<(StipplePenKey const & rhs) const { return m_pattern < rhs.m_pattern; }
+  bool operator==(StipplePenKey const & rhs) const { return m_pattern == rhs.m_pattern; }
 
-class StipplePenHandle
-{
-public:
-  StipplePenHandle(uint64_t value) : m_keyValue(value) {} // don't use this ctor. Only for tests
-  StipplePenHandle(buffer_vector<uint8_t, 8> const & pattern);
-  StipplePenHandle(StipplePenKey const & info);
-
-  bool operator == (StipplePenHandle const & other) const { return m_keyValue == other.m_keyValue; }
-  bool operator < (StipplePenHandle const & other) const { return m_keyValue < other.m_keyValue; }
-
-private:
-  void Init(buffer_vector<uint8_t, 8> const & pattern);
-
-private:
-  friend std::string DebugPrint(StipplePenHandle const &);
-  uint64_t m_keyValue;
+  PenPatternT m_pattern;
 };
 
 class StipplePenRasterizator
 {
 public:
-  StipplePenRasterizator() : m_pixelLength(0), m_patternLength(0) {}
-  StipplePenRasterizator(StipplePenKey const & key);
+  explicit StipplePenRasterizator(StipplePenKey const & key);
 
   uint32_t GetSize() const;
-  uint32_t GetPatternSize() const;
 
-  void Rasterize(void * buffer);
+  void Rasterize(uint8_t * buffer);
 
 private:
   StipplePenKey m_key;
   uint32_t m_pixelLength;
-  uint32_t m_patternLength;
 };
 
 class StipplePenResourceInfo : public Texture::ResourceInfo
 {
 public:
-  StipplePenResourceInfo(m2::RectF const & texRect, uint32_t pixelLength, uint32_t patternLength)
-    : Texture::ResourceInfo(texRect)
-    , m_pixelLength(pixelLength)
-    , m_patternLength(patternLength)
+  StipplePenResourceInfo(m2::RectF const & texRect, uint32_t pixelLength)
+    : Texture::ResourceInfo(texRect), m_pixelLength(pixelLength)
   {
   }
 
   virtual Texture::ResourceType GetType() const { return Texture::ResourceType::StipplePen; }
   uint32_t GetMaskPixelLength() const { return m_pixelLength; }
-  uint32_t GetPatternPixelLength() const { return m_patternLength; }
 
 private:
   uint32_t m_pixelLength;
-  uint32_t m_patternLength;
 };
 
 class StipplePenPacker
 {
 public:
-  StipplePenPacker(m2::PointU const & canvasSize);
+  explicit StipplePenPacker(m2::PointU const & canvasSize);
 
   m2::RectU PackResource(uint32_t width);
   m2::RectF MapTextureCoords(m2::RectU const & pixelRect) const;
@@ -97,19 +79,28 @@ private:
 class StipplePenIndex
 {
 public:
-  StipplePenIndex(m2::PointU const & canvasSize) : m_packer(canvasSize) {}
+  explicit StipplePenIndex(m2::PointU const & canvasSize) : m_packer(canvasSize) {}
+  /// @param[out] newResource Needed for the generic DynamicTexture code.
+  /// @{
+  // Called from TextureManager::Init and fills m_predefinedResourceMapping, no need in m_mappingLock.
   ref_ptr<Texture::ResourceInfo> ReserveResource(bool predefined, StipplePenKey const & key,
                                                  bool & newResource);
+  // Checks m_predefinedResourceMapping, fills m_resourceMapping, locks m_mappingLock.
   ref_ptr<Texture::ResourceInfo> MapResource(StipplePenKey const & key, bool & newResource);
+  /// @}
   void UploadResources(ref_ptr<dp::GraphicsContext> context, ref_ptr<Texture> texture);
 
 private:
-  typedef std::map<StipplePenHandle, StipplePenResourceInfo> TResourceMapping;
+  // std::unordered_map can be better here
+  typedef std::map<StipplePenKey, StipplePenResourceInfo> TResourceMapping;
   typedef std::pair<m2::RectU, StipplePenRasterizator> TPendingNode;
-  typedef buffer_vector<TPendingNode, 32> TPendingNodes;
+  typedef std::vector<TPendingNode> TPendingNodes;
 
+  // Initialized once via ReserveResource.
   TResourceMapping m_predefinedResourceMapping;
+  // Filled async via MapResource, protected with m_mappingLock.
   TResourceMapping m_resourceMapping;
+
   TPendingNodes m_pendingNodes;
   StipplePenPacker m_packer;
 
@@ -117,12 +108,11 @@ private:
   std::mutex m_mappingLock;
 };
 
-std::string DebugPrint(StipplePenHandle const & key);
-
 class StipplePenTexture : public DynamicTexture<StipplePenIndex, StipplePenKey,
                                                 Texture::ResourceType::StipplePen>
 {
   using TBase = DynamicTexture<StipplePenIndex, StipplePenKey, Texture::ResourceType::StipplePen>;
+
 public:
   StipplePenTexture(m2::PointU const & size, ref_ptr<HWTextureAllocator> allocator)
     : m_index(size)
@@ -134,7 +124,7 @@ public:
 
   ~StipplePenTexture() override { TBase::Reset(); }
 
-  void ReservePattern(buffer_vector<uint8_t, 8> const & pattern);
+  void ReservePattern(PenPatternT const & pattern);
 
 private:
   StipplePenIndex m_index;
diff --git a/drape/texture_manager.cpp b/drape/texture_manager.cpp
index e258e5a7c5..b5fb98a0ba 100644
--- a/drape/texture_manager.cpp
+++ b/drape/texture_manager.cpp
@@ -11,6 +11,7 @@
 #include "platform/platform.hpp"
 
 #include "coding/reader.hpp"
+#include "coding/reader_streambuf.hpp"
 
 #include "base/buffer_vector.hpp"
 #include "base/file_name_utils.hpp"
@@ -28,13 +29,16 @@
 
 namespace dp
 {
+namespace
+{
 uint32_t const kMaxTextureSize = 1024;
-uint32_t const kStippleTextureWidth = 512;
+uint32_t const kStippleTextureWidth = 512;  /// @todo Should be equal with kMaxStipplePenLength?
 uint32_t const kMinStippleTextureHeight = 64;
 uint32_t const kMinColorTextureSize = 32;
 uint32_t const kGlyphsTextureSize = 1024;
 size_t const kInvalidGlyphGroup = std::numeric_limits<size_t>::max();
 
+// Reserved for elements like RuleDrawer or other LineShapes.
 uint32_t const kReservedPatterns = 10;
 size_t const kReservedColors = 20;
 
@@ -44,8 +48,6 @@ float const kGlyphAreaCoverage = 0.9f;
 std::string const kSymbolTextures[] = { "symbols" };
 uint32_t const kDefaultSymbolsIndex = 0;
 
-namespace
-{
 void MultilineTextToUniString(TextureManager::TMultilineText const & text, strings::UniString & outString)
 {
   size_t cnt = 0;
@@ -58,32 +60,15 @@ void MultilineTextToUniString(TextureManager::TMultilineText const & text, strin
     outString.append(str.begin(), str.end());
 }
 
-std::string ReadFileToString(std::string const & filename)
-{
-  std::string result;
-  try
-  {
-    ReaderPtr<Reader>(GetPlatform().GetReader(filename)).ReadAsString(result);
-  }
-  catch(RootException const & e)
-  {
-    LOG(LWARNING, ("Error reading file ", filename, " : ", e.what()));
-    return "";
-  }
-  return result;
-}
-
 template <typename ToDo>
 void ParseColorsList(std::string const & colorsFile, ToDo toDo)
 {
-  std::istringstream fin(ReadFileToString(colorsFile));
-  while (true)
+  ReaderStreamBuf buffer(GetPlatform().GetReader(colorsFile));
+  std::istream is(&buffer);
+  while (is.good())
   {
     uint32_t color;
-    fin >> color;
-    if (!fin)
-      break;
-
+    is >> color;
     toDo(dp::Extract(color));
   }
 }
@@ -91,13 +76,14 @@ void ParseColorsList(std::string const & colorsFile, ToDo toDo)
 template <typename ToDo>
 void ParsePatternsList(std::string const & patternsFile, ToDo && toDo)
 {
-  strings::Tokenize(ReadFileToString(patternsFile), "\n", [&](std::string_view patternStr)
-  {
-    if (patternStr.empty())
-      return;
+  ReaderStreamBuf buffer(GetPlatform().GetReader(patternsFile));
+  std::istream is(&buffer);
 
+  std::string line;
+  while (std::getline(is, line))
+  {
     buffer_vector<double, 8> pattern;
-    strings::Tokenize(patternStr, " ", [&](std::string_view token)
+    strings::Tokenize(line, " ", [&](std::string_view token)
     {
       double d = 0.0;
       VERIFY(strings::to_double(token, d), ());
@@ -109,7 +95,7 @@ void ParsePatternsList(std::string const & patternsFile, ToDo && toDo)
     {
       if (fabs(pattern[i]) < 1e-5)
       {
-        LOG(LWARNING, ("Pattern was skipped", patternStr));
+        LOG(LWARNING, ("Pattern was skipped", line));
         isValid = false;
         break;
       }
@@ -117,21 +103,26 @@ void ParsePatternsList(std::string const & patternsFile, ToDo && toDo)
 
     if (isValid)
       toDo(pattern);
-  });
+  }
 }
 
 m2::PointU StipplePenTextureSize(size_t patternsCount, uint32_t maxTextureSize)
 {
   uint32_t const sz = base::NextPowOf2(static_cast<uint32_t>(patternsCount) + kReservedPatterns);
-  uint32_t const stippleTextureHeight =
-      std::min(maxTextureSize, std::max(sz, kMinStippleTextureHeight));
+  // No problem if assert will fire here. Just pen texture will be 2x bigger :)
+  ASSERT_LESS_OR_EQUAL(sz, kMinStippleTextureHeight, ());
+  uint32_t const stippleTextureHeight = std::min(maxTextureSize, std::max(sz, kMinStippleTextureHeight));
+
   return m2::PointU(kStippleTextureWidth, stippleTextureHeight);
 }
 
 m2::PointU ColorTextureSize(size_t colorsCount, uint32_t maxTextureSize)
 {
   uint32_t const sz = static_cast<uint32_t>(floor(sqrt(colorsCount + kReservedColors)));
+  // No problem if assert will fire here. Just color texture will be 2x bigger :)
+  ASSERT_LESS_OR_EQUAL(sz, kMinColorTextureSize, ());
   uint32_t colorTextureSize = std::max(base::NextPowOf2(sz), kMinColorTextureSize);
+
   colorTextureSize *= ColorTexture::GetColorSizeInPixels();
   colorTextureSize = std::min(maxTextureSize, colorTextureSize);
   return m2::PointU(colorTextureSize, colorTextureSize);
@@ -229,11 +220,11 @@ uint32_t TextureManager::StippleRegion::GetMaskPixelLength() const
   return ref_ptr<StipplePenResourceInfo>(m_info)->GetMaskPixelLength();
 }
 
-uint32_t TextureManager::StippleRegion::GetPatternPixelLength() const
-{
-  ASSERT(m_info->GetType() == Texture::ResourceType::StipplePen, ());
-  return ref_ptr<StipplePenResourceInfo>(m_info)->GetPatternPixelLength();
-}
+//uint32_t TextureManager::StippleRegion::GetPatternPixelLength() const
+//{
+//  ASSERT(m_info->GetType() == Texture::ResourceType::StipplePen, ());
+//  return ref_ptr<StipplePenResourceInfo>(m_info)->GetPatternPixelLength();
+//}
 
 void TextureManager::Release()
 {
@@ -437,9 +428,9 @@ void TextureManager::Init(ref_ptr<dp::GraphicsContext> context, Params const & p
     GLFunctions::glPixelStore(gl_const::GLUnpackAlignment, 1);
 
   // Initialize symbols.
-  for (size_t i = 0; i < ARRAY_SIZE(kSymbolTextures); ++i)
+  for (auto const & texName : kSymbolTextures)
   {
-    m_symbolTextures.push_back(make_unique_dp<SymbolsTexture>(context, m_resPostfix, kSymbolTextures[i],
+    m_symbolTextures.push_back(make_unique_dp<SymbolsTexture>(context, m_resPostfix, texName,
                                                               make_ref(m_textureAllocator)));
   }
 
@@ -458,26 +449,28 @@ void TextureManager::Init(ref_ptr<dp::GraphicsContext> context, Params const & p
                                                         dp::TextureFormat::Alpha, make_ref(m_textureAllocator));
   }
 
-  // Initialize patterns.
-  buffer_vector<buffer_vector<uint8_t, 8>, 64> patterns;
+  // Initialize patterns (reserved ./data/patterns.txt lines count).
+  std::vector<PenPatternT> patterns;
+  patterns.reserve(kMinStippleTextureHeight);
+
   double const visualScale = params.m_visualScale;
   ParsePatternsList(params.m_patterns, [&patterns, visualScale](buffer_vector<double, 8> const & pattern)
   {
-    buffer_vector<uint8_t, 8> p;
+    patterns.push_back({});
     for (size_t i = 0; i < pattern.size(); i++)
-      p.push_back(static_cast<uint8_t>(pattern[i] * visualScale));
-    patterns.push_back(std::move(p));
+      patterns.back().push_back(static_cast<uint8_t>(pattern[i] * visualScale));
   });
   m_stipplePenTexture = make_unique_dp<StipplePenTexture>(StipplePenTextureSize(patterns.size(), m_maxTextureSize),
                                                           make_ref(m_textureAllocator));
   LOG(LDEBUG, ("Patterns texture size =", m_stipplePenTexture->GetWidth(), m_stipplePenTexture->GetHeight()));
 
   ref_ptr<StipplePenTexture> stipplePenTextureTex = make_ref(m_stipplePenTexture);
-  for (auto it = patterns.begin(); it != patterns.end(); ++it)
-    stipplePenTextureTex->ReservePattern(*it);
+  for (auto const & p : patterns)
+    stipplePenTextureTex->ReservePattern(p);
 
-  // Initialize colors.
-  buffer_vector<dp::Color, 256> colors;
+  // Initialize colors (reserved ./data/colors.txt lines count).
+  std::vector<dp::Color> colors;
+  colors.reserve(512);
   ParseColorsList(params.m_colors, [&colors](dp::Color const & color)
   {
     colors.push_back(color);
@@ -487,8 +480,8 @@ void TextureManager::Init(ref_ptr<dp::GraphicsContext> context, Params const & p
   LOG(LDEBUG, ("Colors texture size =", m_colorTexture->GetWidth(), m_colorTexture->GetHeight()));
 
   ref_ptr<ColorTexture> colorTex = make_ref(m_colorTexture);
-  for (auto it = colors.begin(); it != colors.end(); ++it)
-    colorTex->ReserveColor(*it);
+  for (auto const & c : colors)
+    colorTex->ReserveColor(c);
 
   // Initialize glyphs.
   m_glyphManager = make_unique_dp<GlyphManager>(params.m_glyphMngParams);
@@ -558,7 +551,7 @@ bool TextureManager::HasSymbolRegion(std::string const & symbolName) const
   return false;
 }
 
-void TextureManager::GetStippleRegion(TStipplePattern const & pen, StippleRegion & region)
+void TextureManager::GetStippleRegion(PenPatternT const & pen, StippleRegion & region)
 {
   CHECK(m_isInitialized, ());
   GetRegionBase(make_ref(m_stipplePenTexture), region, StipplePenKey(pen));
diff --git a/drape/texture_manager.hpp b/drape/texture_manager.hpp
index d34989dd5e..f5df9c434f 100644
--- a/drape/texture_manager.hpp
+++ b/drape/texture_manager.hpp
@@ -1,11 +1,12 @@
 #pragma once
 
 #include "drape/color.hpp"
+#include "drape/font_texture.hpp"
 #include "drape/glyph_generator.hpp"
 #include "drape/glyph_manager.hpp"
 #include "drape/pointers.hpp"
+#include "drape/stipple_pen_resource.hpp"   // for PenPatternT
 #include "drape/texture.hpp"
-#include "drape/font_texture.hpp"
 
 #include "base/string_utils.hpp"
 #include "base/timer.hpp"
@@ -19,8 +20,6 @@
 
 namespace dp
 {
-extern std::string const kDefaultSymbolsTexture;
-
 class HWTextureAllocator;
 
 class TextureManager
@@ -70,7 +69,7 @@ public:
     StippleRegion() : BaseRegion() {}
 
     uint32_t GetMaskPixelLength() const;
-    uint32_t GetPatternPixelLength() const;
+    //uint32_t GetPatternPixelLength() const;
   };
 
   class ColorRegion : public BaseRegion
@@ -98,8 +97,7 @@ public:
   void GetSymbolRegion(std::string const & symbolName, SymbolRegion & region);
   bool HasSymbolRegion(std::string const & symbolName) const;
 
-  typedef buffer_vector<uint8_t, 8> TStipplePattern;
-  void GetStippleRegion(TStipplePattern const & pen, StippleRegion & region);
+  void GetStippleRegion(PenPatternT const & pen, StippleRegion & region);
   void GetColorRegion(Color const & color, ColorRegion & region);
 
   using TMultilineText = buffer_vector<strings::UniString, 4>;
diff --git a/drape/texture_of_colors.cpp b/drape/texture_of_colors.cpp
index 4c34122de4..a0637efe75 100644
--- a/drape/texture_of_colors.cpp
+++ b/drape/texture_of_colors.cpp
@@ -21,10 +21,8 @@ ColorPalette::ColorPalette(m2::PointU const & canvasSize)
 
 ref_ptr<Texture::ResourceInfo> ColorPalette::ReserveResource(bool predefined, ColorKey const & key, bool & newResource)
 {
-  std::lock_guard<std::mutex> lock(m_mappingLock);
-
   TPalette & palette = predefined ? m_predefinedPalette : m_palette;
-  TPalette::iterator itm = palette.find(key.m_color);
+  auto itm = palette.find(key.m_color);
   newResource = (itm == palette.end());
   if (newResource)
   {
@@ -61,12 +59,14 @@ ref_ptr<Texture::ResourceInfo> ColorPalette::ReserveResource(bool predefined, Co
 
 ref_ptr<Texture::ResourceInfo> ColorPalette::MapResource(ColorKey const & key, bool & newResource)
 {
-  TPalette::iterator itm = m_predefinedPalette.find(key.m_color);
+  auto itm = m_predefinedPalette.find(key.m_color);
   if (itm != m_predefinedPalette.end())
   {
     newResource = false;
     return make_ref(&itm->second);
   }
+
+  std::lock_guard<std::mutex> lock(m_mappingLock);
   return ReserveResource(false /* predefined */, key, newResource);
 }
 
@@ -78,6 +78,7 @@ void ColorPalette::UploadResources(ref_ptr<dp::GraphicsContext> context, ref_ptr
     std::lock_guard<std::mutex> g(m_lock);
     if (m_pendingNodes.empty())
       return;
+
     if (context->HasPartialTextureUpdates())
     {
       pendingNodes.swap(m_pendingNodes);
@@ -197,4 +198,4 @@ int ColorTexture::GetColorSizeInPixels()
   return kResourceSize;
 }
 
-}
+} // namespace dp
diff --git a/drape_frontend/shape_view_params.hpp b/drape_frontend/shape_view_params.hpp
index e4bc23c5e5..6cbc8d2e13 100644
--- a/drape_frontend/shape_view_params.hpp
+++ b/drape_frontend/shape_view_params.hpp
@@ -85,7 +85,7 @@ struct LineViewParams : CommonViewParams
   float m_width = 0.0f;
   dp::LineCap m_cap;
   dp::LineJoin m_join;
-  buffer_vector<uint8_t, 8> m_pattern;
+  dp::PenPatternT m_pattern;
   float m_baseGtoPScale = 1.0f;
   int m_zoomLevel = -1;
 };
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index 65dc323d64..2c2e88bba1 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -28,6 +28,8 @@
 
 namespace df
 {
+namespace
+{
 std::array<double, 20> const kLineWidthZoomFactor =
 {
 // 1   2    3    4    5    6    7    8    9    10   11   12   13   14   15   16   17   18   19   20
@@ -35,14 +37,6 @@ std::array<double, 20> const kLineWidthZoomFactor =
 };
 int const kLineSimplifyLevelEnd = 15;
 
-std::string DebugPrint(ColoredSymbolViewParams const & csvp)
-{
-  return DebugPrint(csvp.m_anchor) + DebugPrint(csvp.m_color) +
-         DebugPrint(csvp.m_sizeInPixels) + DebugPrint(csvp.m_offset);
-}
-
-namespace
-{
 template <typename TCreateVector>
 void AlignFormingNormals(TCreateVector const & fn, dp::Anchor anchor, dp::Anchor first,
                          dp::Anchor second, glsl::vec2 & firstNormal, glsl::vec2 & secondNormal)