User mark id contains information about user mark type. User line id added.

17 files changed, 127 insertions, 99 deletions

diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index 057a3a5ef4..d5ea7b38a7 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -229,8 +229,8 @@ void DrapeEngine::UpdateUserMarks(UserMarksProvider * provider)
 
   auto marksRenderCollection = make_unique_dp<UserMarksRenderCollection>();
   auto linesRenderCollection = make_unique_dp<UserLinesRenderCollection>();
-  auto createdIdCollection = make_unique_dp<MarkIDCollection>();
-  auto removedIdCollection = make_unique_dp<MarkIDCollection>();
+  auto createdIdCollection = make_unique_dp<IDCollections>();
+  auto removedIdCollection = make_unique_dp<IDCollections>();
 
   df::MarkGroupID lastGroupId = *dirtyGroupIds.begin();
   bool visibilityChanged = provider->IsGroupVisiblityChanged(lastGroupId);
@@ -239,7 +239,7 @@ void DrapeEngine::UpdateUserMarks(UserMarksProvider * provider)
   auto const HandleMark = [&](
     df::MarkID markId,
     UserMarksRenderCollection & renderCollection,
-    IDCollection * idCollection)
+    MarkIDCollection * idCollection)
   {
     auto const * mark = provider->GetUserPointMark(markId);
     if (!mark->IsDirty())
@@ -269,10 +269,10 @@ void DrapeEngine::UpdateUserMarks(UserMarksProvider * provider)
   removedIdCollection->m_marksID.reserve(removedMarkIds.size());
   removedIdCollection->m_marksID.assign(removedMarkIds.begin(), removedMarkIds.end());
 
-  std::map<df::MarkGroupID, drape_ptr<MarkIDCollection>> dirtyMarkIds;
+  std::map<df::MarkGroupID, drape_ptr<IDCollections>> dirtyMarkIds;
   for (auto groupId : dirtyGroupIds)
   {
-    auto & idCollection = *(dirtyMarkIds.emplace(groupId, make_unique_dp<MarkIDCollection>()).first->second);
+    auto & idCollection = *(dirtyMarkIds.emplace(groupId, make_unique_dp<IDCollections>()).first->second);
     visibilityChanged = provider->IsGroupVisiblityChanged(groupId);
     groupIsVisible = provider->IsGroupVisible(groupId);
     if (!groupIsVisible && !visibilityChanged)
diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp
index 0b259f541c..9191638647 100644
--- a/drape_frontend/message_subclasses.hpp
+++ b/drape_frontend/message_subclasses.hpp
@@ -239,8 +239,8 @@ private:
 class UpdateUserMarksMessage : public Message
 {
 public:
-  UpdateUserMarksMessage(drape_ptr<MarkIDCollection> && createdIds,
-                         drape_ptr<MarkIDCollection> && removedIds,
+  UpdateUserMarksMessage(drape_ptr<IDCollections> && createdIds,
+                         drape_ptr<IDCollections> && removedIds,
                          drape_ptr<UserMarksRenderCollection> && marksRenderParams,
                          drape_ptr<UserLinesRenderCollection> && linesRenderParams)
     : m_createdIds(std::move(createdIds))
@@ -253,12 +253,12 @@ public:
 
   drape_ptr<UserMarksRenderCollection> && AcceptMarkRenderParams() { return std::move(m_marksRenderParams); }
   drape_ptr<UserLinesRenderCollection> && AcceptLineRenderParams() { return std::move(m_linesRenderParams); }
-  drape_ptr<MarkIDCollection> && AcceptRemovedIds() { return std::move(m_removedIds); }
-  drape_ptr<MarkIDCollection> && AcceptCreatedIds() { return std::move(m_createdIds); }
+  drape_ptr<IDCollections> && AcceptRemovedIds() { return std::move(m_removedIds); }
+  drape_ptr<IDCollections> && AcceptCreatedIds() { return std::move(m_createdIds); }
 
 private:
-  drape_ptr<MarkIDCollection> m_createdIds;
-  drape_ptr<MarkIDCollection> m_removedIds;
+  drape_ptr<IDCollections> m_createdIds;
+  drape_ptr<IDCollections> m_removedIds;
   drape_ptr<UserMarksRenderCollection> m_marksRenderParams;
   drape_ptr<UserLinesRenderCollection> m_linesRenderParams;
 };
@@ -267,7 +267,7 @@ class UpdateUserMarkGroupMessage : public Message
 {
 public:
   UpdateUserMarkGroupMessage(MarkGroupID groupId,
-                             drape_ptr<MarkIDCollection> && ids)
+                             drape_ptr<IDCollections> && ids)
     : m_groupId(groupId)
     , m_ids(std::move(ids))
   {}
@@ -275,11 +275,11 @@ public:
   Type GetType() const override { return Message::UpdateUserMarkGroup; }
 
   MarkGroupID GetGroupId() const { return m_groupId; }
-  drape_ptr<MarkIDCollection> && AcceptIds() { return std::move(m_ids); }
+  drape_ptr<IDCollections> && AcceptIds() { return std::move(m_ids); }
 
 private:
   MarkGroupID m_groupId;
-  drape_ptr<MarkIDCollection> m_ids;
+  drape_ptr<IDCollections> m_ids;
 };
 
 using FlushUserMarksMessage = FlushRenderDataMessage<TUserMarksRenderData,
diff --git a/drape_frontend/user_mark_generator.cpp b/drape_frontend/user_mark_generator.cpp
index 8a96d59611..79be6c90f4 100644
--- a/drape_frontend/user_mark_generator.cpp
+++ b/drape_frontend/user_mark_generator.cpp
@@ -28,13 +28,13 @@ void UserMarkGenerator::RemoveGroup(MarkGroupID groupId)
   UpdateIndex(groupId);
 }
 
-void UserMarkGenerator::SetGroup(MarkGroupID groupId, drape_ptr<MarkIDCollection> && ids)
+void UserMarkGenerator::SetGroup(MarkGroupID groupId, drape_ptr<IDCollections> && ids)
 {
   m_groups[groupId] = std::move(ids);
   UpdateIndex(groupId);
 }
 
-void UserMarkGenerator::SetRemovedUserMarks(drape_ptr<MarkIDCollection> && ids)
+void UserMarkGenerator::SetRemovedUserMarks(drape_ptr<IDCollections> && ids)
 {
   if (ids == nullptr)
     return;
@@ -44,7 +44,7 @@ void UserMarkGenerator::SetRemovedUserMarks(drape_ptr<MarkIDCollection> && ids)
     m_lines.erase(id);
 }
 
-void UserMarkGenerator::SetCreatedUserMarks(drape_ptr<MarkIDCollection> && ids)
+void UserMarkGenerator::SetCreatedUserMarks(drape_ptr<IDCollections> && ids)
 {
   if (ids == nullptr)
     return;
@@ -93,7 +93,7 @@ void UserMarkGenerator::UpdateIndex(MarkGroupID groupId)
   if (groupIt == m_groups.end())
     return;
 
-  MarkIDCollection & idCollection = *groupIt->second.get();
+  IDCollections & idCollection = *groupIt->second.get();
 
   for (auto markId : idCollection.m_marksID)
   {
@@ -101,7 +101,7 @@ void UserMarkGenerator::UpdateIndex(MarkGroupID groupId)
     for (int zoomLevel = params.m_minZoom; zoomLevel <= scales::GetUpperScale(); ++zoomLevel)
     {
       TileKey const tileKey = GetTileKeyByPoint(params.m_pivot, zoomLevel);
-      ref_ptr<MarkIDCollection> groupIDs = GetIdCollection(tileKey, groupId);
+      ref_ptr<IDCollections> groupIDs = GetIdCollection(tileKey, groupId);
       groupIDs->m_marksID.push_back(static_cast<uint32_t>(markId));
     }
   }
@@ -125,7 +125,7 @@ void UserMarkGenerator::UpdateIndex(MarkGroupID groupId)
         CalcTilesCoverage(segmentRect, zoomLevel, [&](int tileX, int tileY)
         {
           TileKey const tileKey(tileX, tileY, zoomLevel);
-          ref_ptr<MarkIDCollection> groupIDs = GetIdCollection(tileKey, groupId);
+          ref_ptr<IDCollections> groupIDs = GetIdCollection(tileKey, groupId);
           groupIDs->m_linesID.push_back(static_cast<uint32_t>(lineId));
         });
         return true;
@@ -136,7 +136,7 @@ void UserMarkGenerator::UpdateIndex(MarkGroupID groupId)
   CleanIndex();
 }
 
-ref_ptr<MarkIDCollection> UserMarkGenerator::GetIdCollection(TileKey const & tileKey, MarkGroupID groupId)
+ref_ptr<IDCollections> UserMarkGenerator::GetIdCollection(TileKey const & tileKey, MarkGroupID groupId)
 {
   ref_ptr<MarksIDGroups> tileGroups;
   auto itTileGroups = m_index.find(tileKey);
@@ -151,11 +151,11 @@ ref_ptr<MarkIDCollection> UserMarkGenerator::GetIdCollection(TileKey const & til
     tileGroups = make_ref(itTileGroups->second);
   }
 
-  ref_ptr<MarkIDCollection> groupIDs;
+  ref_ptr<IDCollections> groupIDs;
   auto itGroupIDs = tileGroups->find(groupId);
   if (itGroupIDs == tileGroups->end())
   {
-    auto groupMarkIndexes = make_unique_dp<MarkIDCollection>();
+    auto groupMarkIndexes = make_unique_dp<IDCollections>();
     groupIDs = make_ref(groupMarkIndexes);
     tileGroups->insert(make_pair(groupId, std::move(groupMarkIndexes)));
   }
diff --git a/drape_frontend/user_mark_generator.hpp b/drape_frontend/user_mark_generator.hpp
index 0013041f8f..60adce9d34 100644
--- a/drape_frontend/user_mark_generator.hpp
+++ b/drape_frontend/user_mark_generator.hpp
@@ -12,7 +12,7 @@
 
 namespace df
 {
-using MarksIDGroups = std::map<MarkGroupID, drape_ptr<MarkIDCollection>>;
+using MarksIDGroups = std::map<MarkGroupID, drape_ptr<IDCollections>>;
 using MarksIndex = std::map<TileKey, drape_ptr<MarksIDGroups>>;
 
 class UserMarkGenerator
@@ -24,10 +24,10 @@ public:
 
   void SetUserMarks(drape_ptr<UserMarksRenderCollection> && marks);
   void SetUserLines(drape_ptr<UserLinesRenderCollection> && lines);
-  void SetRemovedUserMarks(drape_ptr<MarkIDCollection> && ids);
-  void SetCreatedUserMarks(drape_ptr<MarkIDCollection> && ids);
+  void SetRemovedUserMarks(drape_ptr<IDCollections> && ids);
+  void SetCreatedUserMarks(drape_ptr<IDCollections> && ids);
 
-  void SetGroup(MarkGroupID groupId, drape_ptr<MarkIDCollection> && ids);
+  void SetGroup(MarkGroupID groupId, drape_ptr<IDCollections> && ids);
   void RemoveGroup(MarkGroupID groupId);
   void SetGroupVisibility(MarkGroupID groupId, bool isVisible);
 
@@ -36,7 +36,7 @@ public:
 private:
   void UpdateIndex(MarkGroupID groupId);
 
-  ref_ptr<MarkIDCollection> GetIdCollection(TileKey const & tileKey, MarkGroupID groupId);
+  ref_ptr<IDCollections> GetIdCollection(TileKey const & tileKey, MarkGroupID groupId);
   void CleanIndex();
 
   int GetNearestLineIndexZoom(int zoom) const;
diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp
index f7bcd56165..655d2b0d43 100644
--- a/drape_frontend/user_mark_shapes.cpp
+++ b/drape_frontend/user_mark_shapes.cpp
@@ -96,7 +96,7 @@ struct UserPointVertex : gpu::BaseVertex
 } // namespace
 
 void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    IDCollection const & marksId, UserMarksRenderCollection & renderParams,
+                    MarkIDCollection const & marksId, UserMarksRenderCollection & renderParams,
                     dp::Batcher & batcher)
 {
   float const vs = static_cast<float>(df::VisualParams::Instance().GetVisualScale());
@@ -338,7 +338,7 @@ void ProcessSplineSegmentRects(m2::SharedSpline const & spline, double maxSegmen
 }
 
 void CacheUserLines(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    IDCollection const & linesId, UserLinesRenderCollection & renderParams,
+                    LineIDCollection const & linesId, UserLinesRenderCollection & renderParams,
                     dp::Batcher & batcher)
 {
   float const vs = static_cast<float>(df::VisualParams::Instance().GetVisualScale());
diff --git a/drape_frontend/user_mark_shapes.hpp b/drape_frontend/user_mark_shapes.hpp
index f649dc5400..3b5bb76529 100644
--- a/drape_frontend/user_mark_shapes.hpp
+++ b/drape_frontend/user_mark_shapes.hpp
@@ -81,10 +81,10 @@ void ProcessSplineSegmentRects(m2::SharedSpline const & spline, double maxSegmen
                                std::function<bool(m2::RectD const & segmentRect)> const & func);
 
 void CacheUserMarks(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    IDCollection const & marksId, UserMarksRenderCollection & renderParams,
+                    MarkIDCollection const & marksId, UserMarksRenderCollection & renderParams,
                     dp::Batcher & batcher);
 
 void CacheUserLines(TileKey const & tileKey, ref_ptr<dp::TextureManager> textures,
-                    IDCollection const & linesId, UserLinesRenderCollection & renderParams,
+                    LineIDCollection const & linesId, UserLinesRenderCollection & renderParams,
                     dp::Batcher & batcher);
 }  // namespace df
diff --git a/drape_frontend/user_marks_global.hpp b/drape_frontend/user_marks_global.hpp
index b815b159a5..3096c3d828 100644
--- a/drape_frontend/user_marks_global.hpp
+++ b/drape_frontend/user_marks_global.hpp
@@ -6,9 +6,12 @@
 namespace df
 {
 using MarkID = uint32_t;
+using LineID = uint32_t;
 using MarkGroupID = size_t;
-using IDCollection = std::vector<MarkID>;
+using MarkIDCollection = std::vector<MarkID>;
+using LineIDCollection = std::vector<LineID>;
 using MarkIDSet = std::set<MarkID>;
+using LineIDSet = std::set<LineID>;
 using GroupIDList = std::vector<MarkGroupID>;
 using GroupIDSet = std::set<MarkGroupID>;
 }  // namespace df
diff --git a/drape_frontend/user_marks_provider.cpp b/drape_frontend/user_marks_provider.cpp
index 7301accdc8..0a406070d0 100644
--- a/drape_frontend/user_marks_provider.cpp
+++ b/drape_frontend/user_marks_provider.cpp
@@ -1,24 +1,15 @@
 #include "user_marks_provider.hpp"
 
-namespace
-{
-df::MarkID GetNextUserMarkId()
-{
-  static uint32_t nextMarkId = 0;
-  return static_cast<df::MarkID>(++nextMarkId);
-}
-}  // namespace
-
 namespace df
 {
-UserPointMark::UserPointMark()
-  : m_id(GetNextUserMarkId())
+UserPointMark::UserPointMark(df::MarkID id)
+  : m_id(id)
 {
 }
 
 
-UserLineMark::UserLineMark()
-  : m_id(GetNextUserMarkId())
+UserLineMark::UserLineMark(df::LineID id)
+  : m_id(id)
 {
 }
 
diff --git a/drape_frontend/user_marks_provider.hpp b/drape_frontend/user_marks_provider.hpp
index 41b356cd97..fd35b62cc8 100644
--- a/drape_frontend/user_marks_provider.hpp
+++ b/drape_frontend/user_marks_provider.hpp
@@ -15,10 +15,10 @@
 
 namespace df
 {
-struct MarkIDCollection
+struct IDCollections
 {
-  IDCollection m_marksID;
-  IDCollection m_linesID;
+  MarkIDCollection m_marksID;
+  LineIDCollection m_linesID;
 
   bool IsEmpty()
   {
@@ -41,7 +41,7 @@ public:
   using SymbolSizes = std::vector<m2::PointF>;
   using SymbolOffsets = std::vector<m2::PointF>;
 
-  UserPointMark();
+  UserPointMark(df::MarkID id);
   virtual ~UserPointMark() {}
 
   virtual bool IsDirty() const = 0;
@@ -77,13 +77,13 @@ private:
 class UserLineMark
 {
 public:
-  UserLineMark();
+  UserLineMark(df::LineID id);
   virtual ~UserLineMark() {}
 
   virtual bool IsDirty() const = 0;
   virtual void ResetChanges() const = 0;
 
-  virtual MarkID GetId() const { return m_id; }
+  virtual LineID GetId() const { return m_id; }
 
   virtual int GetMinZoom() const = 0;
   virtual RenderState::DepthLayer GetDepthLayer() const = 0;
@@ -94,7 +94,7 @@ public:
   virtual std::vector<m2::PointD> const & GetPoints() const = 0;
 
 private:
-  MarkID m_id;
+  LineID m_id;
 };
 
 class UserMarksProvider
@@ -105,14 +105,14 @@ public:
   virtual bool IsGroupVisible(MarkGroupID groupID) const = 0;
   virtual bool IsGroupVisiblityChanged(MarkGroupID groupID) const = 0;
   virtual MarkIDSet const & GetGroupPointIds(MarkGroupID groupID) const = 0;
-  virtual MarkIDSet const & GetGroupLineIds(MarkGroupID groupID) const = 0;
+  virtual LineIDSet const & GetGroupLineIds(MarkGroupID groupID) const = 0;
   virtual MarkIDSet const & GetCreatedMarkIds() const = 0;
   virtual MarkIDSet const & GetRemovedMarkIds() const = 0;
   virtual MarkIDSet const & GetUpdatedMarkIds() const = 0;
   /// Never store UserPointMark reference.
   virtual UserPointMark const * GetUserPointMark(MarkID markID) const = 0;
  /// Never store UserLineMark reference.
-  virtual UserLineMark const * GetUserLineMark(MarkID markID) const = 0;
+  virtual UserLineMark const * GetUserLineMark(LineID lineID) const = 0;
 };
 
 } // namespace df
diff --git a/map/bookmark.cpp b/map/bookmark.cpp
index 4cf08451b9..25b4d98776 100644
--- a/map/bookmark.cpp
+++ b/map/bookmark.cpp
@@ -152,12 +152,12 @@ BookmarkCategory::~BookmarkCategory()
 {
 }
 
-void BookmarkCategory::AttachTrack(df::MarkID trackId)
+void BookmarkCategory::AttachTrack(df::LineID trackId)
 {
   m_tracks.insert(trackId);
 }
 
-void BookmarkCategory::DetachTrack(df::MarkID trackId)
+void BookmarkCategory::DetachTrack(df::LineID trackId)
 {
   m_tracks.erase(trackId);
 }
diff --git a/map/bookmark.hpp b/map/bookmark.hpp
index 925e50de47..2240a64921 100644
--- a/map/bookmark.hpp
+++ b/map/bookmark.hpp
@@ -121,11 +121,11 @@ public:
 
   static std::string GetDefaultType();
 
-  void AttachTrack(df::MarkID markId);
-  void DetachTrack(df::MarkID markId);
+  void AttachTrack(df::LineID markId);
+  void DetachTrack(df::LineID markId);
 
   df::MarkGroupID GetID() const { return m_groupID; }
-  df::MarkIDSet const & GetUserLines() const override { return m_tracks; }
+  df::LineIDSet const & GetUserLines() const override { return m_tracks; }
 
   void SetName(std::string const & name) { m_name = name; }
   void SetFileName(std::string const & fileName) { m_file = fileName; }
@@ -138,7 +138,7 @@ private:
   // Stores file name from which bookmarks were loaded.
   std::string m_file;
 
-  df::MarkIDSet m_tracks;
+  df::LineIDSet m_tracks;
 };
 
 struct KMLData
diff --git a/map/bookmark_manager.cpp b/map/bookmark_manager.cpp
index 7034cd9941..a36b7ca9a7 100644
--- a/map/bookmark_manager.cpp
+++ b/map/bookmark_manager.cpp
@@ -156,10 +156,9 @@ BookmarkManager::~BookmarkManager()
 
 UserMark const * BookmarkManager::GetMark(df::MarkID markID) const
 {
-  auto const * userMark = GetUserMark(markID);
-  if (userMark != nullptr)
-    return userMark;
-  return static_cast<UserMark const *>(GetBookmark(markID));
+  if (IsBookmark(markID))
+    return GetBookmark(markID);
+  return GetUserMark(markID);
 }
 
 UserMark const * BookmarkManager::GetUserMark(df::MarkID markID) const
@@ -267,25 +266,25 @@ Track * BookmarkManager::CreateTrack(m2::PolylineD const & polyline, Track::Para
   return AddTrack(std::make_unique<Track>(polyline, p));
 }
 
-Track const * BookmarkManager::GetTrack(df::MarkID trackID) const
+Track const * BookmarkManager::GetTrack(df::LineID trackID) const
 {
   auto it = m_tracks.find(trackID);
   return (it != m_tracks.end()) ? it->second.get() : nullptr;
 }
 
-void BookmarkManager::AttachTrack(df::MarkID trackID, df::MarkGroupID groupID)
+void BookmarkManager::AttachTrack(df::LineID trackID, df::MarkGroupID groupID)
 {
   auto it = m_tracks.find(trackID);
   it->second->Attach(groupID);
   GetBmCategory(groupID)->AttachTrack(trackID);
 }
 
-void BookmarkManager::DetachTrack(df::MarkID trackID, df::MarkGroupID groupID)
+void BookmarkManager::DetachTrack(df::LineID trackID, df::MarkGroupID groupID)
 {
   GetBmCategory(groupID)->DetachTrack(trackID);
 }
 
-void BookmarkManager::DeleteTrack(df::MarkID trackID)
+void BookmarkManager::DeleteTrack(df::LineID trackID)
 {
   auto it = m_tracks.find(trackID);
   auto const groupID = it->second->GetGroupId();
@@ -366,7 +365,7 @@ df::MarkIDSet const & BookmarkManager::GetUserMarkIds(df::MarkGroupID groupID) c
   return FindContainer(groupID)->GetUserMarks();
 }
 
-df::MarkIDSet const & BookmarkManager::GetTrackIds(df::MarkGroupID groupID) const
+df::LineIDSet const & BookmarkManager::GetTrackIds(df::MarkGroupID groupID) const
 {
   return FindContainer(groupID)->GetUserLines();
 }
@@ -416,9 +415,7 @@ UserMark const * BookmarkManager::FindMarkInRect(df::MarkGroupID groupID, m2::An
     FindMarkFunctor f(&mark, d, rect);
     for (auto markId : group->GetUserMarks())
     {
-      auto const * mark = IsBookmark(groupID)
-        ? static_cast<UserMark const *>(GetBookmark(markId))
-        : GetUserMark(markId);
+      auto const * mark = GetMark(markId);
       if (mark->IsAvailableForSearch() && rect.IsPointInside(mark->GetPivot()))
         f(mark);
     }
@@ -735,7 +732,11 @@ void BookmarkManager::SendBookmarksChanges()
   }
   if (m_callbacks.m_deletedBookmarksCallback != nullptr)
   {
-    df::IDCollection idCollection(m_removedMarks.begin(), m_removedMarks.end());
+    df::MarkIDCollection idCollection;
+    idCollection.reserve(m_removedMarks.size());
+    for (auto markId : m_removedMarks)
+      if (IsBookmark(markId))
+        idCollection.push_back(markId);
     m_callbacks.m_deletedBookmarksCallback(idCollection);
   }
 }
@@ -877,7 +878,7 @@ df::MarkIDSet const & BookmarkManager::GetGroupPointIds(df::MarkGroupID groupId)
   return GetUserMarkIds(groupId);
 }
 
-df::MarkIDSet const & BookmarkManager::GetGroupLineIds(df::MarkGroupID groupId) const
+df::LineIDSet const & BookmarkManager::GetGroupLineIds(df::MarkGroupID groupId) const
 {
   return GetTrackIds(groupId);
 }
@@ -899,15 +900,12 @@ df::MarkIDSet const & BookmarkManager::GetUpdatedMarkIds() const
 
 df::UserPointMark const * BookmarkManager::GetUserPointMark(df::MarkID markID) const
 {
-  df::UserPointMark const * mark = GetUserMark(markID);
-  if (!mark)
-    mark = GetBookmark(markID);
-  return mark;
+  return GetMark(markID);
 }
 
-df::UserLineMark const * BookmarkManager::GetUserLineMark(df::MarkID markID) const
+df::UserLineMark const * BookmarkManager::GetUserLineMark(df::LineID lineID) const
 {
-  return GetTrack(markID);
+  return GetTrack(lineID);
 }
 
 void BookmarkManager::CreateCategories(KMLDataCollection && dataCollection)
diff --git a/map/bookmark_manager.hpp b/map/bookmark_manager.hpp
index 879ebde719..cecf1df56c 100644
--- a/map/bookmark_manager.hpp
+++ b/map/bookmark_manager.hpp
@@ -25,7 +25,7 @@ class BookmarkManager final : public df::UserMarksProvider
   using CategoriesCollection = std::map<df::MarkGroupID, std::unique_ptr<BookmarkCategory>>;
   using MarksCollection = std::map<df::MarkID, std::unique_ptr<UserMark>>;
   using BookmarksCollection = std::map<df::MarkID, std::unique_ptr<Bookmark>>;
-  using TracksCollection = std::map<df::MarkID, std::unique_ptr<Track>>;
+  using TracksCollection = std::map<df::LineID, std::unique_ptr<Track>>;
 
   using CategoryIter = CategoriesCollection::iterator;
   using GroupIdList = std::vector<df::MarkGroupID>;
@@ -128,10 +128,10 @@ public:
   void DeleteBookmark(df::MarkID bmId);
 
   Track * CreateTrack(m2::PolylineD const & polyline, Track::Params const & p);
-  Track const * GetTrack(df::MarkID trackID) const;
-  void AttachTrack(df::MarkID trackID, df::MarkGroupID groupID);
-  void DetachTrack(df::MarkID trackID, df::MarkGroupID groupID);
-  void DeleteTrack(df::MarkID trackID);
+  Track const * GetTrack(df::LineID trackID) const;
+  void AttachTrack(df::LineID trackID, df::MarkGroupID groupID);
+  void DetachTrack(df::LineID trackID, df::MarkGroupID groupID);
+  void DeleteTrack(df::LineID trackID);
 
   //////////////////
   void ClearGroup(df::MarkGroupID groupID);
@@ -139,7 +139,7 @@ public:
   void NotifyChanges(df::MarkGroupID groupID);
 
   df::MarkIDSet const & GetUserMarkIds(df::MarkGroupID groupID) const;
-  df::MarkIDSet const & GetTrackIds(df::MarkGroupID groupID) const;
+  df::LineIDSet const & GetTrackIds(df::MarkGroupID groupID) const;
 
   std::string const & GetCategoryName(df::MarkGroupID categoryId) const;
   void SetCategoryName(df::MarkGroupID categoryId, std::string const & name);
@@ -205,17 +205,18 @@ public:
   bool IsGroupVisible(df::MarkGroupID groupID) const override;
   bool IsGroupVisiblityChanged(df::MarkGroupID groupID) const override;
   df::MarkIDSet const & GetGroupPointIds(df::MarkGroupID groupId) const override;
-  df::MarkIDSet const & GetGroupLineIds(df::MarkGroupID groupId) const override;
+  df::LineIDSet const & GetGroupLineIds(df::MarkGroupID groupId) const override;
   df::MarkIDSet const & GetCreatedMarkIds() const override;
   df::MarkIDSet const & GetRemovedMarkIds() const override;
   df::MarkIDSet const & GetUpdatedMarkIds() const override;
   df::UserPointMark const * GetUserPointMark(df::MarkID markID) const override;
-  df::UserLineMark const * GetUserLineMark(df::MarkID markID) const override;
+  df::UserLineMark const * GetUserLineMark(df::LineID lineID) const override;
 
 private:
   using KMLDataCollection = std::vector<std::unique_ptr<KMLData>>;
 
-  bool IsBookmark(df::MarkGroupID groupId) const { return groupId >= UserMark::BOOKMARK; }
+  static bool IsBookmark(df::MarkGroupID groupId) { return groupId >= UserMark::BOOKMARK; }
+  static bool IsBookmark(df::MarkID markID) { return UserMark::GetMarkType(markID) == UserMark::BOOKMARK; }
   UserMark const * GetMark(df::MarkID markID) const;
   void FindDirtyGroups();
 
diff --git a/map/track.cpp b/map/track.cpp
index 90ea17e342..45a1fe8f9e 100644
--- a/map/track.cpp
+++ b/map/track.cpp
@@ -6,8 +6,18 @@
 
 #include "geometry/distance_on_sphere.hpp"
 
+namespace
+{
+df::LineID GetNextUserLineId()
+{
+  static std::atomic<uint32_t> nextLineId(0);
+  return static_cast<df::LineID>(++nextLineId);
+}
+}  // namespace
+
 Track::Track(Track::PolylineD const & polyline, Track::Params const & p)
-  : m_polyline(polyline)
+  : df::UserLineMark(GetNextUserLineId())
+  , m_polyline(polyline)
   , m_params(p)
   , m_groupID(0)
 {
diff --git a/map/user_mark.cpp b/map/user_mark.cpp
index a32603fee2..466b64bb69 100644
--- a/map/user_mark.cpp
+++ b/map/user_mark.cpp
@@ -7,10 +7,33 @@
 
 #include "base/string_utils.hpp"
 
+#include <atomic>
+
+namespace
+{
+static const uint32_t kMarkIdTypeBitsCount = 4;
+
+df::MarkID GetNextUserMarkId(UserMark::Type type)
+{
+  static std::atomic<uint32_t> nextMarkId(0);
+
+  ASSERT_LESS(type, 1 << kMarkIdTypeBitsCount, ());
+  return static_cast<df::MarkID>(
+    (++nextMarkId) | (type << static_cast<uint32_t>(sizeof(df::MarkID) * 8 - kMarkIdTypeBitsCount)));
+}
+}  // namespace
+
 UserMark::UserMark(m2::PointD const & ptOrg, UserMark::Type type)
-: m_ptOrg(ptOrg), m_type(type)
+  : df::UserPointMark(GetNextUserMarkId(type))
+  , m_ptOrg(ptOrg)
 {}
 
+// static
+UserMark::Type UserMark::GetMarkType(df::MarkID id)
+{
+  return static_cast<Type>(id >> (sizeof(id) * 8 - kMarkIdTypeBitsCount));
+}
+
 m2::PointD const & UserMark::GetPivot() const
 {
   return m_ptOrg;
diff --git a/map/user_mark.hpp b/map/user_mark.hpp
index e49a1e5921..bc9c9c0326 100644
--- a/map/user_mark.hpp
+++ b/map/user_mark.hpp
@@ -30,7 +30,7 @@ public:
     TransitKeyStop
   };
 
-  enum Type: size_t
+  enum Type: uint32_t
   {
     API,
     SEARCH,
@@ -44,8 +44,11 @@ public:
 
   UserMark(m2::PointD const & ptOrg, UserMark::Type type);
 
-  Type GetMarkType() const { return m_type; }
-  df::MarkGroupID GetGroupId() const override { return m_type; }
+  static Type GetMarkType(df::MarkID);
+//  static df::MarkGroupID GetGroupId(UserMark::Type type);
+
+  Type GetMarkType() const { return GetMarkType(GetId()); }
+  df::MarkGroupID GetGroupId() const override { return GetMarkType(); }
 
   // df::UserPointMark overrides.
   bool IsDirty() const override { return m_isDirty; }
@@ -77,7 +80,6 @@ protected:
   void SetDirty() { m_isDirty = true; }
 
   m2::PointD m_ptOrg;
-  Type m_type;
 
 private:
   mutable bool m_isDirty = true;
diff --git a/map/user_mark_container.hpp b/map/user_mark_container.hpp
index cc1f7af2da..acc786fb7b 100644
--- a/map/user_mark_container.hpp
+++ b/map/user_mark_container.hpp
@@ -28,7 +28,7 @@ public:
   UserMark::Type GetType() const;
 
   df::MarkIDSet const & GetUserMarks() const { return m_userMarks; }
-  virtual df::MarkIDSet const & GetUserLines() const { return m_userLines; }
+  virtual df::LineIDSet const & GetUserLines() const { return m_userLines; }
 
   void AttachUserMark(df::MarkID markId);
   void DetachUserMark(df::MarkID markId);
@@ -42,9 +42,9 @@ protected:
   UserMark::Type m_type;
 
   df::MarkIDSet m_userMarks;
-  df::MarkIDSet m_userLines;
+  df::LineIDSet m_userLines;
 
-  bool m_isDirty = false;
+  bool m_isDirty = true;
   bool m_isVisible = true;
   bool m_wasVisible = false;