[Sync] Move //sync to //components/sync.

components/sync/base/ordinal.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef SYNC_INTERNAL_API_PUBLIC_BASE_ORDINAL_H_
-#define SYNC_INTERNAL_API_PUBLIC_BASE_ORDINAL_H_
+#ifndef COMPONENTS_SYNC_BASE_ORDINAL_H_
+#define COMPONENTS_SYNC_BASE_ORDINAL_H_
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cstddef>
 #include <string>
 
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 
@@ skipping 133 matching lines @@
   static_assert(kMaxDigitValue > kMidDigitValue, "incorrect ordinal max digit");
   static_assert(kRadix == kMaxDigitValue + 1, "incorrect ordinal radix");
 
  private:
   // Returns true iff the given byte string satisfies the criteria for
   // a valid Ordinal.
   static bool IsValidOrdinalBytes(const std::string& bytes);
 
   // Returns the length that bytes.substr(0, length) would be with
   // trailing zero digits removed.
-  static size_t GetLengthWithoutTrailingZeroDigits(
-      const std::string& bytes,
-      size_t length);
+  static size_t GetLengthWithoutTrailingZeroDigits(const std::string& bytes,
+                                                   size_t length);
 
   // Returns the digit at position i, padding with zero digits if
   // required.
   static uint8_t GetDigit(const std::string& bytes, size_t i);
 
   // Returns the digit value at position i, padding with 0 if required.
   static int GetDigitValue(const std::string& bytes, size_t i);
 
   // Adds the given value to |bytes| at position i, carrying when
   // necessary.  Returns the left-most carry.
@@ skipping 22 matching lines @@
   std::string bytes_;
 
   // A cache of the result of IsValidOrdinalBytes(bytes_).
   bool is_valid_;
 };
 
 template <typename Traits>
 const uint8_t Ordinal<Traits>::kZeroDigit;
 template <typename Traits>
 const uint8_t Ordinal<Traits>::kMaxDigit;
-template <typename Traits> const size_t Ordinal<Traits>::kMinLength;
+template <typename Traits>
+const size_t Ordinal<Traits>::kMinLength;
 template <typename Traits>
 const uint8_t Ordinal<Traits>::kOneDigit;
 template <typename Traits>
 const uint8_t Ordinal<Traits>::kMidDigit;
-template <typename Traits> const unsigned int Ordinal<Traits>::kMidDigitValue;
-template <typename Traits> const unsigned int Ordinal<Traits>::kMaxDigitValue;
-template <typename Traits> const unsigned int Ordinal<Traits>::kRadix;
+template <typename Traits>
+const unsigned int Ordinal<Traits>::kMidDigitValue;
+template <typename Traits>
+const unsigned int Ordinal<Traits>::kMaxDigitValue;
+template <typename Traits>
+const unsigned int Ordinal<Traits>::kRadix;
 
 template <typename Traits>
 Ordinal<Traits>::LessThanFn::LessThanFn() {}
 
 template <typename Traits>
 bool Ordinal<Traits>::LessThanFn::operator()(const Ordinal<Traits>& lhs,
                                              const Ordinal<Traits>& rhs) const {
   return lhs.LessThan(rhs);
 }
 
 template <typename Traits>
 Ordinal<Traits>::EqualsFn::EqualsFn() {}
 
 template <typename Traits>
 bool Ordinal<Traits>::EqualsFn::operator()(const Ordinal<Traits>& lhs,
                                            const Ordinal<Traits>& rhs) const {
   return lhs.Equals(rhs);
 }
 
 template <typename Traits>
 Ordinal<Traits>::Ordinal(const std::string& bytes)
