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

components/sync/sessions_impl/data_type_tracker.cc

 // Copyright 2013 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 "sync/sessions/data_type_tracker.h"
+#include "components/sync/sessions_impl/data_type_tracker.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
-#include "sync/internal_api/public/base/invalidation_interface.h"
-#include "sync/sessions/nudge_tracker.h"
+#include "components/sync/base/invalidation_interface.h"
+#include "components/sync/sessions_impl/nudge_tracker.h"
 
 namespace syncer {
 namespace sessions {
 
 DataTypeTracker::DataTypeTracker()
     : local_nudge_count_(0),
       local_refresh_request_count_(0),
       payload_buffer_size_(NudgeTracker::kDefaultMaxPayloadsPerType),
       initial_sync_required_(false),
-      sync_required_to_resolve_conflict_(false) {
-}
+      sync_required_to_resolve_conflict_(false) {}
 
-DataTypeTracker::~DataTypeTracker() { }
+DataTypeTracker::~DataTypeTracker() {}
 
 base::TimeDelta DataTypeTracker::RecordLocalChange() {
   local_nudge_count_++;
   return nudge_delay_;
 }
 
 void DataTypeTracker::RecordLocalRefreshRequest() {
   local_refresh_request_count_++;
 }
 
@@ skipping 72 matching lines @@
 
   local_nudge_count_ = 0;
   local_refresh_request_count_ = 0;
 
   // TODO(rlarocque): If we want this to be correct even if we should happen to
   // crash before writing all our state, we should wait until the results of
   // this sync cycle have been written to disk before updating the invalidations
   // state.  See crbug.com/324996.
   for (ScopedVector<InvalidationInterface>::const_iterator it =
            pending_invalidations_.begin();
-       it != pending_invalidations_.end();
-       ++it) {
+       it != pending_invalidations_.end(); ++it) {
     (*it)->Acknowledge();
   }
   pending_invalidations_.clear();
 
   if (last_dropped_invalidation_) {
     last_dropped_invalidation_->Acknowledge();
     last_dropped_invalidation_.reset();
   }
 
   initial_sync_required_ = false;
@@ skipping 54 matching lines @@
   }
 }
 
 void DataTypeTracker::FillGetUpdatesTriggersMessage(
     sync_pb::GetUpdateTriggers* msg) const {
   // Fill the list of payloads, if applicable.  The payloads must be ordered
   // oldest to newest, so we insert them in the same order as we've been storing
   // them internally.
   for (ScopedVector<InvalidationInterface>::const_iterator it =
            pending_invalidations_.begin();
-       it != pending_invalidations_.end();
-       ++it) {
+       it != pending_invalidations_.end(); ++it) {
     if (!(*it)->IsUnknownVersion()) {
       msg->add_notification_hint((*it)->GetPayload());
     }
   }
 
   msg->set_server_dropped_hints(
       !pending_invalidations_.empty() &&
       (*pending_invalidations_.begin())->IsUnknownVersion());
   msg->set_client_dropped_hints(!!last_dropped_invalidation_);
   msg->set_local_modification_nudges(local_nudge_count_);
   msg->set_datatype_refresh_nudges(local_refresh_request_count_);
   msg->set_initial_sync_in_progress(initial_sync_required_);
   msg->set_sync_for_resolve_conflict_in_progress(
       sync_required_to_resolve_conflict_);
 }
 
 bool DataTypeTracker::IsThrottled() const {
   return !unthrottle_time_.is_null();
 }
 
 base::TimeDelta DataTypeTracker::GetTimeUntilUnthrottle(
     base::TimeTicks now) const {
   if (!IsThrottled()) {
     NOTREACHED();
     return base::TimeDelta::FromSeconds(0);
   }
-  return std::max(base::TimeDelta::FromSeconds(0),
-                  unthrottle_time_ - now);
+  return std::max(base::TimeDelta::FromSeconds(0), unthrottle_time_ - now);
 }
 
 void DataTypeTracker::ThrottleType(base::TimeDelta duration,
-                                      base::TimeTicks now) {
+                                   base::TimeTicks now) {
   unthrottle_time_ = std::max(unthrottle_time_, now + duration);
 }
 
 void DataTypeTracker::UpdateThrottleState(base::TimeTicks now) {
   if (now >= unthrottle_time_) {
     unthrottle_time_ = base::TimeTicks();
   }
 }
 
 void DataTypeTracker::UpdateLocalNudgeDelay(base::TimeDelta delay) {
   nudge_delay_ = delay;
 }
 
 }  // namespace sessions
 }  // namespace syncer