Fix usage of deprecated APIs. (#219)

These were spotted with -Wdeprecated-declarations in a clang build.

No functionality change.

Author: nlewycky

src/s2/encoded_s2point_vector.cc

@@ -105,7 +105,7 @@ bool EncodedS2PointVector::Init(Decoder* decoder) {
 
   // Peek at the format but don't advance the decoder; the format-specific
   // Init functions will do that.
-  format_ = static_cast<Format>(*decoder->ptr() & kEncodingFormatMask);
+  format_ = static_cast<Format>(*decoder->skip(0) & kEncodingFormatMask);
   switch (format_) {
     case UNCOMPRESSED:
       return InitUncompressedFormat(decoder);
@@ -196,7 +196,7 @@ bool EncodedS2PointVector::InitUncompressedFormat(Decoder* decoder) {
   size_t bytes = size_t{size_} * sizeof(S2Point);
   if (decoder->avail() < bytes) return false;
 
-  uncompressed_.points = reinterpret_cast<const S2Point*>(decoder->ptr());
+  uncompressed_.points = reinterpret_cast<const S2Point*>(decoder->skip(0));
   decoder->skip(bytes);
   return true;
 }

src/s2/encoded_string_vector.cc

@@ -46,7 +46,7 @@ void StringVectorEncoder::Encode(Span<const string> v, Encoder* encoder) {
 
 bool EncodedStringVector::Init(Decoder* decoder) {
   if (!offsets_.Init(decoder)) return false;
-  data_ = reinterpret_cast<const char*>(decoder->ptr());
+  data_ = reinterpret_cast<const char*>(decoder->skip(0));
   if (offsets_.size() > 0) {
     uint64 length = offsets_[offsets_.size() - 1];
     if (decoder->avail() < length) return false;

src/s2/encoded_uint_vector.h

@@ -192,7 +192,7 @@ inline T GetUintWithLength(const char* ptr, int length) {
 template <class T>
 bool DecodeUintWithLength(int length, Decoder* decoder, T* result) {
   if (decoder->avail() < length) return false;
-  const char* ptr = reinterpret_cast<const char*>(decoder->ptr());
+  const char* ptr = reinterpret_cast<const char*>(decoder->skip(0));
   *result = GetUintWithLength<T>(ptr, length);
   decoder->skip(length);
   return true;
@@ -231,7 +231,7 @@ bool EncodedUintVector<T>::Init(Decoder* decoder) {
   if (size_ > std::numeric_limits<size_t>::max() / sizeof(T)) return false;
   size_t bytes = size_ * len_;
   if (decoder->avail() < bytes) return false;
-  data_ = reinterpret_cast<const char*>(decoder->ptr());
+  data_ = reinterpret_cast<const char*>(decoder->skip(0));
   decoder->skip(bytes);
   return true;
 }

src/s2/s2builderutil_get_snapped_winding_delta.cc

@@ -173,7 +173,7 @@ S2Point GetConnector(const S2Point& b0, const S2Point& b1,
   // Otherwise we use the point on (B0, B1) that is 90 degrees away from B1'.
   // This is sufficient to ensure conditions (1) and (2).
   S2Point x = S2::RobustCrossProd(b0, b1).CrossProd(b1_snapped).Normalize();
-  return (x.DotProd(S2::Interpolate(0.5, b0, b1)) >= 0) ? x : -x;
+  return (x.DotProd(S2::Interpolate(b0, b1, 0.5)) >= 0) ? x : -x;
 }
 
 // Returns the set of incoming and outgoing edges incident to the given

src/s2/s2cap.cc

@@ -127,10 +127,10 @@ S2Cap S2Cap::Union(const S2Cap& other) const {
     return *this;
   } else {
     S1Angle result_radius = 0.5 * (distance + this_radius + other_radius);
-    S2Point result_center = S2::InterpolateAtDistance(
-        0.5 * (distance - this_radius + other_radius),
+    S2Point result_center = S2::GetPointOnLine(
         center(),
-        other.center());
+        other.center(),
+        0.5 * (distance - this_radius + other_radius));
     return S2Cap(result_center, result_radius);
   }
 }

src/s2/s2convex_hull_query.cc

@@ -203,7 +203,7 @@ unique_ptr<S2Loop> S2ConvexHullQuery::GetSingleEdgeLoop(const S2Point& a,
   vector<S2Point> vertices;
   vertices.push_back(a);
   vertices.push_back(b);
-  vertices.push_back(S2::Interpolate(0.5, a, b));
+  vertices.push_back(S2::Interpolate(a, b, 0.5));
   auto loop = make_unique<S2Loop>(vertices);
   // The resulting loop may be clockwise, so invert it if necessary.
   loop->Normalize();

src/s2/s2edge_tessellator.cc

@@ -201,8 +201,8 @@ S1ChordAngle S2EdgeTessellator::EstimateMaxError(
 
   constexpr double t1 = kInterpolationFraction;
   constexpr double t2 = 1 - kInterpolationFraction;
-  S2Point mid1 = S2::Interpolate(t1, a, b);
-  S2Point mid2 = S2::Interpolate(t2, a, b);
+  S2Point mid1 = S2::Interpolate(a, b, t1);
+  S2Point mid2 = S2::Interpolate(a, b, t2);
   S2Point pmid1 = proj_.Unproject(proj_.Interpolate(t1, pa, pb));
   S2Point pmid2 = proj_.Unproject(proj_.Interpolate(t2, pa, pb));
   return std::max(S1ChordAngle(mid1, pmid1), S1ChordAngle(mid2, pmid2));

src/s2/s2loop.cc

@@ -644,7 +644,7 @@ bool S2Loop::DecodeInternal(Decoder* const decoder,
 #endif
   if (within_scope && !is_misaligned) {
     vertices_ = const_cast<S2Point *>(reinterpret_cast<const S2Point*>(
-                    decoder->ptr()));
+                    decoder->skip(0)));
     decoder->skip(num_vertices_ * sizeof(*vertices_));
     owns_vertices_ = false;
   } else {

src/s2/s2polyline.cc

@@ -238,8 +238,7 @@ S2Point S2Polyline::GetSuffix(double fraction, int* next_vertex) const {
     if (target < length) {
       // This interpolates with respect to arc length rather than
       // straight-line distance, and produces a unit-length result.
-      S2Point result = S2::InterpolateAtDistance(target, vertex(i-1),
-                                                         vertex(i));
+      S2Point result = S2::GetPointOnLine(vertex(i-1), vertex(i), target);
       // It is possible that (result == vertex(i)) due to rounding errors.
       *next_vertex = (result == vertex(i)) ? (i + 1) : i;
       return result;