sync: Refactor per-datatype throttling

sync/internal_api/sync_manager.cc

 // 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.
 
 #include "sync/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/network_change_notifier.h"
+#include "sync/engine/all_status.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/nigori_util.h"
 #include "sync/engine/sync_scheduler.h"
 #include "sync/engine/syncer_types.h"
-#include "sync/internal_api/all_status.h"
+#include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/internal_api/base_node.h"
 #include "sync/internal_api/change_reorder_buffer.h"
 #include "sync/internal_api/configure_reason.h"
 #include "sync/internal_api/debug_info_event_listener.h"
 #include "sync/internal_api/js_mutation_event_observer.h"
 #include "sync/internal_api/js_sync_manager_observer.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/internal_api/public/syncable/model_type.h"
 #include "sync/internal_api/public/syncable/model_type_payload_map.h"
 #include "sync/internal_api/read_node.h"
@@ skipping 101 matching lines @@
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeDelegate {
  public:
   explicit SyncInternal(const std::string& name)
       : name_(name),
         weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         change_delegate_(NULL),
         initialized_(false),
         testing_mode_(NON_TEST),
         observing_ip_address_changes_(false),
+        throttled_data_type_tracker_(&allstatus_),
         traffic_recorder_(kMaxMessagesToRecord, kMaxMessageSizeToRecord),
         encryptor_(NULL),
         unrecoverable_error_handler_(NULL),
         report_unrecoverable_error_function_(NULL),
         created_on_loop_(MessageLoop::current()),
         nigori_overwrite_count_(0) {
     // Pre-fill |notification_info_map_|.
     for (int i = syncable::FIRST_REAL_MODEL_TYPE;
          i < syncable::MODEL_TYPE_COUNT; ++i) {
       notification_info_map_.insert(
@@ skipping 182 matching lines @@
     DCHECK(initialized_);
     return &share_;
   }
 
   // Return the currently active (validated) username for use with syncable
   // types.
   const std::string& username_for_share() const {
     return share_.name;
   }
 
-  Status GetStatus();
+  SyncStatus GetStatus();
 
   void RequestNudge(const tracked_objects::Location& nudge_location);
 
   void RequestNudgeForDataTypes(
       const tracked_objects::Location& nudge_location,
       ModelTypeSet type);
 
   TimeDelta GetNudgeDelayTimeDelta(const ModelType& model_type);
 
   void NotifyCryptographerState(Cryptographer* cryptographer);
@@ skipping 235 matching lines @@
   // Map used to store the notification info to be displayed in
   // about:sync page.
   NotificationInfoMap notification_info_map_;
 
   // These are for interacting with chrome://sync-internals.
   JsMessageHandlerMap js_message_handlers_;
   WeakHandle<JsEventHandler> js_event_handler_;
   JsSyncManagerObserver js_sync_manager_observer_;
   JsMutationEventObserver js_mutation_event_observer_;
 
+  browser_sync::ThrottledDataTypeTracker throttled_data_type_tracker_;
+
   // This is for keeping track of client events to send to the server.
   DebugInfoEventListener debug_info_event_listener_;
 
   browser_sync::TrafficRecorder traffic_recorder_;
 
   Encryptor* encryptor_;
   UnrecoverableErrorHandler* unrecoverable_error_handler_;
   ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
 
   MessageLoop* const created_on_loop_;
@@ skipping 80 matching lines @@
 
 SyncManager::ChangeDelegate::~ChangeDelegate() {}
 
 SyncManager::ChangeObserver::~ChangeObserver() {}
 
 SyncManager::Observer::~Observer() {}
 
 SyncManager::SyncManager(const std::string& name)
     : data_(new SyncInternal(name)) {}
 
-SyncManager::Status::Status()
-    : notifications_enabled(false),
-      notifications_received(0),
-      encryption_conflicts(0),
-      hierarchy_conflicts(0),
-      simple_conflicts(0),
-      server_conflicts(0),
-      committed_count(0),
-      syncing(false),
-      initial_sync_ended(false),
-      updates_available(0),
-      updates_received(0),
-      reflected_updates_received(0),
-      tombstone_updates_received(0),
-      num_commits_total(0),
-      num_local_overwrites_total(0),
-      num_server_overwrites_total(0),
-      nonempty_get_updates(0),
-      empty_get_updates(0),
-      sync_cycles_with_commits(0),
-      sync_cycles_without_commits(0),
-      useless_sync_cycles(0),
-      useful_sync_cycles(0),
-      cryptographer_ready(false),
-      crypto_has_pending_keys(false) {
-}
-
-SyncManager::Status::~Status() {
-}
-
 bool SyncManager::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     HttpPostProviderFactory* post_factory,
     const browser_sync::ModelSafeRoutingInfo& model_safe_routing_info,
     const std::vector<browser_sync::ModelSafeWorker*>& workers,
@@ skipping 203 matching lines @@
     DVLOG(1) << "Sync is bringing up SyncSessionContext.";
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(&allstatus_);
     listeners.push_back(this);
     session_context_.reset(new SyncSessionContext(
         connection_manager_.get(),
         directory(),
         model_safe_routing_info,
         workers,
         extensions_activity_monitor,
+        &throttled_data_type_tracker_,
         listeners,
         &debug_info_event_listener_,
         &traffic_recorder_));
     session_context()->set_account_name(credentials.email);
     scheduler_.reset(new SyncScheduler(name_, session_context(), new Syncer()));
   }
 
   bool signed_in = SignIn(credentials);
 
   if (signed_in) {
@@ skipping 984 matching lines @@
              VisiblePropertiesDiffer(it->second, crypto)) {
       change_buffers_[type].PushUpdatedItem(
           handle, VisiblePositionsDiffer(it->second));
     }
 
     SetExtraChangeRecordData(handle, type, &change_buffers_[type], crypto,
                              it->second.original, existed_before, exists_now);
   }
 }
 
-SyncManager::Status SyncManager::SyncInternal::GetStatus() {
+SyncStatus SyncManager::SyncInternal::GetStatus() {
   return allstatus_.status();
 }
 
 void SyncManager::SyncInternal::RequestNudge(
     const tracked_objects::Location& location) {
   if (scheduler()) {
      scheduler()->ScheduleNudge(
         TimeDelta::FromMilliseconds(0), browser_sync::NUDGE_SOURCE_LOCAL,
         ModelTypeSet(), location);
   }
@@ skipping 398 matching lines @@
 void SyncManager::SyncInternal::AddObserver(
     SyncManager::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void SyncManager::SyncInternal::RemoveObserver(
     SyncManager::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-SyncManager::Status SyncManager::GetDetailedStatus() const {
+SyncStatus SyncManager::GetDetailedStatus() const {
   return data_->GetStatus();
 }
 
 void SyncManager::SaveChanges() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SaveChanges();
 }
 
 void SyncManager::SyncInternal::SaveChanges() {
   directory()->SaveChanges();
@@ skipping 110 matching lines @@
     share->directory->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api