[Sync] Add client-side plumbing for server control of sessions commit delay

chrome/browser/sync/engine/syncapi.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/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
@@ skipping 91 matching lines @@
 using browser_sync::sessions::SyncSessionContext;
 using std::list;
 using std::hex;
 using std::string;
 using std::vector;
 using syncable::Directory;
 using syncable::DirectoryManager;
 using syncable::Entry;
 using syncable::EntryKernelMutationSet;
 using syncable::kEncryptedString;
+using syncable::ModelType;
 using syncable::ModelTypeBitSet;
 using syncable::WriterTag;
 using syncable::SPECIFICS;
 using sync_pb::AutofillProfileSpecifics;
 
 namespace {
 
 typedef GoogleServiceAuthError AuthError;
 
 static const int kThreadExitTimeoutMsec = 60000;
@@ skipping 1094 matching lines @@
 // SyncManager's implementation: SyncManager::SyncInternal
 class SyncManager::SyncInternal
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public sync_notifier::SyncNotifierObserver,
       public JsBackend,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeDelegate {
   static const int kDefaultNudgeDelayMilliseconds;
   static const int kPreferencesNudgeDelayMilliseconds;
-  // TODO(akalin): Remove this once we have the delay controllable
-  // from the server.
-  static const int kSessionsNudgeDelayMilliseconds;
  public:
   explicit SyncInternal(const std::string& name)
       : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         registrar_(NULL),
         initialized_(false),
         setup_for_test_mode_(false),
         observing_ip_address_changes_(false) {
     // Pre-fill |notification_info_map_|.
     for (int i = syncable::FIRST_REAL_MODEL_TYPE;
          i < syncable::MODEL_TYPE_COUNT; ++i) {
@@ skipping 130 matching lines @@
   // Return the currently active (validated) username for use with syncable
   // types.
   const std::string& username_for_share() const {
     return share_.name;
   }
 
   Status GetStatus();
 
   void RequestNudge(const tracked_objects::Location& nudge_location);
 
-  void RequestNudgeWithDataTypes(const TimeDelta& delay,
-      browser_sync::NudgeSource source, const ModelTypeBitSet& types,
-      const tracked_objects::Location& nudge_location);
+  void RequestNudgeForDataType(
+      const tracked_objects::Location& nudge_location,
+      const ModelType& type);
 
   void RequestEarlyExit();
 
   // See SyncManager::Shutdown for information.
   void Shutdown();
 
   // If this is a deletion for a password, sets the legacy
   // ExtraPasswordChangeRecordData field of |buffer|. Otherwise sets
   // |buffer|'s specifics field to contain the unencrypted data.
   void SetExtraChangeRecordData(int64 id,
@@ skipping 239 matching lines @@
   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_;
   JsTransactionObserver js_transaction_observer_;
 };
 const int SyncManager::SyncInternal::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::SyncInternal::kPreferencesNudgeDelayMilliseconds = 2000;
-const int SyncManager::SyncInternal::kSessionsNudgeDelayMilliseconds = 10000;
 
 SyncManager::Observer::~Observer() {}
 
 SyncManager::SyncManager(const std::string& name)
     : data_(new SyncInternal(name)) {}
 
 SyncManager::Status::Status()
     : summary(INVALID),
       authenticated(false),
       server_up(false),
@@ skipping 806 matching lines @@
 
     // Found real mutation.
     if (mutated_model_type == syncable::UNSPECIFIED) {
       mutated_model_type = model_type;
       break;
     }
   }
 
   // Nudge if necessary.
   if (mutated_model_type != syncable::UNSPECIFIED) {
-    int nudge_delay;
-    switch (mutated_model_type) {
-      case syncable::PREFERENCES:
-        nudge_delay = kPreferencesNudgeDelayMilliseconds;
-      case syncable::SESSIONS:
-        nudge_delay = kSessionsNudgeDelayMilliseconds;
-      default:
-        nudge_delay = kDefaultNudgeDelayMilliseconds;
-    }
-    syncable::ModelTypeBitSet model_types;
-    model_types.set(mutated_model_type);
     if (weak_handle_this_.IsInitialized()) {
       weak_handle_this_.Call(FROM_HERE,
-                             &SyncInternal::RequestNudgeWithDataTypes,
-                             TimeDelta::FromMilliseconds(nudge_delay),
-                             browser_sync::NUDGE_SOURCE_LOCAL,
-                             model_types,
-                             FROM_HERE);
+                             &SyncInternal::RequestNudgeForDataType,
+                             FROM_HERE,
+                             mutated_model_type);
     } else {
       NOTREACHED();
     }
   }
 }
 
 void SyncManager::SyncInternal::SetExtraChangeRecordData(int64 id,
     syncable::ModelType type, ChangeReorderBuffer* buffer,
     Cryptographer* cryptographer, const syncable::EntryKernel& original,
     bool existed_before, bool exists_now) {
@@ skipping 64 matching lines @@
 }
 
 void SyncManager::SyncInternal::RequestNudge(
     const tracked_objects::Location& location) {
   if (scheduler())
      scheduler()->ScheduleNudge(
         TimeDelta::FromMilliseconds(0), browser_sync::NUDGE_SOURCE_LOCAL,
         ModelTypeBitSet(), location);
 }
 
-void SyncManager::SyncInternal::RequestNudgeWithDataTypes(
-    const TimeDelta& delay,
-    browser_sync::NudgeSource source, const ModelTypeBitSet& types,
-    const tracked_objects::Location& nudge_location) {
+
+void SyncManager::SyncInternal::RequestNudgeForDataType(
+    const tracked_objects::Location& nudge_location,
+    const ModelType& type) {
   if (!scheduler()) {
     NOTREACHED();
     return;
   }
-  scheduler()->ScheduleNudge(delay, source, types, nudge_location);
+  base::TimeDelta nudge_delay;
+  switch (type) {
+    case syncable::PREFERENCES:
+      nudge_delay =
+          TimeDelta::FromMilliseconds(kPreferencesNudgeDelayMilliseconds);
+      break;
+    case syncable::SESSIONS:
+      nudge_delay = scheduler()->GetSessionsCommitDelay();
+      break;
+    default:
+      nudge_delay =
+          TimeDelta::FromMilliseconds(kPreferencesNudgeDelayMilliseconds);
+      break;
+  }
+  syncable::ModelTypeBitSet types;
+  types.set(type);
+  scheduler()->ScheduleNudge(nudge_delay,
+                             browser_sync::NUDGE_SOURCE_LOCAL,
+                             types,
+                             nudge_location);
 }
 
 void SyncManager::SyncInternal::OnSyncEngineEvent(
     const SyncEngineEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!HaveObservers()) {
     LOG(INFO)
         << "OnSyncEngineEvent returning because observers_.size() is zero";
     return;
   }
@@ skipping 485 matching lines @@
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api