[Sync] Initial support for encrypting any datatype (no UI hookup yet).

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2010 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 <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/command_line.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/sync/glue/database_model_worker.h"
 #include "chrome/browser/sync/glue/history_model_worker.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/http_bridge.h"
 #include "chrome/browser/sync/glue/password_model_worker.h"
 #include "chrome/browser/sync/js_arg_list.h"
 #include "chrome/browser/sync/sessions/session_state.h"
 // TODO(tim): Remove this! We should have a syncapi pass-thru instead.
 #include "chrome/browser/sync/syncable/directory_manager.h"  // Cryptographer.
 #include "chrome/browser/sync/syncable/model_type.h"
+#include "chrome/browser/sync/syncable/nigori_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "webkit/glue/webkit_glue.h"
 
 static const int kSaveChangesIntervalSeconds = 10;
 static const FilePath::CharType kSyncDataFolderName[] =
@@ skipping 75 matching lines @@
       it != types.end(); ++it) {
     registrar_.routing_info[(*it)] = GROUP_PASSIVE;
   }
 
   PasswordStore* password_store =
       profile_->GetPasswordStore(Profile::IMPLICIT_ACCESS);
   if (password_store) {
     registrar_.workers[GROUP_PASSWORD] =
         new PasswordModelWorker(password_store);
   } else {
-    LOG(WARNING) << "Password store not initialized, cannot sync passwords";
+    LOG_IF(WARNING, types.count(syncable::PASSWORDS) > 0) << "Password store "
+        << "not initialized, cannot sync passwords";
     registrar_.routing_info.erase(syncable::PASSWORDS);
   }
 
-  // TODO(tim): Remove this special case once NIGORI is populated by
-  // default.  We piggy back off of the passwords flag for now to not
-  // require both encryption and passwords flags.
-  bool enable_encryption = !CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableSyncPasswords) || types.count(syncable::PASSWORDS);
-  if (enable_encryption)
-    registrar_.routing_info[syncable::NIGORI] = GROUP_PASSIVE;
+  // Nigori is populated by default now.
+  registrar_.routing_info[syncable::NIGORI] = GROUP_PASSIVE;
 
   InitCore(Core::DoInitializeOptions(
       sync_service_url,
       MakeHttpBridgeFactory(baseline_context_getter),
       credentials,
       delete_sync_data_folder,
       notifier_options,
       RestoreEncryptionBootstrapToken(),
       false));
 }
@@ skipping 251 matching lines @@
   // downloading updates for newly added data types.  Once this is
   // complete, the configure_ready_task_ is run via an
   // OnInitializationComplete notification.
   if (deleted_type || !core_->syncapi()->InitialSyncEndedForAllEnabledTypes()) {
     // We can only nudge when we've either deleted a dataype or added one, else
     // we break all the profile sync unit tests.
     RequestNudge();
   }
 }
 
+void SyncBackendHost::EncryptDataTypes(
+    const syncable::ModelTypeSet& encrypted_types) {
+  core_thread_.message_loop()->PostTask(FROM_HERE,
+     NewRunnableMethod(core_.get(),
+                       &SyncBackendHost::Core::DoEncryptDataTypes,
+                       encrypted_types));
+}
+
 void SyncBackendHost::RequestNudge() {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoRequestNudge));
 }
 
 void SyncBackendHost::ActivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   base::AutoLock lock(registrar_lock_);
 
@@ skipping 84 matching lines @@
   if (!host_)
     return;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TokenAvailableDetails details(GaiaConstants::kSyncService, token);
   NotificationService::current()->Notify(
       NotificationType::TOKEN_UPDATED,
       NotificationService::AllSources(),
       Details<const TokenAvailableDetails>(&details));
 }
 
+void SyncBackendHost::Core::NotifyEncryptionComplete(
+    const syncable::ModelTypeSet& encrypted_types) {
+  if (!host_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
+  host_->frontend_->OnEncryptionComplete(encrypted_types);
+}
+
 SyncBackendHost::Core::DoInitializeOptions::DoInitializeOptions(
     const GURL& service_url,
     sync_api::HttpPostProviderFactory* http_bridge_factory,
     const sync_api::SyncCredentials& credentials,
     bool delete_sync_data_folder,
     const notifier::NotifierOptions& notifier_options,
     std::string restored_key_for_bootstrapping,
     bool setup_for_test_mode)
     : service_url(service_url),
       http_bridge_factory(http_bridge_factory),
@@ skipping 138 matching lines @@
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->StartSyncing();
 }
 
 void SyncBackendHost::Core::DoSetPassphrase(const std::string& passphrase,
                                             bool is_explicit) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->SetPassphrase(passphrase, is_explicit);
 }
 
+void SyncBackendHost::Core::DoEncryptDataTypes(
+    const syncable::ModelTypeSet& encrypted_types) {
+  DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
+  syncapi_->EncryptDataTypes(encrypted_types);
+}
+
 UIModelWorker* SyncBackendHost::ui_worker() {
   ModelSafeWorker* w = registrar_.workers[GROUP_UI];
   if (w == NULL)
     return NULL;
   if (w->GetModelSafeGroup() != GROUP_UI)
     NOTREACHED();
   return static_cast<UIModelWorker*>(w);
 }
 
 void SyncBackendHost::Core::DoShutdown(bool sync_disabled) {
@@ skipping 199 matching lines @@
 void SyncBackendHost::Core::OnClearServerDataSucceeded() {
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleClearServerDataSucceededOnFrontendLoop));
 }
 
 void SyncBackendHost::Core::OnClearServerDataFailed() {
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleClearServerDataFailedOnFrontendLoop));
 }
 
+void SyncBackendHost::Core::OnEncryptionComplete(
+    const syncable::ModelTypeSet& encrypted_types) {
+  host_->frontend_loop_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &Core::NotifyEncryptionComplete,
+                        encrypted_types));
+}
+
 void SyncBackendHost::Core::RouteJsEvent(
     const std::string& name, const JsArgList& args,
     const JsEventHandler* target) {
   host_->frontend_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(
           this, &Core::RouteJsEventOnFrontendLoop, name, args, target));
 }
 
 void SyncBackendHost::Core::HandleStopSyncingPermanentlyOnFrontendLoop() {
   if (!host_ || !host_->frontend_)
@@ skipping 126 matching lines @@
 }
 
 void SyncBackendHost::Core::DoProcessMessage(
     const std::string& name, const JsArgList& args,
     const JsEventHandler* sender) {
   DCHECK_EQ(MessageLoop::current(), host_->core_thread_.message_loop());
   syncapi_->GetJsBackend()->ProcessMessage(name, args, sender);
 }
 
 }  // namespace browser_sync