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

components/sync/sessions_impl/nudge_tracker.cc

 // Copyright (c) 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/nudge_tracker.h"
+#include "components/sync/sessions_impl/nudge_tracker.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
-#include "sync/internal_api/public/engine/polling_constants.h"
-#include "sync/protocol/sync.pb.h"
+#include "components/sync/engine/polling_constants.h"
+#include "components/sync/protocol/sync.pb.h"
 
 namespace syncer {
 namespace sessions {
 
 namespace {
 
 // Delays for syncer nudges.
 const int kDefaultNudgeDelayMilliseconds = 200;
 const int kSlowNudgeDelayMilliseconds = 2000;
 const int kDefaultSessionsCommitDelaySeconds = 10;
 const int kSyncRefreshDelayMilliseconds = 500;
 const int kSyncSchedulerDelayMilliseconds = 250;
 
 base::TimeDelta GetDefaultDelayForType(ModelType model_type,
                                        base::TimeDelta minimum_delay) {
   switch (model_type) {
     case AUTOFILL:
-     // Accompany types rely on nudges from other types, and hence have long
-     // nudge delays.
-     return base::TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds);
+      // Accompany types rely on nudges from other types, and hence have long
+      // nudge delays.
+      return base::TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds);
     case BOOKMARKS:
     case PREFERENCES:
-     // Types with sometimes automatic changes get longer delays to allow more
-     // coalescing.
-     return base::TimeDelta::FromMilliseconds(kSlowNudgeDelayMilliseconds);
+      // Types with sometimes automatic changes get longer delays to allow more
+      // coalescing.
+      return base::TimeDelta::FromMilliseconds(kSlowNudgeDelayMilliseconds);
     case SESSIONS:
     case FAVICON_IMAGES:
     case FAVICON_TRACKING:
-     // Types with navigation triggered changes get longer delays to allow more
-     // coalescing.
-     return base::TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds);
+      // Types with navigation triggered changes get longer delays to allow more
+      // coalescing.
+      return base::TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds);
     default:
-     return minimum_delay;
+      return minimum_delay;
   }
 }
 
 }  // namespace
 
 size_t NudgeTracker::kDefaultMaxPayloadsPerType = 10;
 
 NudgeTracker::NudgeTracker()
     : invalidations_enabled_(false),
       invalidations_out_of_sync_(true),
       minimum_local_nudge_delay_(
           base::TimeDelta::FromMilliseconds(kDefaultNudgeDelayMilliseconds)),
       local_refresh_nudge_delay_(
           base::TimeDelta::FromMilliseconds(kSyncRefreshDelayMilliseconds)),
       remote_invalidation_nudge_delay_(
           base::TimeDelta::FromMilliseconds(kSyncSchedulerDelayMilliseconds)) {
   ModelTypeSet protocol_types = ProtocolTypes();
   // Default initialize all the type trackers.
   for (ModelTypeSet::Iterator it = protocol_types.First(); it.Good();
        it.Inc()) {
     type_trackers_.insert(
         std::make_pair(it.Get(), base::WrapUnique(new DataTypeTracker())));
   }
 }
 
