FYI: Control Data + Per-Device Metadata

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 135 matching lines @@
   void DoSetEncryptionPassphrase(const std::string& passphrase,
                                  bool is_explicit);
 
   // Called to decrypt the pending keys.
   void DoSetDecryptionPassphrase(const std::string& passphrase);
 
   // Called to turn on encryption of all sync data as well as
   // reencrypt everything.
   void DoEnableEncryptEverything();
 
-  // Called to refresh encryption with the most recent passphrase
-  // and set of encrypted types. Also adds device information to the nigori
-  // node. |done_callback| is called on the sync thread.
-  void DoRefreshNigori(const base::Closure& done_callback);
+  // Called to perform tasks which require the metadata to be present, including
+  // refreshing encryption with the most passphrase and requested types an
+  // updating device information.
+  void DoInitialProcessMetadata(const base::Closure& done_callback);
 
   // The shutdown order is a bit complicated:
   // 1) From |sync_thread_|, invoke the syncapi Shutdown call to do
   //    a final SaveChanges, and close sqlite handles.
   // 2) Then, from |frontend_loop_|, halt the sync_thread_ (which is
   //    a blocking call). This causes syncapi thread-exit handlers
   //    to run and make use of cached pointers to various components
   //    owned implicitly by us.
   // 3) Destroy this Core. That will delete syncapi components in a
   //    safe order because the thread that was using them has exited
@@ skipping 454 matching lines @@
 
   registrar_.reset();
   chrome_sync_notification_bridge_.reset();
   core_ = NULL;  // Releases reference to core_.
 }
 
 void SyncBackendHost::ConfigureDataTypes(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet types_to_add,
     syncer::ModelTypeSet types_to_remove,
-    NigoriState nigori_state,
     const base::Callback<void(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 SyncBackendHost 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
   // never send a new configure request until the current request succeeds.
 
   DCHECK_GT(initialization_state_, NOT_INITIALIZED);
 
-  syncer::ModelTypeSet types_to_add_with_nigori = types_to_add;
-  syncer::ModelTypeSet types_to_remove_with_nigori = types_to_remove;
-  if (nigori_state == WITH_NIGORI) {
-    types_to_add_with_nigori.Put(syncer::NIGORI);
-    types_to_remove_with_nigori.Remove(syncer::NIGORI);
-  } else {
-    types_to_add_with_nigori.Remove(syncer::NIGORI);
-    types_to_remove_with_nigori.Put(syncer::NIGORI);
-  }
-
   // The SyncBackendRegistrar's routing info will be updated by adding the
-  // types_to_add_with_nigori to the list then removing
-  // types_to_remove_with_nigori.  Any types which are not in either of those
-  // sets will remain untouched.
+  // types_to_add to the list then removing types_to_remove.  Any types which
+  // are not in either of those sets will remain untouched.
   //
   // Types which were not in the list previously are not fully downloaded, so we
   // must ask the syncer to download them.  Any newly supported datatypes will
   // not have been in that routing info list, so they will be among the types
   // downloaded if they are enabled.
   //
   // The SyncBackendRegistrar's state was initially derived from the types
   // marked initial_sync_ended when the sync database was loaded.  Afterwards it
   // is modified only by this function.  We expect it to remain in sync with the
   // backend because configuration requests are never aborted; they are retried
   // until they succeed or the browser is closed.
 
   syncer::ModelTypeSet types_to_download = registrar_->ConfigureDataTypes(
-      types_to_add_with_nigori, types_to_remove_with_nigori);
+      types_to_add, types_to_remove);
   if (!types_to_download.Empty())
     types_to_download.Put(syncer::NIGORI);
 
   // TODO(sync): crbug.com/137550.
   // It's dangerous to configure types that have progress markers.  Types with
   // progress markers can trigger a MIGRATION_DONE response.  We are not
   // prepared to handle a migration during a configure, so we must ensure that
   // all our types_to_download actually contain no data before we sync them.
   //
   // The most common way to end up in this situation used to be types which had
@@ skipping 473 matching lines @@
     const std::string& passphrase) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->SetDecryptionPassphrase(passphrase);
 }
 
 void SyncBackendHost::Core::DoEnableEncryptEverything() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->EnableEncryptEverything();
 }
 
-void SyncBackendHost::Core::DoRefreshNigori(
+void SyncBackendHost::Core::DoInitialProcessMetadata(
     const base::Closure& done_callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   chrome::VersionInfo version_info;
-  sync_manager_->RefreshNigori(version_info.CreateVersionString(),
-                               done_callback);
+  sync_manager_->InitialProcessMetadata(version_info.CreateVersionString(),
+                                        done_callback);
 }
 
 void SyncBackendHost::Core::DoStopSyncManagerForShutdown(
     const base::Closure& closure) {
   if (sync_manager_.get()) {
     sync_manager_->StopSyncingForShutdown(closure);
   } else {
     sync_loop_->PostTask(FROM_HERE, closure);
   }
 }
@@ skipping 136 matching lines @@
 
   // Run initialization state machine.
   switch (initialization_state_) {
     case NOT_INITIALIZED:
       // This configuration should result in a download request if the nigori
       // type's initial_sync_ended bit is unset.  If the download request
       // contains progress markers, there is a risk that the server will try to
       // trigger migration.  That would be disastrous, so we must rely on the
       // sync manager to ensure that this type never has both progress markers
       // and !initial_sync_ended.
-      initialization_state_ = DOWNLOADING_NIGORI;
+      initialization_state_ = DOWNLOADING_METADATA;
       ConfigureDataTypes(
           syncer::CONFIGURE_REASON_NEW_CLIENT,
+          syncer::ModelTypeSet(syncer::ControlTypes()),

[rlarocque, 2012/08/11 01:31:52]

ControlTypes was intended to be a group of types that do not undergo regular
update application and conflict resolution.  All currently defined control types
are expected to be downloaded early, but there's no guarantee that will always
be the case.  Maybe I should define a separate group, the EarlyDownloadTypes(),
which are independent from the control types.

           syncer::ModelTypeSet(),
-          syncer::ModelTypeSet(),
-          WITH_NIGORI,
           // Calls back into this function.
           base::Bind(
               &SyncBackendHost::
                   HandleNigoriConfigurationCompletedOnFrontendLoop,
               weak_ptr_factory_.GetWeakPtr(), js_backend),
           base::Bind(&SyncBackendHost::OnNigoriDownloadRetry,
                      weak_ptr_factory_.GetWeakPtr()));
       break;
-    case DOWNLOADING_NIGORI:
-      initialization_state_ = REFRESHING_NIGORI;
-      // Triggers OnEncryptedTypesChanged() and OnEncryptionComplete()
-      // if necessary.
-      RefreshNigori(
+    case DOWNLOADING_METADATA:
+      initialization_state_ = PROCESSING_METADATA;
+      // Updates encryption and other metadata.  Will call
+      // OnEncryptedTypesChanged() and OnEncryptionComplete() if necessary.
+      InitialProcessMetadata(
           base::Bind(
               &SyncBackendHost::
                   HandleInitializationCompletedOnFrontendLoop,
               weak_ptr_factory_.GetWeakPtr(), js_backend, true));
       break;
-    case REFRESHING_NIGORI:
+    case PROCESSING_METADATA:
       initialization_state_ = INITIALIZED;
       // Now that we've downloaded the nigori node, we can see if there are any
       // experimental types to enable. This should be done before we inform
       // the frontend to ensure they're visible in the customize screen.
       AddExperimentalTypes();
       frontend_->OnBackendInitialized(js_backend, true);
       break;
     default:
       NOTREACHED();
   }
@@ skipping 163 matching lines @@
 
 // Needed because MessageLoop::PostTask is overloaded.
 void PostClosure(MessageLoop* message_loop,
                  const tracked_objects::Location& from_here,
                  const base::Closure& callback) {
   message_loop->PostTask(from_here, callback);
 }
 
 }  // namespace
 
-void SyncBackendHost::RefreshNigori(const base::Closure& done_callback) {
+void SyncBackendHost::InitialProcessMetadata(
+    const base::Closure& done_callback) {
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   base::Closure sync_thread_done_callback =
       base::Bind(&PostClosure,
                  MessageLoop::current(), FROM_HERE, done_callback);
   sync_thread_.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
+      base::Bind(&SyncBackendHost::Core::DoInitialProcessMetadata,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync