diff --git a/geometry/polyline2d.hpp b/geometry/polyline2d.hpp
index 0a3495504c..a8f2368efc 100644
--- a/geometry/polyline2d.hpp
+++ b/geometry/polyline2d.hpp
@@ -19,7 +19,7 @@ class PolylineT
 
 public:
   PolylineT() {}
-  explicit PolylineT(initializer_list<Point<T> > points) : m_points(points)
+  PolylineT(initializer_list<Point<T> > points) : m_points(points)
   {
     ASSERT_GREATER(m_points.size(), 1, ());
   }
diff --git a/routing/features_road_graph.cpp b/routing/features_road_graph.cpp
index 3ff5f993a1..031e8755ea 100644
--- a/routing/features_road_graph.cpp
+++ b/routing/features_road_graph.cpp
@@ -66,19 +66,19 @@ public:
       return;
 
     // load feature from cache
-    FeaturesRoadGraph::CachedFeature const & fc = m_graph.GetCachedFeature(fID.m_offset, ft, false);
-    ASSERT_EQUAL(speed, fc.m_speed, ());
+    IRoadGraph::RoadInfo const & ri = m_graph.GetCachedRoadInfo(fID.m_offset, ft, false);
+    ASSERT_EQUAL(speed, ri.m_speedKMPH, ());
 
-    size_t const count = fc.m_points.size();
+    size_t const count = ri.m_points.size();
 
     PossibleTurn t;
