[Sync] Persist keystore key across restarts

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 360 matching lines @@
       &extensions_activity_monitor_,
       event_handler,
       sync_service_url,
       base::Bind(&MakeHttpBridgeFactory,
                  make_scoped_refptr(profile_->GetRequestContext())),
       credentials,
       &chrome_sync_notification_bridge_,
       &sync_notifier_factory_,
       delete_sync_data_folder,
       sync_prefs_->GetEncryptionBootstrapToken(),
+      sync_prefs_->GetKeystoreEncryptionBootstrapToken(),
       sync_api::SyncManager::NON_TEST,
       unrecoverable_error_handler,
       report_unrecoverable_error_function));
 }
 
 void SyncBackendHost::UpdateCredentials(const SyncCredentials& credentials) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoUpdateCredentials, core_.get(),
                  credentials));
 }
@@ skipping 322 matching lines @@
        base::Bind(&SyncBackendHost::Core::DoConfigureSyncer,
                   core_.get(),
                   reason,
                   types_to_config,
                   routing_info,
                   ready_task,
                   retry_callback));
 }
 
 void SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop(
+    const std::string& keystore_bootstrap_token,

[rlarocque, 2012/06/13 23:35:04]

Is it really necessary to send the token back on every call to
FinishConfigureDataTypesOnFrontendLoop()?

If the value is not going to change, could we pass it back in some other way? 
Maybe a 'HandleGetKeyReponseOnFrontendLoop()'?

[Nicolas Zea, 2012/06/15 00:42:07]

Yeah, I guess the bootstrap token doesn't really relate to configuring
datatypes. I've gone ahead and changed this to reuse the PersistEncryptionToken
method and key off the last_get_key_result being successful in
OnSyncCycleCompleted.

[rlarocque, 2012/06/15 19:02:00]

I'm not sure that's much better.  Wouldn't it make more sense to only update it
when it changes, as is the case with the bootstrap token?

[Nicolas Zea, 2012/06/15 20:15:30]

This is effectively the same logic used in the bootstrap token, i.e. any time we
successfully set a passphrase we update the bootstrap token (even if it didn't
change). We don't have any logic comparing the already persisted token and the
new one; the pref service does that for you (it checks to see if the new pref is
different or not). I don't see why we should duplicate that logic.

Note also that we'll only ever perform a GetKey if we didn't have a valid key in
the first place. In other words, if the GetKey succeeded, it means we're writing
a new key anyways (barring those cases where the getkey succeeds but the
download updates fails, but that goes back to the pref service only persisting
new strings).

     const syncable::ModelTypeSet& types_to_configure,
     const syncable::ModelTypeSet& configured_types,
     const base::Callback<void(syncable::ModelTypeSet)>& ready_task) {
   const syncable::ModelTypeSet failed_configuration_types =
       Difference(types_to_configure, configured_types);
   SDVLOG(1)
       << "Added types: "
       << syncable::ModelTypeSetToString(types_to_configure)
       << ", configured types: "
       << syncable::ModelTypeSetToString(configured_types)
       << ", failed configuration types: "
       << syncable::ModelTypeSetToString(failed_configuration_types);
 
   // Update |chrome_sync_notification_bridge_|'s enabled types here as it has
   // to happen on the UI thread.
   chrome_sync_notification_bridge_.UpdateEnabledTypes(configured_types);
 
   // Notify SyncManager (especially the notification listener) about new types.
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoUpdateEnabledTypes, core_.get(),
                  configured_types));
 
+  if (!keystore_bootstrap_token.empty()) {
+    DVLOG(1) << "Persisting keystore encryption bootstrap token.";
+    sync_prefs_->SetKeystoreEncryptionBootstrapToken(keystore_bootstrap_token);
+  }
+
   if (!ready_task.is_null())
     ready_task.Run(failed_configuration_types);
 }
 
 SyncBackendHost::DoInitializeOptions::DoInitializeOptions(
     MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
     const ModelSafeRoutingInfo& routing_info,
     const std::vector<ModelSafeWorker*>& workers,
     ExtensionsActivityMonitor* extensions_activity_monitor,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& service_url,
     MakeHttpBridgeFactoryFn make_http_bridge_factory_fn,
     const sync_api::SyncCredentials& credentials,
     ChromeSyncNotificationBridge* chrome_sync_notification_bridge,
     sync_notifier::SyncNotifierFactory* sync_notifier_factory,
     bool delete_sync_data_folder,
     const std::string& restored_key_for_bootstrapping,
+    const std::string& restored_keystore_key_for_bootstrapping,
     sync_api::SyncManager::TestingMode testing_mode,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function)
     : sync_loop(sync_loop),
       registrar(registrar),
       routing_info(routing_info),
       workers(workers),
       extensions_activity_monitor(extensions_activity_monitor),
       event_handler(event_handler),
       service_url(service_url),
       make_http_bridge_factory_fn(make_http_bridge_factory_fn),
       credentials(credentials),
       chrome_sync_notification_bridge(chrome_sync_notification_bridge),
       sync_notifier_factory(sync_notifier_factory),
       delete_sync_data_folder(delete_sync_data_folder),
       restored_key_for_bootstrapping(restored_key_for_bootstrapping),
+      restored_keystore_key_for_bootstrapping(
+          restored_keystore_key_for_bootstrapping),
       testing_mode(testing_mode),
       unrecoverable_error_handler(unrecoverable_error_handler),
       report_unrecoverable_error_function(
           report_unrecoverable_error_function) {
 }
 
 SyncBackendHost::DoInitializeOptions::~DoInitializeOptions() {}
 
 SyncBackendHost::Core::Core(const std::string& name,
                             const FilePath& sync_data_folder_path,
@@ skipping 214 matching lines @@
       options.routing_info,
       options.workers,
       options.extensions_activity_monitor,
       options.registrar /* as SyncManager::ChangeDelegate */,
       MakeUserAgentForSyncApi(),
       options.credentials,
       new BridgedSyncNotifier(
           options.chrome_sync_notification_bridge,
           options.sync_notifier_factory->CreateSyncNotifier()),
       options.restored_key_for_bootstrapping,
+      options.restored_keystore_key_for_bootstrapping,
       CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kSyncKeystoreEncryption),
       options.testing_mode,
       &encryptor_,
       options.unrecoverable_error_handler,
       options.report_unrecoverable_error_function);
   LOG_IF(ERROR, !success) << "Syncapi initialization failed!";
 
   // Now check the command line to see if we need to simulate an
   // unrecoverable error for testing purpose. Note the error is thrown
@@ skipping 101 matching lines @@
                  retry_callback));
 }
 
 void SyncBackendHost::Core::DoFinishConfigureDataTypes(
     syncable::ModelTypeSet types_to_config,
     const base::Callback<void(syncable::ModelTypeSet)>& ready_task) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   syncable::ModelTypeSet configured_types =
       sync_manager_->InitialSyncEndedTypes();
   configured_types.RetainAll(types_to_config);
+
+  std::string keystore_token;
+  sync_manager_->GetKeystoreKeyBootstrapToken(&keystore_token);
+
   host_.Call(FROM_HERE,
              &SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop,
+             keystore_token,
              types_to_config,
              configured_types,
              ready_task);
 }
 
 void SyncBackendHost::Core::DoRetryConfiguration(
     const base::Closure& retry_callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::RetryConfigurationOnFrontendLoop,
@@ skipping 261 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync