sync: Refactor per-datatype throttling

sync/engine/all_status.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/all_status.h"
+#include "sync/engine/all_status.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/port.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/internal_api/public/syncable/model_type.h"
 #include "sync/sessions/session_state.h"
 
 namespace browser_sync {
 
 AllStatus::AllStatus() {
   status_.initial_sync_ended = true;
   status_.notifications_enabled = false;
   status_.cryptographer_ready = false;
   status_.crypto_has_pending_keys = false;
 }
 
 AllStatus::~AllStatus() {
 }
 
-sync_api::SyncManager::Status AllStatus::CreateBlankStatus() const {
+sync_api::SyncStatus AllStatus::CreateBlankStatus() const {
   // Status is initialized with the previous status value.  Variables
   // whose values accumulate (e.g. lifetime counters like updates_received)
   // are not to be cleared here.
-  sync_api::SyncManager::Status status = status_;
+  sync_api::SyncStatus status = status_;
   status.encryption_conflicts = 0;
   status.hierarchy_conflicts = 0;
   status.simple_conflicts = 0;
   status.server_conflicts = 0;
   status.committed_count = 0;
   status.initial_sync_ended = false;
   status.updates_available = 0;
   return status;
 }
 
-sync_api::SyncManager::Status AllStatus::CalcSyncing(
+sync_api::SyncStatus AllStatus::CalcSyncing(
     const SyncEngineEvent &event) const {
-  sync_api::SyncManager::Status status = CreateBlankStatus();
+  sync_api::SyncStatus status = CreateBlankStatus();
   const sessions::SyncSessionSnapshot& snapshot = event.snapshot;
   status.encryption_conflicts = snapshot.num_encryption_conflicts();
   status.hierarchy_conflicts = snapshot.num_hierarchy_conflicts();
   status.simple_conflicts = snapshot.num_simple_conflicts();
   status.server_conflicts = snapshot.num_server_conflicts();
   status.committed_count = snapshot.syncer_status().num_successful_commits;
 
   if (event.what_happened == SyncEngineEvent::SYNC_CYCLE_BEGIN) {
     status.syncing = true;
   } else if (event.what_happened == SyncEngineEvent::SYNC_CYCLE_ENDED) {
@@ skipping 57 matching lines @@
     case SyncEngineEvent::ACTIONABLE_ERROR:
       status_ = CreateBlankStatus();
       status_.sync_protocol_error = event.snapshot.errors().sync_protocol_error;
       break;
     default:
       LOG(ERROR) << "Unrecognized Syncer Event: " << event.what_happened;
       break;
   }
 }
 
-sync_api::SyncManager::Status AllStatus::status() const {
+sync_api::SyncStatus AllStatus::status() const {
   base::AutoLock lock(mutex_);
   return status_;
 }
 
 void AllStatus::SetNotificationsEnabled(bool notifications_enabled) {
   ScopedStatusLock lock(this);
   status_.notifications_enabled = notifications_enabled;
 }
 
 void AllStatus::IncrementNotificationsReceived() {
   ScopedStatusLock lock(this);
   ++status_.notifications_received;
 }
 
 void AllStatus::SetEncryptedTypes(syncable::ModelTypeSet types) {
   ScopedStatusLock lock(this);
   status_.encrypted_types = types;
 }
 
+void AllStatus::SetThrottledTypes(const syncable::ModelTypeSet& types) {
+  ScopedStatusLock lock(this);
+  status_.throttled_types = types;
+}
+
 void AllStatus::SetCryptographerReady(bool ready) {
   ScopedStatusLock lock(this);
   status_.cryptographer_ready = ready;
 }
 
 void AllStatus::SetCryptoHasPendingKeys(bool has_pending_keys) {
   ScopedStatusLock lock(this);
   status_.crypto_has_pending_keys = has_pending_keys;
 }
 
 void AllStatus::SetUniqueId(const std::string& guid) {
   ScopedStatusLock lock(this);
   status_.unique_id = guid;
 }
 
 ScopedStatusLock::ScopedStatusLock(AllStatus* allstatus)
     : allstatus_(allstatus) {
   allstatus->mutex_.Acquire();
 }
 
 ScopedStatusLock::~ScopedStatusLock() {
   allstatus_->mutex_.Release();
 }
 
 }  // namespace browser_sync