-NudgeTracker::~NudgeTracker() { }
+NudgeTracker::~NudgeTracker() {}
 
 bool NudgeTracker::IsSyncRequired() const {
   if (IsRetryRequired())
     return true;
 
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     if (it->second->IsSyncRequired()) {
       return true;
     }
@@ skipping 49 matching lines @@
   for (ModelTypeSet::Iterator type_it = types.First(); type_it.Good();
        type_it.Inc()) {
     TypeTrackerMap::const_iterator tracker_it =
         type_trackers_.find(type_it.Get());
     DCHECK(tracker_it != type_trackers_.end());
 
     // Only if the type tracker has a valid delay (non-zero) that is shorter
     // than the calculated delay do we update the calculated delay.
     base::TimeDelta type_delay = tracker_it->second->RecordLocalChange();
     if (type_delay.is_zero()) {
-      type_delay = GetDefaultDelayForType(type_it.Get(),
-                                          minimum_local_nudge_delay_);
+      type_delay =
+          GetDefaultDelayForType(type_it.Get(), minimum_local_nudge_delay_);
     }
     if (type_delay < delay)
       delay = type_delay;
   }
   return delay;
 }
 
 base::TimeDelta NudgeTracker::RecordLocalRefreshRequest(ModelTypeSet types) {
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(it.Get());
@@ skipping 27 matching lines @@
 
 void NudgeTracker::OnInvalidationsEnabled() {
   invalidations_enabled_ = true;
 }
 
 void NudgeTracker::OnInvalidationsDisabled() {
   invalidations_enabled_ = false;
   invalidations_out_of_sync_ = true;
 }
 
-void NudgeTracker::SetTypesThrottledUntil(
-    ModelTypeSet types,
-    base::TimeDelta length,
-    base::TimeTicks now) {
+void NudgeTracker::SetTypesThrottledUntil(ModelTypeSet types,
+                                          base::TimeDelta length,
+                                          base::TimeTicks now) {
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(it.Get());
     tracker_it->second->ThrottleType(length, now);
   }
 }
 
 void NudgeTracker::UpdateTypeThrottlingState(base::TimeTicks now) {
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second->UpdateThrottleState(now);
@@ skipping 126 matching lines @@
     return sync_pb::GetUpdatesCallerInfo::DATATYPE_REFRESH;
   } else if (has_commit_pending) {
     return sync_pb::GetUpdatesCallerInfo::LOCAL;
   } else if (has_retry) {
     return sync_pb::GetUpdatesCallerInfo::RETRY;
   } else {
     return sync_pb::GetUpdatesCallerInfo::UNKNOWN;
   }
 }
 
-void NudgeTracker::FillProtoMessage(
-    ModelType type,
-    sync_pb::GetUpdateTriggers* msg) const {
+void NudgeTracker::FillProtoMessage(ModelType type,
+                                    sync_pb::GetUpdateTriggers* msg) const {
   DCHECK(type_trackers_.find(type) != type_trackers_.end());
 
   // Fill what we can from the global data.
   msg->set_invalidations_out_of_sync(invalidations_out_of_sync_);
 
   // Delegate the type-specific work to the DataTypeTracker class.
   type_trackers_.find(type)->second->FillGetUpdatesTriggersMessage(msg);
 }
 
 void NudgeTracker::SetSyncCycleStartTime(base::TimeTicks now) {
@@ skipping 27 matching lines @@
 }
 
 void NudgeTracker::SetNextRetryTime(base::TimeTicks retry_time) {
   next_retry_time_ = retry_time;
 }
 
 void NudgeTracker::OnReceivedCustomNudgeDelays(
     const std::map<ModelType, base::TimeDelta>& delay_map) {
   for (std::map<ModelType, base::TimeDelta>::const_iterator iter =
            delay_map.begin();
-       iter != delay_map.end();
-       ++iter) {
+       iter != delay_map.end(); ++iter) {
     ModelType type = iter->first;
     DCHECK(syncer::ProtocolTypes().Has(type));
     TypeTrackerMap::const_iterator type_iter = type_trackers_.find(type);
     if (type_iter == type_trackers_.end())
       continue;
 
     if (iter->second > minimum_local_nudge_delay_) {
       type_iter->second->UpdateLocalNudgeDelay(iter->second);
     } else {
       type_iter->second->UpdateLocalNudgeDelay(
-          GetDefaultDelayForType(type,
-                                 minimum_local_nudge_delay_));
+          GetDefaultDelayForType(type, minimum_local_nudge_delay_));
     }
   }
 }
 
 void NudgeTracker::SetDefaultNudgeDelay(base::TimeDelta nudge_delay) {
   minimum_local_nudge_delay_ = nudge_delay;
 }
 
 }  // namespace sessions
 }  // namespace syncer