Take 2: sync changes to support encryption

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2006-2008 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 "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_version_info.h"
@@ skipping 83 matching lines @@
       new PasswordModelWorker(
           profile_->GetPasswordStore(Profile::IMPLICIT_ACCESS));
 
   // Any datatypes that we want the syncer to pull down must
   // be in the routing_info map.  We set them to group passive, meaning that
   // updates will be applied, but not dispatched to the UI thread yet.
   for (syncable::ModelTypeSet::const_iterator it = types.begin();
       it != types.end(); ++it) {
     registrar_.routing_info[(*it)] = GROUP_PASSIVE;
   }
+  registrar_.routing_info[syncable::NIGORI] = GROUP_PASSIVE;
 
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoInitialize,
                         Core::DoInitializeOptions(
                             sync_service_url, true,
                             network_change_notifier_thread,
                             new HttpBridgeFactory(baseline_context_getter),
                             new HttpBridgeFactory(baseline_context_getter),
                             lsid,
                             delete_sync_data_folder,
                             invalidate_sync_login,
                             invalidate_sync_xmpp_login,
                             notification_method)));
 }
 
 void SyncBackendHost::Authenticate(const std::string& username,
                                    const std::string& password,
                                    const std::string& captcha) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoAuthenticate,
                         username, password, captcha));
 }
 
 void SyncBackendHost::StartSyncing() {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoStartSyncing));
 }
 
+void SyncBackendHost::SetPassphrase(const std::string& passphrase) {
+  core_thread_.message_loop()->PostTask(FROM_HERE,
+      NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoSetPassphrase,
+                        passphrase));
+}
+
 void SyncBackendHost::Shutdown(bool sync_disabled) {
   // Thread shutdown should occur in the following order:
   // - SyncerThread
   // - CoreThread
   // - UI Thread (stops some time after we return from this call).
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(),
                         &SyncBackendHost::Core::DoShutdown,
                         sync_disabled));
 
@@ skipping 126 matching lines @@
                                          NotificationService::AllSources(),
                                          NotificationService::NoDetails());
 }
 
 void SyncBackendHost::Core::NotifyResumed() {
   NotificationService::current()->Notify(NotificationType::SYNC_RESUMED,
                                          NotificationService::AllSources(),
                                          NotificationService::NoDetails());
 }
 
+void SyncBackendHost::Core::NotifyPassphraseRequired() {
+  NotificationService::current()->Notify(
+      NotificationType::SYNC_PASSPHRASE_REQUIRED,
+      NotificationService::AllSources(),
+      NotificationService::NoDetails());
+}
+
+void SyncBackendHost::Core::NotifyPassphraseAccepted() {
+  NotificationService::current()->Notify(
+      NotificationType::SYNC_PASSPHRASE_ACCEPTED,
+      NotificationService::AllSources(),
+      NotificationService::NoDetails());
+}
+
 SyncBackendHost::UserShareHandle SyncBackendHost::GetUserShareHandle() const {
   return core_->syncapi()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
   return core_->syncapi()->GetDetailedStatus();
 }
 
 SyncBackendHost::StatusSummary SyncBackendHost::GetStatusSummary() {
   return core_->syncapi()->GetStatusSummary();
@@ skipping 105 matching lines @@
                                            const std::string& captcha) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->Authenticate(username.c_str(), password.c_str(), captcha.c_str());
 }
 
 void SyncBackendHost::Core::DoStartSyncing() {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->StartSyncing();
 }
 
+void SyncBackendHost::Core::DoSetPassphrase(const std::string& passphrase) {
+  DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
+  syncapi_->SetPassphrase(passphrase);
+}
+
 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 123 matching lines @@
 
 
 void SyncBackendHost::Core::OnAuthError(const AuthError& auth_error) {
   // We could be on SyncEngine_AuthWatcherThread.  Post to our core loop so
   // we can modify state.
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::HandleAuthErrorEventOnFrontendLoop,
       auth_error));
 }
 
+void SyncBackendHost::Core::OnPassphraseRequired() {
+  host_->frontend_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &Core::NotifyPassphraseRequired));
+}
+
+void SyncBackendHost::Core::OnPassphraseAccepted() {
+  host_->frontend_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &Core::NotifyPassphraseAccepted));
+}
+
 void SyncBackendHost::Core::OnPaused() {
   host_->frontend_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyPaused));
 }
 
 void SyncBackendHost::Core::OnResumed() {
   host_->frontend_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyResumed));
@@ skipping 21 matching lines @@
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace browser_sync