[Sync] Cache encrypted types info in ProfileSyncService

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2011 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 287 matching lines @@
   sync_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       core_.get(), &SyncBackendHost::Core::DoStartConfiguration, callback));
 }
 
 void SyncBackendHost::EnableEncryptEverything() {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
      NewRunnableMethod(core_.get(),
                        &SyncBackendHost::Core::DoEnableEncryptEverything));
 }
 
-bool SyncBackendHost::EncryptEverythingEnabled() const {
-  if (initialization_state_ <= NOT_INITIALIZED) {
-    NOTREACHED() << "Cannot check encryption status without first "
-                 << "initializing backend.";
-    return false;
-  }
-  return core_->sync_manager()->EncryptEverythingEnabled();
-}
-
-syncable::ModelTypeSet SyncBackendHost::GetEncryptedDataTypes() const {
-  DCHECK_GT(initialization_state_, NOT_INITIALIZED);
-  return core_->sync_manager()->GetEncryptedDataTypes();
-}
-
 void SyncBackendHost::ActivateDataType(
     syncable::ModelType type, ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
 void SyncBackendHost::DeactivateDataType(syncable::ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
@@ skipping 164 matching lines @@
 }
 
 void SyncBackendHost::Core::OnClearServerDataSucceeded() {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleClearServerDataSucceededOnFrontendLoop));
 }
 
-void SyncBackendHost::Core::OnEncryptionComplete(
-    const syncable::ModelTypeSet& encrypted_types) {
+void SyncBackendHost::Core::OnEncryptedTypesChanged(
+    const syncable::ModelTypeSet& encrypted_types,
+    bool encrypt_everything) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  // NOTE: We're in a transaction.
   host_->frontend_loop_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &Core::NotifyEncryptionComplete,
-                        encrypted_types));
+      base::Bind(&Core::NotifyEncryptedTypesChanged, this,
+                 encrypted_types, encrypt_everything));
+}
+
+void SyncBackendHost::Core::OnEncryptionComplete() {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  // NOTE: We're in a transaction.
+  host_->frontend_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&Core::NotifyEncryptionComplete, this));
 }
 
 void SyncBackendHost::Core::OnActionableError(
     const browser_sync::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::HandleActionableErrorEventOnFrontendLoop,
@@ skipping 262 matching lines @@
   if (!host_)
     return;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TokenAvailableDetails details(GaiaConstants::kSyncService, token);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_UPDATED,
       content::Source<Profile>(host_->profile_),
       content::Details<const TokenAvailableDetails>(&details));
 }
 
-void SyncBackendHost::Core::NotifyEncryptionComplete(
-    const syncable::ModelTypeSet& encrypted_types) {
+void SyncBackendHost::Core::NotifyEncryptedTypesChanged(
+    const syncable::ModelTypeSet& encrypted_types,
+    bool encrypt_everything) {
   if (!host_)
     return;
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
-  host_->frontend_->OnEncryptionComplete(encrypted_types);
+  host_->frontend_->OnEncryptedTypesChanged(
+      encrypted_types, encrypt_everything);
+}
+
+void SyncBackendHost::Core::NotifyEncryptionComplete() {
+  if (!host_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
+  host_->frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHost::Core::HandleSyncCycleCompletedOnFrontendLoop(
     SyncSessionSnapshot* snapshot) {
   if (!host_ || !host_->frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
   host_->last_snapshot_.reset(snapshot);
 
@@ skipping 100 matching lines @@
           syncable::ModelTypeSet(),
           sync_api::CONFIGURE_REASON_NEW_CLIENT,
           base::Bind(
               &SyncBackendHost::Core::
                   HandleInitializationCompletedOnFrontendLoop,
               core_.get(), js_backend),
           true);
       break;
     case DOWNLOADING_NIGORI:
       initialization_state_ = REFRESHING_ENCRYPTION;
+      // Triggers OnEncryptedTypesChanged() and OnEncryptionComplete()
+      // if necessary.
       RefreshEncryption(
           base::Bind(
               &SyncBackendHost::Core::
                   HandleInitializationCompletedOnFrontendLoop,
               core_.get(), js_backend, true));
       break;
     case REFRESHING_ENCRYPTION:
       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
@@ skipping 111 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshEncryption,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync