diff --git a/routing/base/followed_polyline.cpp b/routing/base/followed_polyline.cpp
index 313ac3b14a..4aa2b9aba9 100644
--- a/routing/base/followed_polyline.cpp
+++ b/routing/base/followed_polyline.cpp
@@ -136,9 +136,13 @@ Iter FollowedPolyline::GetClosestProjectionInInterval(m2::RectD const & posRect,
   return res;
 }
 
+/// \returns iterator to the best projection of center of |posRect| to the |m_poly|.
+/// If there's a good projection of center of |posRect| to two closest segments of |m_poly|
+/// after |m_current| the iterator corresponding of the projection returns.
+/// Otherwise returned a projection to closest point of route.
 template <class DistanceFn>
-Iter FollowedPolyline::GetClosestProjection(m2::RectD const & posRect,
-                                            DistanceFn const & distFn) const
+Iter FollowedPolyline::GetBestProjection(m2::RectD const & posRect,
+                                         DistanceFn const & distFn) const
 {
   CHECK_EQUAL(m_segProj.size() + 1, m_poly.GetSize(), ());
   // At first trying to find a projection to two closest route segments of route which is near
@@ -163,7 +167,7 @@ Iter FollowedPolyline::UpdateProjectionByPrediction(m2::RectD const & posRect,
     return UpdateProjection(posRect);
 
   Iter res;
-  res = GetClosestProjection(posRect, [&](Iter const & it)
+  res = GetBestProjection(posRect, [&](Iter const & it)
   {
     return fabs(GetDistanceM(m_current, it) - predictDistance);
   });
@@ -180,7 +184,7 @@ Iter FollowedPolyline::UpdateProjection(m2::RectD const & posRect) const
 
   Iter res;
   m2::PointD const currPos = posRect.Center();
-  res = GetClosestProjection(posRect, [&](Iter const & it)
+  res = GetBestProjection(posRect, [&](Iter const & it)
   {
     return MercatorBounds::DistanceOnEarth(it.m_pt, currPos);
   });
diff --git a/routing/base/followed_polyline.hpp b/routing/base/followed_polyline.hpp
index 0d67605501..35245409e9 100644
--- a/routing/base/followed_polyline.hpp
+++ b/routing/base/followed_polyline.hpp
@@ -79,7 +79,7 @@ private:
   Iter GetClosestProjectionInInterval(m2::RectD const & posRect, DistanceFn const & distFn,
                                       size_t startIdx, size_t endIdx) const;
   template <class DistanceFn>
-  Iter GetClosestProjection(m2::RectD const & posRect, DistanceFn const & distFn) const;
+  Iter GetBestProjection(m2::RectD const & posRect, DistanceFn const & distFn) const;
 
   void Update();
 
diff --git a/routing/route.cpp b/routing/route.cpp
index 0bd567ed39..9f05c43262 100644
--- a/routing/route.cpp
+++ b/routing/route.cpp
@@ -28,7 +28,6 @@ namespace routing
 {
 namespace
 {
-double constexpr kLocationTimeThreshold = 60.0 * 1.0;
 double constexpr kOnEndToleranceM = 10.0;
 double constexpr kSteetNameLinkMeters = 400.;
 
diff --git a/routing/routing_tests/followed_polyline_test.cpp b/routing/routing_tests/followed_polyline_test.cpp
index 50a996d3d9..41737ee3ea 100644
--- a/routing/routing_tests/followed_polyline_test.cpp
+++ b/routing/routing_tests/followed_polyline_test.cpp
@@ -10,29 +10,29 @@ using namespace routing;
 
 namespace
 {
-  static const m2::PolylineD kTestDirectedPolyline({{0.0, 0.0}, {3.0, 0.0}, {5.0, 0.0}});
+  static const m2::PolylineD kTestDirectedPolyline1({{0.0, 0.0}, {3.0, 0.0}, {5.0, 0.0}});
   static const m2::PolylineD kTestDirectedPolyline2({{6.0, 0.0}, {7.0, 0.0}});
 }  // namespace
 
 UNIT_TEST(FollowedPolylineAppend)
 {
-  FollowedPolyline followedPolyline1(kTestDirectedPolyline.Begin(), kTestDirectedPolyline.End());
+  FollowedPolyline followedPolyline1(kTestDirectedPolyline1.Begin(), kTestDirectedPolyline1.End());
   FollowedPolyline const followedPolyline2(kTestDirectedPolyline2.Begin(), kTestDirectedPolyline2.End());
 
-  TEST_EQUAL(followedPolyline1.GetPolyline(), kTestDirectedPolyline, ());
+  TEST_EQUAL(followedPolyline1.GetPolyline(), kTestDirectedPolyline1, ());
   followedPolyline1.Append(followedPolyline2);
   TEST_EQUAL(followedPolyline1.GetPolyline().GetSize(), 5, ());
 
-  m2::PolylineD polyline1 = kTestDirectedPolyline;
+  m2::PolylineD polyline1 = kTestDirectedPolyline1;
   polyline1.Append(kTestDirectedPolyline2);
   TEST_EQUAL(followedPolyline1.GetPolyline(), polyline1, ());
 }
 
 UNIT_TEST(FollowedPolylinePop)
 {
-  FollowedPolyline followedPolyline(kTestDirectedPolyline.Begin(), kTestDirectedPolyline.End());
+  FollowedPolyline followedPolyline(kTestDirectedPolyline1.Begin(), kTestDirectedPolyline1.End());
 
-  TEST_EQUAL(followedPolyline.GetPolyline(), kTestDirectedPolyline, ());
+  TEST_EQUAL(followedPolyline.GetPolyline(), kTestDirectedPolyline1, ());
   TEST_EQUAL(followedPolyline.GetPolyline().GetSize(), 3, ());
   followedPolyline.PopBack();
   TEST_EQUAL(followedPolyline.GetPolyline().GetSize(), 2, ());
@@ -40,7 +40,7 @@ UNIT_TEST(FollowedPolylinePop)
 
 UNIT_TEST(FollowedPolylineInitializationFogTest)
 {
-  FollowedPolyline polyline(kTestDirectedPolyline.Begin(), kTestDirectedPolyline.End());
+  FollowedPolyline polyline(kTestDirectedPolyline1.Begin(), kTestDirectedPolyline1.End());
   TEST(polyline.IsValid(), ());
   TEST_EQUAL(polyline.GetCurrentIter().m_ind, 0, ());
   TEST_EQUAL(polyline.GetPolyline().GetSize(), 3, ());
@@ -48,7 +48,7 @@ UNIT_TEST(FollowedPolylineInitializationFogTest)
 
 UNIT_TEST(FollowedPolylineFollowingTestByProjection)
 {
-  FollowedPolyline polyline(kTestDirectedPolyline.Begin(), kTestDirectedPolyline.End());
+  FollowedPolyline polyline(kTestDirectedPolyline1.Begin(), kTestDirectedPolyline1.End());
   TEST_EQUAL(polyline.GetCurrentIter().m_ind, 0, ());
   polyline.UpdateProjection(MercatorBounds::RectByCenterXYAndSizeInMeters({0, 0}, 2));
   TEST_EQUAL(polyline.GetCurrentIter().m_ind, 0, ());
@@ -88,10 +88,10 @@ UNIT_TEST(FollowedPolylineFollowingTestByPrediction)
 UNIT_TEST(FollowedPolylineDistanceCalculationTest)
 {
   // Test full length case.
-  FollowedPolyline polyline(kTestDirectedPolyline.Begin(), kTestDirectedPolyline.End());
+  FollowedPolyline polyline(kTestDirectedPolyline1.Begin(), kTestDirectedPolyline1.End());
   double distance = polyline.GetDistanceM(polyline.Begin(), polyline.End());
-  double masterDistance = MercatorBounds::DistanceOnEarth(kTestDirectedPolyline.Front(),
-                                                          kTestDirectedPolyline.Back());
+  double masterDistance = MercatorBounds::DistanceOnEarth(kTestDirectedPolyline1.Front(),
+                                                          kTestDirectedPolyline1.Back());
   TEST_ALMOST_EQUAL_ULPS(distance, masterDistance, ());
   distance = polyline.GetTotalDistanceMeters();
   TEST_ALMOST_EQUAL_ULPS(distance, masterDistance, ());
@@ -99,8 +99,8 @@ UNIT_TEST(FollowedPolylineDistanceCalculationTest)
   // Test partial length case.
   polyline.UpdateProjection(MercatorBounds::RectByCenterXYAndSizeInMeters({3, 0}, 2));
   distance = polyline.GetDistanceM(polyline.GetCurrentIter(), polyline.End());
-  masterDistance = MercatorBounds::DistanceOnEarth(kTestDirectedPolyline.GetPoint(1),
-                                                   kTestDirectedPolyline.Back());
+  masterDistance = MercatorBounds::DistanceOnEarth(kTestDirectedPolyline1.GetPoint(1),
+                                                   kTestDirectedPolyline1.Back());
   TEST_ALMOST_EQUAL_ULPS(distance, masterDistance, ());
   distance = polyline.GetDistanceToEndMeters();
   TEST_ALMOST_EQUAL_ULPS(distance, masterDistance, ());
@@ -109,7 +109,7 @@ UNIT_TEST(FollowedPolylineDistanceCalculationTest)
   polyline.UpdateProjection(MercatorBounds::RectByCenterXYAndSizeInMeters({4, 0}, 2));
   distance = polyline.GetDistanceM(polyline.GetCurrentIter(), polyline.End());
   masterDistance = MercatorBounds::DistanceOnEarth(m2::PointD(4, 0),
-                                                   kTestDirectedPolyline.Back());
+                                                   kTestDirectedPolyline1.Back());
   TEST_ALMOST_EQUAL_ULPS(distance, masterDistance, ());
   distance = polyline.GetDistanceToEndMeters();
   TEST_ALMOST_EQUAL_ULPS(distance, masterDistance, ());
@@ -136,9 +136,10 @@ UNIT_TEST(FollowedPolylineGetDistanceFromBeginM)
   FollowedPolyline polyline(testPolyline.Begin(), testPolyline.End());
   m2::PointD point(4, 0);
   polyline.UpdateProjection(MercatorBounds::RectByCenterXYAndSizeInMeters(point, 2));
+
   double const distance = polyline.GetDistanceFromStartMeters();
-  double const masterDistance = MercatorBounds::DistanceOnEarth(kTestDirectedPolyline.Front(),
-                                                          point);
+  double const masterDistance =
+      MercatorBounds::DistanceOnEarth(kTestDirectedPolyline1.Front(), point);
   TEST_ALMOST_EQUAL_ULPS(distance, masterDistance, ());
 }
 }  // namespace routing_test