-    t.m_speed = fc.m_speed;
-    t.m_startPoint = fc.m_points[0];
-    t.m_endPoint = fc.m_points[count - 1];
+    t.m_speedKMPH = ri.m_speedKMPH;
+    t.m_startPoint = ri.m_points[0];
+    t.m_endPoint = ri.m_points[count - 1];
 
     for (size_t i = 0; i < count; ++i)
     {
-      m2::PointD const & p = fc.m_points[i];
+      m2::PointD const & p = ri.m_points[i];
 
       /// @todo Is this a correct way to compare?
       if (!m2::AlmostEqual(m_point, p))
@@ -115,15 +115,15 @@ void FeaturesRoadGraph::GetNearestTurns(RoadPos const & pos, vector<PossibleTurn
 {
   uint32_t const featureId = pos.GetFeatureId();
   FeatureType ft;
-  CachedFeature const fc = GetCachedFeature(featureId, ft, true);
+  RoadInfo const ri = GetCachedRoadInfo(featureId, ft, true);
 
-  if (fc.m_speed <= 0.0)
+  if (ri.m_speedKMPH <= 0.0)
     return;
 
-  ASSERT_GREATER_OR_EQUAL(fc.m_points.size(), 2,
-                          ("Incorrect road - only", fc.m_points.size(), "point(s)."));
+  ASSERT_GREATER_OR_EQUAL(ri.m_points.size(), 2,
+                          ("Incorrect road - only", ri.m_points.size(), "point(s)."));
 
-  m2::PointD const point = fc.m_points[pos.GetSegStartPointId()];
+  m2::PointD const point = ri.m_points[pos.GetSegStartPointId()];
 
   // Find possible turns to startPoint from other features.
   CrossFeaturesLoader crossLoader(*this, point, turns);
@@ -150,12 +150,11 @@ double FeaturesRoadGraph::GetSpeedKMPH(uint32_t featureId)
   return GetSpeedKMPHFromFt(ft);
 }
 
-FeaturesRoadGraph::CachedFeature const & FeaturesRoadGraph::GetCachedFeature(uint32_t const ftId,
-                                                                             FeatureType & ft,
-                                                                             bool fullLoad)
+IRoadGraph::RoadInfo const & FeaturesRoadGraph::GetCachedRoadInfo(uint32_t const ftId,
+                                                                  FeatureType & ft, bool fullLoad)
 {
   bool found = false;
-  CachedFeature & f = m_cache.Find(ftId, found);
+  RoadInfo & ri = m_cache.Find(ftId, found);
 
   if (!found)
   {
@@ -164,13 +163,13 @@ FeaturesRoadGraph::CachedFeature const & FeaturesRoadGraph::GetCachedFeature(uin
     else
       ft.ParseGeometry(FeatureType::BEST_GEOMETRY);
 
-    f.m_isOneway = IsOneWay(ft);
-    f.m_speed = GetSpeedKMPHFromFt(ft);
-    ft.SwapPoints(f.m_points);
+    ri.m_bidirectional = !IsOneWay(ft);
+    ri.m_speedKMPH = GetSpeedKMPHFromFt(ft);
+    ft.SwapPoints(ri.m_points);
     m_cacheMiss++;
   }
   m_cacheAccess++;
 
-  return f;
+  return ri;
 }
 }  // namespace routing
diff --git a/routing/features_road_graph.hpp b/routing/features_road_graph.hpp
index 2f2f923a58..ae37d37914 100644
--- a/routing/features_road_graph.hpp
+++ b/routing/features_road_graph.hpp
@@ -19,18 +19,9 @@ namespace routing
 {
 class FeaturesRoadGraph : public IRoadGraph
 {
-  struct CachedFeature
-  {
-    CachedFeature() : m_speed(0), m_isOneway(false) {}
-
-    buffer_vector<m2::PointD, 32> m_points;
-    double m_speed;
-    bool m_isOneway;
-  };
-
   // TODO (@gorshenin): ft is not set when feature is not loaded from
   // cache, investigate how to fix this.
-  CachedFeature const & GetCachedFeature(uint32_t const ftId, FeatureType & ft, bool fullLoad);
+  RoadInfo const & GetCachedRoadInfo(uint32_t const ftId, FeatureType & ft, bool fullLoad);
 
 public:
   FeaturesRoadGraph(Index const * pIndex, size_t mwmID);
@@ -62,7 +53,7 @@ private:
   Index const * m_pIndex;
   size_t m_mwmID;
   unique_ptr<IVehicleModel> m_vehicleModel;
-  my::Cache<uint32_t, CachedFeature> m_cache;
+  my::Cache<uint32_t, RoadInfo> m_cache;
 
   uint32_t m_cacheMiss;
   uint32_t m_cacheAccess;
diff --git a/routing/road_graph.hpp b/routing/road_graph.hpp
index 973e5540b2..152443a270 100644
--- a/routing/road_graph.hpp
+++ b/routing/road_graph.hpp
@@ -72,7 +72,7 @@ struct PossibleTurn
   m2::PointD m_endPoint;
 
   /// Speed on the old road.
-  double m_speed;
+  double m_speedKMPH;
 
   /// Distance and time to get to this turn on old road.
   double m_metersCovered;
@@ -90,6 +90,29 @@ public:
   typedef vector<RoadPos> RoadPosVectorT;
   typedef vector<m2::PointD> PointsVectorT;
 
+  // This struct contains a part of a feature's metadata which is
+  // relevant for routing.
+  struct RoadInfo
+  {
+    RoadInfo() : m_speedKMPH(0.0), m_bidirectional(false) {}
+
+    RoadInfo(RoadInfo const & ri)
+        : m_points(ri.m_points), m_speedKMPH(ri.m_speedKMPH), m_bidirectional(ri.m_bidirectional)
+    {
+    }
+
+    RoadInfo(RoadInfo && ri)
+        : m_points(move(ri.m_points)),
+          m_speedKMPH(ri.m_speedKMPH),
+          m_bidirectional(ri.m_bidirectional)
+    {
+    }
+
+    buffer_vector<m2::PointD, 32> m_points;
+    double m_speedKMPH;
+    bool m_bidirectional;
+  };
+
   virtual ~IRoadGraph() = default;
 
   /// Construct route by road positions (doesn't include first and last section).
diff --git a/routing/routing_tests/road_graph_builder.cpp b/routing/routing_tests/road_graph_builder.cpp
index 82370974ee..a3978b7402 100644
--- a/routing/routing_tests/road_graph_builder.cpp
+++ b/routing/routing_tests/road_graph_builder.cpp
@@ -8,41 +8,31 @@ using namespace routing;
 
 namespace routing_test
 {
-double const MPS2KMPH = (60 * 60) / 1000.0;
-
-void RoadInfo::Swap(RoadInfo & r)
-{
-  m_points.swap(r.m_points);
-  std::swap(m_speedMS, r.m_speedMS);
-  std::swap(m_bidirectional, r.m_bidirectional);
-}
-
-void RoadGraphMockSource::AddRoad(RoadInfo & rd)
+void RoadGraphMockSource::AddRoad(RoadInfo && ri)
 {
   /// @todo Do CHECK for RoadInfo params.
   uint32_t const roadId = m_roads.size();
 
-  CHECK_GREATER_OR_EQUAL(rd.m_points.size(), 2, ("Empty road"));
-  size_t const numSegments = rd.m_points.size() - 1;
+  CHECK_GREATER_OR_EQUAL(ri.m_points.size(), 2, ("Empty road"));
+  size_t const numSegments = ri.m_points.size() - 1;
 
   for (size_t segId = 0; segId < numSegments; ++segId)
   {
     PossibleTurn t;
-    t.m_startPoint = rd.m_points.front();
-    t.m_endPoint = rd.m_points.back();
-    t.m_speed = rd.m_speedMS;
+    t.m_startPoint = ri.m_points.front();
+    t.m_endPoint = ri.m_points.back();
+    t.m_speedKMPH = ri.m_speedKMPH;
 
-    t.m_pos = RoadPos(roadId, true /* forward */, segId, rd.m_points[segId + 1] /* segEndPoint */);
+    t.m_pos = RoadPos(roadId, true /* forward */, segId, ri.m_points[segId + 1] /* segEndPoint */);
     m_turns[t.m_pos.GetSegEndpoint()].push_back(t);
-    if (rd.m_bidirectional)
+    if (ri.m_bidirectional)
     {
-      t.m_pos = RoadPos(roadId, false /* forward */, segId, rd.m_points[segId] /* segEndPoint */);
+      t.m_pos = RoadPos(roadId, false /* forward */, segId, ri.m_points[segId] /* segEndPoint */);
       m_turns[t.m_pos.GetSegEndpoint()].push_back(t);
     }
   }
 
-  m_roads.push_back(RoadInfo());
-  m_roads.back().Swap(rd);
+  m_roads.push_back(move(ri));
 }
 
 void RoadGraphMockSource::GetNearestTurns(RoadPos const & pos, TurnsVectorT & turns)
@@ -61,13 +51,13 @@ void RoadGraphMockSource::GetNearestTurns(RoadPos const & pos, TurnsVectorT & tu
   for (size_t featureId = 0; featureId < m_roads.size(); ++featureId)
   {
     RoadInfo const & road = m_roads[featureId];
-    vector<m2::PointD> const & points = road.m_points;
-    if (road.m_speedMS <= 0.0)
+    auto const & points = road.m_points;
+    if (road.m_speedKMPH <= 0.0)
       continue;
     PossibleTurn turn;
     turn.m_startPoint = points.front();
     turn.m_endPoint = points.back();
-    turn.m_speed = road.m_speedMS;
+    turn.m_speedKMPH = road.m_speedKMPH;
     for (size_t i = 0; i < points.size(); ++i)
     {
       m2::PointD point = points[i];
@@ -91,54 +81,54 @@ void RoadGraphMockSource::GetNearestTurns(RoadPos const & pos, TurnsVectorT & tu
 double RoadGraphMockSource::GetSpeedKMPH(uint32_t featureId)
 {
   CHECK_LESS(featureId, m_roads.size(), ("Invalid feature id."));
-  return m_roads[featureId].m_speedMS * MPS2KMPH;
+  return m_roads[featureId].m_speedKMPH;
 }
 
 void InitRoadGraphMockSourceWithTest1(RoadGraphMockSource & src)
 {
-  RoadInfo ri0;
+  IRoadGraph::RoadInfo ri0;
   ri0.m_bidirectional = true;
-  ri0.m_speedMS = 40;
+  ri0.m_speedKMPH = 40;
   ri0.m_points.push_back(m2::PointD(0, 0));
   ri0.m_points.push_back(m2::PointD(5, 0));
   ri0.m_points.push_back(m2::PointD(10, 0));
   ri0.m_points.push_back(m2::PointD(15, 0));
   ri0.m_points.push_back(m2::PointD(20, 0));
 
-  RoadInfo ri1;
+  IRoadGraph::RoadInfo ri1;
   ri1.m_bidirectional = true;
-  ri1.m_speedMS = 40;
+  ri1.m_speedKMPH = 40;
   ri1.m_points.push_back(m2::PointD(10, -10));
   ri1.m_points.push_back(m2::PointD(10, -5));
   ri1.m_points.push_back(m2::PointD(10, 0));
   ri1.m_points.push_back(m2::PointD(10, 5));
   ri1.m_points.push_back(m2::PointD(10, 10));
 
-  RoadInfo ri2;
+  IRoadGraph::RoadInfo ri2;
   ri2.m_bidirectional = true;
-  ri2.m_speedMS = 40;
+  ri2.m_speedKMPH = 40;
   ri2.m_points.push_back(m2::PointD(15, -5));
   ri2.m_points.push_back(m2::PointD(15, 0));
 
-  RoadInfo ri3;
+  IRoadGraph::RoadInfo ri3;
   ri3.m_bidirectional = true;
-  ri3.m_speedMS = 40;
+  ri3.m_speedKMPH = 40;
   ri3.m_points.push_back(m2::PointD(20, 0));
   ri3.m_points.push_back(m2::PointD(25, 5));
   ri3.m_points.push_back(m2::PointD(15, 5));
   ri3.m_points.push_back(m2::PointD(20, 0));
 
-  src.AddRoad(ri0);
-  src.AddRoad(ri1);
-  src.AddRoad(ri2);
-  src.AddRoad(ri3);
+  src.AddRoad(move(ri0));
+  src.AddRoad(move(ri1));
+  src.AddRoad(move(ri2));
+  src.AddRoad(move(ri3));
 }
 
 void InitRoadGraphMockSourceWithTest2(RoadGraphMockSource & graph)
 {
-  RoadInfo ri0;
+  IRoadGraph::RoadInfo ri0;
   ri0.m_bidirectional = true;
-  ri0.m_speedMS = 40;
+  ri0.m_speedKMPH = 40;
   ri0.m_points.push_back(m2::PointD(0, 0));
   ri0.m_points.push_back(m2::PointD(10, 0));
   ri0.m_points.push_back(m2::PointD(25, 0));
@@ -146,58 +136,58 @@ void InitRoadGraphMockSourceWithTest2(RoadGraphMockSource & graph)
   ri0.m_points.push_back(m2::PointD(70, 0));
   ri0.m_points.push_back(m2::PointD(80, 0));
 
-  RoadInfo ri1;
+  IRoadGraph::RoadInfo ri1;
   ri1.m_bidirectional = true;
-  ri1.m_speedMS = 40;
+  ri1.m_speedKMPH = 40;
   ri1.m_points.push_back(m2::PointD(0, 0));
   ri1.m_points.push_back(m2::PointD(5, 10));
   ri1.m_points.push_back(m2::PointD(5, 40));
 
-  RoadInfo ri2;
+  IRoadGraph::RoadInfo ri2;
   ri2.m_bidirectional = true;
-  ri2.m_speedMS = 40;
+  ri2.m_speedKMPH = 40;
   ri2.m_points.push_back(m2::PointD(12, 25));
   ri2.m_points.push_back(m2::PointD(10, 10));
   ri2.m_points.push_back(m2::PointD(10, 0));
 
-  RoadInfo ri3;
+  IRoadGraph::RoadInfo ri3;
   ri3.m_bidirectional = true;
-  ri3.m_speedMS = 40;
+  ri3.m_speedKMPH = 40;
   ri3.m_points.push_back(m2::PointD(5, 10));
   ri3.m_points.push_back(m2::PointD(10, 10));
   ri3.m_points.push_back(m2::PointD(70, 10));
   ri3.m_points.push_back(m2::PointD(80, 10));
 
-  RoadInfo ri4;
+  IRoadGraph::RoadInfo ri4;
   ri4.m_bidirectional = true;
-  ri4.m_speedMS = 40;
+  ri4.m_speedKMPH = 40;
   ri4.m_points.push_back(m2::PointD(25, 0));
   ri4.m_points.push_back(m2::PointD(27, 25));
 
-  RoadInfo ri5;
+  IRoadGraph::RoadInfo ri5;
   ri5.m_bidirectional = true;
-  ri5.m_speedMS = 40;
+  ri5.m_speedKMPH = 40;
   ri5.m_points.push_back(m2::PointD(35, 0));
   ri5.m_points.push_back(m2::PointD(37, 30));
   ri5.m_points.push_back(m2::PointD(70, 30));
   ri5.m_points.push_back(m2::PointD(80, 30));
 
-  RoadInfo ri6;
+  IRoadGraph::RoadInfo ri6;
   ri6.m_bidirectional = true;
-  ri6.m_speedMS = 40;
+  ri6.m_speedKMPH = 40;
   ri6.m_points.push_back(m2::PointD(70, 0));
   ri6.m_points.push_back(m2::PointD(70, 10));
   ri6.m_points.push_back(m2::PointD(70, 30));
 
-  RoadInfo ri7;
+  IRoadGraph::RoadInfo ri7;
   ri7.m_bidirectional = true;
-  ri7.m_speedMS = 40;
+  ri7.m_speedKMPH = 40;
   ri7.m_points.push_back(m2::PointD(39, 55));
   ri7.m_points.push_back(m2::PointD(80, 55));
 
-  RoadInfo ri8;
+  IRoadGraph::RoadInfo ri8;
   ri8.m_bidirectional = true;
-  ri8.m_speedMS = 40;
+  ri8.m_speedKMPH = 40;
   ri8.m_points.push_back(m2::PointD(5, 40));
   ri8.m_points.push_back(m2::PointD(18, 55));
   ri8.m_points.push_back(m2::PointD(39, 55));
@@ -206,15 +196,15 @@ void InitRoadGraphMockSourceWithTest2(RoadGraphMockSource & graph)
   ri8.m_points.push_back(m2::PointD(12, 25));
   ri8.m_points.push_back(m2::PointD(5, 40));
 
-  graph.AddRoad(ri0);
-  graph.AddRoad(ri1);
-  graph.AddRoad(ri2);
-  graph.AddRoad(ri3);
-  graph.AddRoad(ri4);
-  graph.AddRoad(ri5);
-  graph.AddRoad(ri6);
-  graph.AddRoad(ri7);
-  graph.AddRoad(ri8);
+  graph.AddRoad(move(ri0));
+  graph.AddRoad(move(ri1));
+  graph.AddRoad(move(ri2));
+  graph.AddRoad(move(ri3));
+  graph.AddRoad(move(ri4));
+  graph.AddRoad(move(ri5));
+  graph.AddRoad(move(ri6));
+  graph.AddRoad(move(ri7));
+  graph.AddRoad(move(ri8));
 }
 
 }  // namespace routing_test
diff --git a/routing/routing_tests/road_graph_builder.hpp b/routing/routing_tests/road_graph_builder.hpp
index ad4c2fdac4..40f3268495 100644
--- a/routing/routing_tests/road_graph_builder.hpp
+++ b/routing/routing_tests/road_graph_builder.hpp
@@ -4,23 +4,6 @@
 
 namespace routing_test
 {
-/// This struct represents road as a polyline.
-struct RoadInfo
-{
-  /// Points of a polyline representing the road.
-  vector<m2::PointD> m_points;
-
-  /// Speed on the road.
-  double m_speedMS;
-
-  /// Indicates whether the road is bidirectional.
-  bool m_bidirectional;
-
-  RoadInfo() : m_speedMS(0.0), m_bidirectional(false) {}
-
-  void Swap(RoadInfo & r);
-};
-
 class RoadGraphMockSource : public routing::IRoadGraph
 {
   vector<RoadInfo> m_roads;
@@ -45,7 +28,7 @@ class RoadGraphMockSource : public routing::IRoadGraph
   TurnsMapT m_turns;
 
 public:
-  void AddRoad(RoadInfo & rd);
+  void AddRoad(RoadInfo && ri);
 
   // routing::IRoadGraph overrides:
   void GetNearestTurns(routing::RoadPos const & pos, TurnsVectorT & turns) override;