[Sync] Add support for performing a GetKey on startup.

sync/internal_api/sync_manager_impl.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/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 167 matching lines @@
             const scoped_refptr<base::TaskRunner>& blocking_task_runner,
             scoped_ptr<HttpPostProviderFactory> post_factory,
             const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
             const std::vector<syncer::ModelSafeWorker*>& workers,
             syncer::ExtensionsActivityMonitor*
                 extensions_activity_monitor,
             SyncManager::ChangeDelegate* change_delegate,
             const SyncCredentials& credentials,
             scoped_ptr<syncer::SyncNotifier> sync_notifier,
             const std::string& restored_key_for_bootstrapping,
+            bool keystore_encryption_enabled,
             SyncManager::TestingMode testing_mode,
             Encryptor* encryptor,
             UnrecoverableErrorHandler* unrecoverable_error_handler,
             ReportUnrecoverableErrorFunction
                 report_unrecoverable_error_function);
 
   // Sign into sync with given credentials.
   // We do not verify the tokens given. After this call, the tokens are set
   // and the sync DB is open. True if successful, false if something
   // went wrong.
@@ skipping 517 matching lines @@
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     scoped_ptr<HttpPostProviderFactory> post_factory,
     const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
     const std::vector<syncer::ModelSafeWorker*>& workers,
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     SyncManager::ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
     scoped_ptr<syncer::SyncNotifier> sync_notifier,
     const std::string& restored_key_for_bootstrapping,
+    bool keystore_encryption_enabled,
     SyncManager::TestingMode testing_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(post_factory.get());
   DVLOG(1) << "SyncManager starting Init...";
   std::string server_string(sync_server_and_path);
   return data_->Init(database_location,
                      event_handler,
                      server_string,
                      sync_server_port,
                      use_ssl,
                      blocking_task_runner,
                      post_factory.Pass(),
                      model_safe_routing_info,
                      workers,
                      extensions_activity_monitor,
                      change_delegate,
                      credentials,
                      sync_notifier.Pass(),
                      restored_key_for_bootstrapping,
+                     keystore_encryption_enabled,
                      testing_mode,
                      encryptor,
                      unrecoverable_error_handler,
                      report_unrecoverable_error_function);
 }
 
 void SyncManagerImpl::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCredentials(credentials);
 }
@@ skipping 88 matching lines @@
       DVLOG(1) << "Purging disabled types: "
                << ModelTypeSetToString(disabled_types);
       data_->directory()->PurgeEntriesWithTypeIn(disabled_types);
     }
   }
 
   // TODO(zea): set this based on whether cryptographer has keystore
   // encryption key or not (requires opening a transaction). crbug.com/129665.
   ConfigurationParams::KeystoreKeyStatus keystore_key_status =
       ConfigurationParams::KEYSTORE_KEY_UNNECESSARY;
+  if (data_->session_context() &&
+      data_->session_context()->keystore_encryption_enabled()) {
+    ReadTransaction trans(FROM_HERE, GetUserShare());
+    Cryptographer* cryptographer = trans.GetCryptographer();
+    keystore_key_status =
+        (cryptographer->HasKeystoreKey() ?
+         ConfigurationParams::KEYSTORE_KEY_UNNECESSARY :
+         ConfigurationParams::KEYSTORE_KEY_NEEDED);
+  }
 
   ConfigurationParams params(GetSourceFromReason(reason),
                              types_to_config,
                              new_routing_info,
                              keystore_key_status,
                              ready_task);
 
   if (!data_->scheduler()) {
     LOG(INFO)
         << "SyncManagerImpl::ConfigureSyncer: could not configure because "
@@ skipping 16 matching lines @@
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     scoped_ptr<HttpPostProviderFactory> post_factory,
     const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
     const std::vector<syncer::ModelSafeWorker*>& workers,
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     SyncManager::ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
     scoped_ptr<syncer::SyncNotifier> sync_notifier,
     const std::string& restored_key_for_bootstrapping,
+    bool keystore_encryption_enabled,
     SyncManager::TestingMode testing_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   CHECK(!initialized_);
 
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Starting SyncInternal initialization.";
 
@@ skipping 54 matching lines @@
     listeners.push_back(this);
     session_context_.reset(new SyncSessionContext(
         connection_manager_.get(),
         directory(),
         model_safe_routing_info,
         workers,
         extensions_activity_monitor,
         &throttled_data_type_tracker_,
         listeners,
         &debug_info_event_listener_,
-        &traffic_recorder_));
+        &traffic_recorder_,
+        keystore_encryption_enabled));
     session_context()->set_account_name(credentials.email);
     scheduler_.reset(new SyncScheduler(name_, session_context(), new Syncer()));
   }
 
   bool success = SignIn(credentials);
 
   if (success) {
     if (scheduler()) {
       scheduler()->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
     }
@@ skipping 1559 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer