diff --git a/map/gps_track_container.cpp b/map/gps_track_container.cpp
new file mode 100644
index 0000000000..be2f26ef71
--- /dev/null
+++ b/map/gps_track_container.cpp
@@ -0,0 +1,149 @@
+#include "map/gps_track_container.hpp"
+
+#include "base/logging.hpp"
+
+namespace
+{
+
+uint32_t constexpr kDefaultMaxSize = 100000;
+hours constexpr kDefaultDuration = hours(24);
+
+uint32_t constexpr kSecondsPerHour = 60 * 60;
+
+} // namespace
+
+GpsTrackContainer::GpsTrackContainer()
+    : m_trackDuration(kDefaultDuration)
+    , m_maxSize(kDefaultMaxSize)
+    , m_counter(0)
+{
+}
+
+void GpsTrackContainer::SetDuration(hours duration)
+{
+  lock_guard<mutex> lg(m_guard);
+
+  m_trackDuration = duration;
+
+  vector<uint32_t> removed;
+  RemoveOldPoints(removed);
+
+  if (m_callback && !removed.empty())
+    m_callback(vector<GpsTrackPoint>(), move(removed));
+}
+
+void GpsTrackContainer::SetMaxSize(size_t maxSize)
+{
+  lock_guard<mutex> lg(m_guard);
+
+  m_maxSize = maxSize;
+
+  vector<uint32_t> removed;
+  RemoveOldPoints(removed);
+
+  if (m_callback && !removed.empty())
+    m_callback(vector<GpsTrackPoint>(), move(removed));
+}
+
+void GpsTrackContainer::SetCallback(TGpsTrackDiffCallback callback, bool sendAll)
+{
+  lock_guard<mutex> lg(m_guard);
+
+  m_callback = callback;
+
+  if (!m_callback || !sendAll || m_points.empty())
+    return;
+
+  vector<GpsTrackPoint> added;
+  CopyPoints(added);
+
+  m_callback(move(added), vector<uint32_t>());
+}
+
+uint32_t GpsTrackContainer::AddPoint(m2::PointD const & point, double speedMPS, double timestamp)
+{
+  lock_guard<mutex> lg(m_guard);
+
+  GpsTrackPoint gtp;
+  gtp.m_timestamp = timestamp;
+  gtp.m_point = point;
+  gtp.m_speedMPS = speedMPS;
+  gtp.m_id = ++m_counter;
+
+  // Do not process points which are come with timestamp earlier than timestamp of the last point
+  // because it is probably some error in logic or gps error, because valid gps must provide UTC time which is growing.
+  if (!m_points.empty() && timestamp < m_points.back().m_timestamp)
+  {
+    LOG(LINFO, ("Incorrect GPS timestamp sequence"));
+    return kInvalidId;
+  }
+
+  m_points.push_back(gtp);
+
+  vector<GpsTrackPoint> added;
+  added.emplace_back(gtp);
+
+  vector<uint32_t> removed;
+  RemoveOldPoints(removed);
+
+  if (m_callback)
+    m_callback(move(added), move(removed));
+
+  return gtp.m_id;
+}
+
+void GpsTrackContainer::GetPoints(vector<GpsTrackPoint> & points) const
+{
+  lock_guard<mutex> lg(m_guard);
+
+  CopyPoints(points);
+}
+
+void GpsTrackContainer::RemoveOldPoints(vector<uint32_t> & removedIds)
+{
+  // Must be called under m_guard lock
+
+  if (m_points.empty())
+    return;
+
+  time_t const lowerBorder = m_points.back().m_timestamp - kSecondsPerHour * m_trackDuration.count();
+
+  if (m_points.front().m_timestamp < lowerBorder)
+  {
+    GpsTrackPoint pt;
+    pt.m_timestamp = lowerBorder;
+
+    auto const itr = lower_bound(m_points.begin(), m_points.end(), pt,
+                                 [](GpsTrackPoint const & a, GpsTrackPoint const & b)->bool{ return a.m_timestamp < b.m_timestamp; });
+
+    if (itr != m_points.begin())
+    {
+      removedIds.reserve(removedIds.size() + distance(m_points.begin(), itr));
+      for (auto i = m_points.begin(); i != itr; ++i)
+        removedIds.emplace_back(i->m_id);
+
+      m_points.erase(m_points.begin(), itr);
+    }
+  }
+
+  if (m_points.size() > m_maxSize)
+  {
+    auto const itr = m_points.begin() + m_points.size() - m_maxSize;
+
+    removedIds.reserve(removedIds.size() + distance(m_points.begin(), itr));
+    for (auto i = m_points.begin(); i != itr; ++i)
+      removedIds.emplace_back(i->m_id);
+
+    m_points.erase(m_points.begin(), itr);
+  }
+}
+
+void GpsTrackContainer::CopyPoints(vector<GpsTrackPoint> & points) const
+{
+  // Must be called under m_guard lock
+
+  vector<GpsTrackPoint> tmp;
+  tmp.reserve(m_points.size());
+  copy(m_points.begin(), m_points.end(), back_inserter(tmp));
+  points.swap(tmp);
+}
diff --git a/map/gps_track_container.hpp b/map/gps_track_container.hpp
new file mode 100644
index 0000000000..ec3027e423
--- /dev/null
+++ b/map/gps_track_container.hpp
@@ -0,0 +1,89 @@
+#pragma once
+
+#include "std/chrono.hpp"
+#include "std/deque.hpp"
+#include "std/function.hpp"
+#include "std/mutex.hpp"
+
+#include "geometry/point2d.hpp"
+
+class GpsTrackContainer
+{
+public:
+  struct GpsTrackPoint
+  {
+    // Timestamp of the point, seconds from 1st Jan 1970
+    double m_timestamp;
+
+    // Point in the Mercator projection
+    m2::PointD m_point;
+
+    // Speed in the point, M/S
+    double m_speedMPS;
+
+    // Unique identifier of the point
+    uint32_t m_id;
+  };
+
+  static uint32_t constexpr kInvalidId = numeric_limits<uint32_t>::max();
+
+  /// Notification callback about a change of the gps track.
+  /// @param toAdd - collection of points to add.
+  /// @param toRemove - collection of point indices to remove.
+  /// @note Calling of a GpsTrackContainer's function from the callback causes deadlock.
+  using TGpsTrackDiffCallback = std::function<void(vector<GpsTrackPoint> && toAdd, vector<uint32_t> && toRemove)>;
+
+  GpsTrackContainer();
+
+  /// Sets track duration in hours.
+  /// @note Callback is called with 'toRemove' points, if some points were removed.
+  /// By default, duration is 24h.
+  void SetDuration(hours duration);
+
+  /// Sets max number of points in the track.
+  /// @note Callback is called with 'toRemove' points, if some points were removed.
+  /// By default, max size is 100k.
+  void SetMaxSize(size_t maxSize);
+
+  /// Sets callback on change of gps track.
+  /// @param callback - callback callable object
+  /// @param sendAll - If it is true then callback is called with all points as 'toAdd' points, if there are points.
+  /// If helps to avoid race condition and complex synchronizations if we called getter GetGpsTrackPoints
+  /// and waited for notification OnGpsTrackChanged. If it is false, then there is no ant callback and client is responsible
+  /// for getting of initial state and syncing it with callbacks.
+  /// @note Only one callback is supported at time.
+  void SetCallback(TGpsTrackDiffCallback callback, bool sendAll);
+
+  /// Adds new point in the track.
+  /// @param point - new point in the Mercator projection.
+  /// @param speedMPS - current speed in the new point in M/S.
+  /// @param timestamp - timestamp of the point.
+  /// @note Callback is called with 'toAdd' and 'toRemove' points.
+  /// @returns the point unique identifier or kInvalidId if point has incorrect time.
+  uint32_t AddPoint(m2::PointD const & point, double speedMPS, double timestamp);
+
+  /// Returns points snapshot from the container.
+  /// @param points - output for collection of points.
+  void GetPoints(vector<GpsTrackPoint> & points) const;
+
+private:
+  void RemoveOldPoints(vector<uint32_t> & removedIds);
+  void CopyPoints(vector<GpsTrackPoint> & points) const;
+
+  mutable mutex m_guard;
+
+  TGpsTrackDiffCallback m_callback;
+
+  // Max duration of track, by default is 24h.
+  hours m_trackDuration;
+
+  // Max number of points in track, by default is 100k.
+  size_t m_maxSize;
+
+  // Collection of points, by nature is asc. sorted by m_timestamp.
+  // Max size of m_points is adjusted by m_trackDuration and m_maxSize.
+  deque<GpsTrackPoint> m_points;
+
+  // Simple counter which is used to generate point unique ids.
+  uint32_t m_counter;
+};
diff --git a/map/map.pro b/map/map.pro
index c96935f8f7..40c73f83bc 100644
--- a/map/map.pro
+++ b/map/map.pro
@@ -21,6 +21,7 @@ HEADERS += \
     framework.hpp \
     ge0_parser.hpp \
     geourl_process.hpp \
+    gps_track_container.hpp \
     mwm_url.hpp \
     storage_bridge.hpp \
     styled_point.hpp \
@@ -40,6 +41,7 @@ SOURCES += \
     framework.cpp \
     ge0_parser.cpp \
     geourl_process.cpp \
+    gps_track_container.cpp \
     mwm_url.cpp \
     storage_bridge.cpp \
     styled_point.cpp \
diff --git a/map/map_tests/gps_track_container_test.cpp b/map/map_tests/gps_track_container_test.cpp
new file mode 100644
index 0000000000..4d3baa219d
--- /dev/null
+++ b/map/map_tests/gps_track_container_test.cpp
@@ -0,0 +1,84 @@
+#include "testing/testing.hpp"
+
+#include "map/gps_track_container.hpp"
+
+#include "std/bind.hpp"
+
+namespace
+{
+
+uint32_t constexpr kSecondsPerHour = 60 * 60;
+
+struct GpsTrackContainerCallback
+{
+public:
+  void OnChange(vector<GpsTrackContainer::GpsTrackPoint> && toAdd, vector<uint32_t> && toRemove)
+  {
+    m_toAdd.insert(m_toAdd.end(), toAdd.begin(), toAdd.end());
+    m_toRemove.insert(m_toRemove.end(), toRemove.begin(), toRemove.end());
+  }
+  vector<GpsTrackContainer::GpsTrackPoint> m_toAdd;
+  vector<uint32_t> m_toRemove;
+};
+
+} // namespace
+
+UNIT_TEST(GpsTrackContainer_Test)
+{
+  GpsTrackContainer gpstrack;
+
+  time_t timestamp = system_clock::to_time_t(system_clock::now());
+
+  uint32_t id0 = gpstrack.AddPoint(m2::PointD(0,0), 0.0, timestamp);
+  uint32_t id1 = gpstrack.AddPoint(m2::PointD(1,1), 1.0, timestamp + kSecondsPerHour);
+  uint32_t id2 = gpstrack.AddPoint(m2::PointD(2,2), 2.0, timestamp + 2 * kSecondsPerHour);
+
+  // Set callback and expect toAdd callback with all points
+
+  GpsTrackContainerCallback callback;
+  gpstrack.SetCallback(bind(&GpsTrackContainerCallback::OnChange, ref(callback), _1, _2), true /* sendAll */);
+
+  TEST(callback.m_toRemove.empty(), ());
+
+  TEST_EQUAL(3, callback.m_toAdd.size(), ());
+  TEST_EQUAL(id0, callback.m_toAdd[0].m_id, ());
+  TEST_EQUAL(id1, callback.m_toAdd[1].m_id, ());
+  TEST_EQUAL(id2, callback.m_toAdd[2].m_id, ());
+
+  callback.m_toAdd.clear();
+  callback.m_toRemove.clear();
+
+  // Add point in 25h (duration is 24h) and expect point id0 is popped and point id25 is added
+
+  uint32_t id25 = gpstrack.AddPoint(m2::PointD(25,25), 25.0, timestamp + 25 * kSecondsPerHour);
+
+  TEST_EQUAL(1, callback.m_toAdd.size(), ());
+  TEST_EQUAL(id25, callback.m_toAdd[0].m_id, ());
+
+  TEST_EQUAL(1, callback.m_toRemove.size(), ());
+  TEST_EQUAL(id0, callback.m_toRemove[0], ());
+
+  callback.m_toAdd.clear();
+  callback.m_toRemove.clear();
+
+  // Set duration in 2h and expect points id1 and id2 are popped
+
+  gpstrack.SetDuration(hours(2));
+
+  TEST(callback.m_toAdd.empty(), ());
+
+  TEST_EQUAL(2, callback.m_toRemove.size(), ());
+  TEST_EQUAL(id1, callback.m_toRemove[0], ());
+  TEST_EQUAL(id2, callback.m_toRemove[1], ());
+
+  callback.m_toAdd.clear();
+  callback.m_toRemove.clear();
+
+  // and test there is only id25 point in the track
+
+  vector<GpsTrackContainer::GpsTrackPoint> points;
+  gpstrack.GetPoints(points);
+
+  TEST_EQUAL(1, points.size(), ());
+  TEST_EQUAL(id25, points[0].m_id, ());
+}
diff --git a/map/map_tests/map_tests.pro b/map/map_tests/map_tests.pro
index 68f7ac6658..be6b5a263c 100644
--- a/map/map_tests/map_tests.pro
+++ b/map/map_tests/map_tests.pro
@@ -31,6 +31,7 @@ SOURCES += \
   bookmarks_test.cpp \
   ge0_parser_tests.cpp  \
   geourl_test.cpp \
+  gps_track_container_test.cpp \
   kmz_unarchive_test.cpp \
   mwm_url_tests.cpp \
 
diff --git a/std/chrono.hpp b/std/chrono.hpp
index 598ffbee7a..1ac4f3f731 100644
--- a/std/chrono.hpp
+++ b/std/chrono.hpp
@@ -9,6 +9,7 @@
 using std::chrono::duration;
 using std::chrono::duration_cast;
 using std::chrono::high_resolution_clock;
+using std::chrono::hours;
 using std::chrono::milliseconds;
 using std::chrono::minutes;
 using std::chrono::nanoseconds;