[Sync] Remove static initializers

chrome/browser/sync/engine/build_commit_command.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/browser/sync/engine/build_commit_command.h"
 
 #include <limits>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 17 matching lines @@
 using syncable::Id;
 using syncable::MutableEntry;
 using syncable::SPECIFICS;
 using syncable::UNSPECIFIED;
 
 namespace browser_sync {
 
 using sessions::SyncSession;
 
 // static
-const int64 BuildCommitCommand::kFirstPosition =
-    std::numeric_limits<int64>::min();
+int64 BuildCommitCommand::GetFirstPosition() {
+  return std::numeric_limits<int64>::min();
+}
 
 // static
-const int64 BuildCommitCommand::kLastPosition =
-    std::numeric_limits<int64>::max();
+int64 BuildCommitCommand::GetLastPosition() {
+  return std::numeric_limits<int64>::max();
+}
 
 // static
-const int64 BuildCommitCommand::kGap = 1LL << 20;
+int64 BuildCommitCommand::GetGap() {
+  return 1LL << 20;
+}
 
 BuildCommitCommand::BuildCommitCommand() {}
 BuildCommitCommand::~BuildCommitCommand() {}
 
 void BuildCommitCommand::AddExtensionsActivityToMessage(
     SyncSession* session, CommitMessage* message) {
   // We only send ExtensionsActivity to the server if bookmarks are being
   // committed.
   ExtensionsActivityMonitor* monitor = session->context()->extensions_monitor();
   if (!session->status_controller()->HasBookmarkCommitActivity()) {
@@ skipping 121 matching lines @@
       sync_entry->set_deleted(true);
     } else {
       if (meta_entry.Get(SPECIFICS).HasExtension(sync_pb::bookmark)) {
         // Common data in both new and old protocol.
         const Id& prev_id = meta_entry.Get(syncable::PREV_ID);
         string prev_id_string =
             prev_id.IsRoot() ? string() : prev_id.GetServerId();
         sync_entry->set_insert_after_item_id(prev_id_string);
 
         // Compute a numeric position based on what we know locally.
-        std::pair<int64, int64> position_block(kFirstPosition, kLastPosition);
+        std::pair<int64, int64> position_block(
+            GetFirstPosition(), GetLastPosition());
         std::map<Id, std::pair<int64, int64> >::iterator prev_pos =
             position_map.find(prev_id);
         if (prev_pos != position_map.end()) {
           position_block = prev_pos->second;
           position_map.erase(prev_pos);
         } else {
           position_block = std::make_pair(
               FindAnchorPosition(syncable::PREV_ID, meta_entry),
               FindAnchorPosition(syncable::NEXT_ID, meta_entry));
         }
@@ skipping 14 matching lines @@
   Id next_id = entry.Get(direction);
   while (!next_id.IsRoot()) {
     Entry next_entry(entry.trans(),
                      syncable::GET_BY_ID,
                      next_id);
     if (!next_entry.Get(IS_UNSYNCED) && !next_entry.Get(IS_UNAPPLIED_UPDATE)) {
       return next_entry.Get(SERVER_POSITION_IN_PARENT);
     }
     next_id = next_entry.Get(direction);
   }
-  return direction == syncable::PREV_ID ? kFirstPosition : kLastPosition;
+  return
+      direction == syncable::PREV_ID ?
+      GetFirstPosition() : GetLastPosition();
 }
 
 int64 BuildCommitCommand::InterpolatePosition(const int64 lo,
                                               const int64 hi) {
   DCHECK_LE(lo, hi);
 
   // The first item to be added under a parent gets a position of zero.
-  if (lo == kFirstPosition && hi == kLastPosition)
+  if (lo == GetFirstPosition() && hi == GetLastPosition())
     return 0;
 
   // For small gaps, we do linear interpolation.  For larger gaps,
-  // we use an additive offset of |kGap|.  We are careful to avoid
+  // we use an additive offset of |GetGap()|.  We are careful to avoid
   // signed integer overflow.
   uint64 delta = static_cast<uint64>(hi) - static_cast<uint64>(lo);
-  if (delta <= static_cast<uint64>(kGap*2))
+  if (delta <= static_cast<uint64>(GetGap()*2))
     return lo + (static_cast<int64>(delta) + 7) / 8;  // Interpolate.
-  else if (lo == kFirstPosition)
-    return hi - kGap;  // Extend range just before successor.
+  else if (lo == GetFirstPosition())
+    return hi - GetGap();  // Extend range just before successor.
   else
-    return lo + kGap;  // Use or extend range just after predecessor.
+    return lo + GetGap();  // Use or extend range just after predecessor.
 }
 
 
 }  // namespace browser_sync