Add non-blocking sync code to ProfileSyncService

chrome/browser/sync/glue/sync_backend_host_impl.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 "chrome/browser/sync/glue/sync_backend_host_impl.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/invalidation_service.h"
 #include "chrome/browser/invalidation/invalidation_service_factory.h"
@@ skipping 216 matching lines @@
 
 void SyncBackendHostImpl::StopSyncingForShutdown() {
   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
 
   // Immediately stop sending messages to the frontend.
   frontend_ = NULL;
 
   // Stop listening for and forwarding locally-triggered sync refresh requests.
   notification_registrar_.RemoveAll();
 
+  // Stop non-blocking sync types from sending any more requests to the syncer.
+  sync_core_proxy_.reset();
+
   DCHECK(registrar_->sync_thread()->IsRunning());
 
   registrar_->RequestWorkerStopOnUIThread();
 
   core_->ShutdownOnUIThread();
 }
 
 scoped_ptr<base::Thread> SyncBackendHostImpl::Shutdown(ShutdownOption option) {
   // StopSyncingForShutdown() (which nulls out |frontend_|) should be
   // called first.
@@ skipping 34 matching lines @@
 }
 
 void SyncBackendHostImpl::UnregisterInvalidationIds() {
   if (invalidation_handler_registered_) {
     invalidator_->UpdateRegisteredInvalidationIds(
         this,
         syncer::ObjectIdSet());
   }
 }
 
+void SyncBackendHostImpl::SetPreferredNonBlockingTypes(
+    syncer::ModelTypeSet types) {
+  preferred_non_blocking_types_ = types;
+  UpdateRegisteredInvalidationTypes();
+}
+
 void SyncBackendHostImpl::ConfigureDataTypes(
     syncer::ConfigureReason reason,
     const DataTypeConfigStateMap& config_state_map,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task,
     const base::Callback<void()>& retry_callback) {
   // Only one configure is allowed at a time.  This is guaranteed by our
   // callers.  The SyncBackendHostImpl requests one configure as the backend is
   // initializing and waits for it to complete.  After initialization, all
   // configurations will pass through the DataTypeManager, which is careful to
@@ skipping 119 matching lines @@
 }
 
 void SyncBackendHostImpl::DeactivateDataType(syncer::ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
 syncer::UserShare* SyncBackendHostImpl::GetUserShare() const {
   return core_->sync_manager()->GetUserShare();
 }
 
+syncer::SyncCoreProxy SyncBackendHostImpl::GetSyncCoreProxy() {
+  return *sync_core_proxy_.get();
+}
+
 SyncBackendHostImpl::Status SyncBackendHostImpl::GetDetailedStatus() {
   DCHECK(initialized());
   return core_->sync_manager()->GetDetailedStatus();
 }
 
 syncer::sessions::SyncSessionSnapshot
 SyncBackendHostImpl::GetLastSessionSnapshot() const {
   return last_snapshot_;
 }
 
@@ skipping 77 matching lines @@
 
 void SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop(
     const syncer::ModelTypeSet enabled_types,
     const syncer::ModelTypeSet succeeded_configuration_types,
     const syncer::ModelTypeSet failed_configuration_types,
     const base::Callback<void(syncer::ModelTypeSet,
                               syncer::ModelTypeSet)>& ready_task) {
   if (!frontend_)
     return;
 
-  invalidator_->UpdateRegisteredInvalidationIds(
-      this,
-      ModelTypeSetToObjectIdSet(enabled_types));
+  enabled_directory_types_ = enabled_types;
+  UpdateRegisteredInvalidationTypes();
 
   if (!ready_task.is_null())
     ready_task.Run(succeeded_configuration_types, failed_configuration_types);
 }
 
+void SyncBackendHostImpl::UpdateRegisteredInvalidationTypes() {

[Nicolas Zea, 2014/04/02 23:19:05]

How about changing this to UpdateEnabledTypes(directory types, nonblocking
types), and having that always invoke UpdateRegisteredInvalidationIds? That way
you don't have to remember to also call that in the two spots you've got.

[rlarocque, 2014/04/03 01:03:46]

I don't understand this suggestion.  We'd still need call this function in both
spots, because there are two scenarios where the list of registered types must
be changed.

[Nicolas Zea, 2014/04/03 17:52:15]

Yeah, I think I was still thinking of the set of enabled types as one enumset.
Disregard.

+  invalidator_->UpdateRegisteredInvalidationIds(
+      this,
+      ModelTypeSetToObjectIdSet(
+          Union(enabled_directory_types_, preferred_non_blocking_types_)));
+}
+
 void SyncBackendHostImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK_EQ(type, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL);
 
   content::Details<const syncer::ModelTypeSet> state_details(details);
   const syncer::ModelTypeSet& types = *(state_details.ptr());
   registrar_->sync_thread()->message_loop()->PostTask(FROM_HERE,
@@ skipping 11 matching lines @@
   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   if (!frontend_)
     return;
 
   frontend_->OnSyncConfigureRetry();
 }
 
 void SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
     const syncer::WeakHandle<syncer::JsBackend> js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
-        debug_info_listener) {
+        debug_info_listener,
+    base::WeakPtr<syncer::SyncCore> sync_core) {

[Nicolas Zea, 2014/04/02 23:19:05]

What do you think about creating the SyncCoreProxy in the core on the sync
thread, and having it get posted back to the UI thread? That way the SyncCore
itself doesn't need to be passed around.

[rlarocque, 2014/04/03 01:03:46]

I think that's a good idea.  Done.

   DCHECK_EQ(base::MessageLoop::current(), frontend_loop_);
   if (!frontend_)
     return;
 
   initialized_ = true;
 
+  sync_core_proxy_.reset(
+      new syncer::SyncCoreProxy(
+          registrar_->sync_thread()->message_loop_proxy(),
+          sync_core));
+
   invalidator_->RegisterInvalidationHandler(this);
   invalidation_handler_registered_ = true;
 
   // Fake a state change to initialize the SyncManager's cached invalidator
   // state.
   OnInvalidatorStateChange(invalidator_->GetInvalidatorState());
 
   // Start forwarding refresh requests to the SyncManager
   notification_registrar_.Add(this, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
                               content::Source<Profile>(profile_));
@@ skipping 181 matching lines @@
 base::MessageLoop* SyncBackendHostImpl::GetSyncLoopForTesting() {
   return registrar_->sync_thread()->message_loop();
 }
 
 }  // namespace browser_sync
 
 #undef SDVLOG
 
 #undef SLOG