-    : bytes_(bytes),
-      is_valid_(IsValidOrdinalBytes(bytes_)) {}
+    : bytes_(bytes), is_valid_(IsValidOrdinalBytes(bytes_)) {}
 
 template <typename Traits>
 Ordinal<Traits>::Ordinal() : is_valid_(false) {}
 
 template <typename Traits>
 Ordinal<Traits> Ordinal<Traits>::CreateInitialOrdinal() {
   std::string bytes(Traits::kMinLength, kZeroDigit);
   bytes[0] = kMidDigit;
   return Ordinal(bytes);
 }
@@ skipping 120 matching lines @@
     const uint8_t last_byte = bytes[length - 1];
     if (last_byte == kZeroDigit)
       return false;
   }
 
   return true;
 }
 
 template <typename Traits>
 size_t Ordinal<Traits>::GetLengthWithoutTrailingZeroDigits(
-    const std::string& bytes, size_t length) {
+    const std::string& bytes,
+    size_t length) {
   DCHECK(!bytes.empty());
   DCHECK_GT(length, 0U);
 
   size_t end_position =
       bytes.find_last_not_of(static_cast<char>(kZeroDigit), length - 1);
 
   // If no non kZeroDigit is found then the string is a string of all zeros
   // digits so we return 0 as the correct length.
   if (end_position == std::string::npos)
     return 0;
 
   return end_position + 1;
 }
 
 template <typename Traits>
 uint8_t Ordinal<Traits>::GetDigit(const std::string& bytes, size_t i) {
   return (i < bytes.length()) ? bytes[i] : kZeroDigit;
 }
 
 template <typename Traits>
 int Ordinal<Traits>::GetDigitValue(const std::string& bytes, size_t i) {
   return GetDigit(bytes, i) - kZeroDigit;
 }
 
 template <typename Traits>
 int Ordinal<Traits>::AddDigitValue(std::string* bytes,
-                                   size_t i, int digit_value) {
+                                   size_t i,
+                                   int digit_value) {
   DCHECK_GE(i, 0U);
   DCHECK_LT(i, bytes->length());
 
   for (int j = static_cast<int>(i); j >= 0 && digit_value > 0; --j) {
     int byte_j_value = GetDigitValue(*bytes, j) + digit_value;
     digit_value = byte_j_value / kRadix;
     DCHECK_LE(digit_value, 1);
     byte_j_value %= kRadix;
     (*bytes)[j] = static_cast<char>(kZeroDigit + byte_j_value);
   }
@@ skipping 14 matching lines @@
         GetLengthWithoutTrailingZeroDigits(bytes, drop_length - 1);
 
     if (truncated_length > 0 &&
         bytes.compare(0, truncated_length, lower_bound) > 0)
       drop_length = truncated_length;
   }
   return std::max(drop_length, kMinLength);
 }
 
 template <typename Traits>
-std::string Ordinal<Traits>::ComputeMidpoint(
-    const std::string& start,
-    const std::string& end) {
+std::string Ordinal<Traits>::ComputeMidpoint(const std::string& start,
+                                             const std::string& end) {
   size_t max_size = std::max(start.length(), end.length()) + 1;
   std::string midpoint(max_size, kZeroDigit);
 
   // Perform the operation (start + end) / 2 left-to-right by
   // maintaining a "forward carry" which is either 0 or
   // kMidDigitValue.  AddDigitValue() is in general O(n), but this
   // operation is still O(n) despite that; calls to AddDigitValue()
   // will overflow at most to the last position where AddDigitValue()
   // last overflowed.
   int forward_carry = 0;
@@ skipping 28 matching lines @@
   DCHECK_GT(midpoint, start_bytes);
   DCHECK_LT(midpoint, end_bytes);
 
   Ordinal<Traits> midpoint_ordinal(midpoint);
   DCHECK(midpoint_ordinal.IsValid());
   return midpoint_ordinal;
 }
 
 }  // namespace syncer
 
-#endif  // SYNC_INTERNAL_API_PUBLIC_BASE_ORDINAL_H_
+#endif  // COMPONENTS_SYNC_BASE_ORDINAL_H_