[Sync] Cache encrypted types info in ProfileSyncService

chrome/browser/sync/profile_sync_service.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 "chrome/browser/sync/profile_sync_service.h"
 
 #include <algorithm>
 #include <cstddef>
 #include <map>
 #include <set>
@@ skipping 93 matching lines @@
       cros_user_(cros_user),
       sync_service_url_(kDevServerUrl),
       backend_initialized_(false),
       is_auth_in_progress_(false),
       wizard_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       signin_(signin_manager),
       unrecoverable_error_detected_(false),
       scoped_runnable_method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       expect_sync_configuration_aborted_(false),
       clear_server_data_state_(CLEAR_NOT_STARTED),
+      encrypted_types_(browser_sync::Cryptographer::SensitiveTypes()),
+      encrypt_everything_(false),
       encryption_pending_(false),
       auto_start_enabled_(false),
       failed_datatypes_handler_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   // By default, dev, canary, and unbranded Chromium users will go to the
   // development servers. Development servers have more features than standard
   // sync servers. Users with officially-branded Chrome stable and beta builds
   // will go to the standard sync servers.
   //
   // GetChannel hits the registry on Windows. See http://crbug.com/70380.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
@@ skipping 292 matching lines @@
   }
 
   scoped_runnable_method_factory_.RevokeAll();
 
   // Clear various flags.
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
   cached_passphrases_ = CachedPassphrases();
   encryption_pending_ = false;
+  encrypt_everything_ = false;
+  encrypted_types_ = browser_sync::Cryptographer::SensitiveTypes();
   passphrase_required_reason_ = sync_api::REASON_PASSPHRASE_NOT_REQUIRED;
   last_attempted_user_email_.clear();
   last_auth_error_ = GoogleServiceAuthError::None();
 
   if (sync_global_error_.get()) {
     GlobalErrorServiceFactory::GetForProfile(profile_)->RemoveGlobalError(
         sync_global_error_.get());
     RemoveObserver(sync_global_error_.get());
     sync_global_error_.reset(NULL);
   }
@@ skipping 391 matching lines @@
   // If No encryption is pending and our passphrase has been accepted, tell the
   // wizard we're done (no need to hang around waiting for the sync to
   // complete). If encryption is pending, its successful completion will trigger
   // the done step.
   if (WizardIsVisible() && !encryption_pending())
     wizard_.Step(SyncSetupWizard::DONE);
 
   NotifyObservers();
 }
 
-void ProfileSyncService::OnEncryptionComplete(
-    const syncable::ModelTypeSet& encrypted_types) {
+void ProfileSyncService::OnEncryptedTypesChanged(
+    const syncable::ModelTypeSet& encrypted_types,
+    bool encrypt_everything) {
+  encrypted_types_ = encrypted_types;
+  encrypt_everything_ = encrypt_everything;
+  VLOG(2) << "Encrypted types changed to "

[Nicolas Zea, 2011/10/21 14:29:07]

Since these now happen relatively rarely, I'd prefer VLOG(1) for this and
encryption complete.

[akalin, 2011/10/22 03:28:38]

Done.

+          << syncable::ModelTypeSetToString(encrypted_types_)
+          << " (encrypt everything is set to "
+          << (encrypt_everything_ ? "true" : "false") << ")";
+  DCHECK_GT(encrypted_types_.count(syncable::PASSWORDS), 0u);
+}
+
+void ProfileSyncService::OnEncryptionComplete() {
+  VLOG(2) << "Encryption complete for "
+          << syncable::ModelTypeSetToString(encrypted_types_);
+  DCHECK_GT(encrypted_types_.count(syncable::PASSWORDS), 0u);
   if (encryption_pending_) {
     syncable::ModelTypeSet registered_types;
     GetRegisteredDataTypes(&registered_types);
     bool encryption_complete = true;
     for (syncable::ModelTypeSet::const_iterator it = registered_types.begin();

[Nicolas Zea, 2011/10/21 14:29:07]

I think now that we're receiving the encrypt_everything value in
OnEncryptedTypesChanged, we can key of that instead of doing this comparison. If
encryption_pending_ is true, we're waiting until encrypt_everything becomes
true. Once that is true, we can be sure all registered types will have been
encrypted (ReEncryptEverything will always get the current set of encrypted
types and encrypt all registered types).

[akalin, 2011/10/22 03:28:38]

Yeah.  But we still need to wait for encryption to finish, right?  I implemented
that.

          it != registered_types.end();
          ++it) {
-      if (encrypted_types.count(*it) == 0) {
+      if (encrypted_types_.count(*it) == 0) {
         // One of our types is not yet encrypted - keep waiting.
         encryption_complete = false;
         break;
       }
     }
     if (encryption_complete) {
       encryption_pending_ = false;
       // The user had chosen to encrypt datatypes. This is the last thing to
       // complete, so now that we're done notify the UI.
       wizard_.Step(SyncSetupWizard::DONE);
+      // This is to nudge the integration tests when encryption is
+      // finished.
+      NotifyObservers();
     }
   }
-  NotifyObservers();
 }
 
 void ProfileSyncService::OnMigrationNeededForTypes(
     const syncable::ModelTypeSet& types) {
   DCHECK(backend_initialized_);
   DCHECK(data_type_manager_.get());
 
   // Migrator must be valid, because we don't sync until it is created and this
   // callback originates from a sync cycle.
   migrator_->MigrateTypes(types);
@@ skipping 443 matching lines @@
   } else {
     if (is_explicit) {
       cached_passphrases_.explicit_passphrase = passphrase;
     } else {
       cached_passphrases_.gaia_passphrase = passphrase;
     }
   }
 }
 
 void ProfileSyncService::SetEncryptEverything(bool encrypt_everything) {
+  // We may be called during the setup process before we're

[Nicolas Zea, 2011/10/21 14:29:07]

I understand GetEncryptedTypes being called by the UI, but SetEncryptEverything
is only called once we're already configuring, which is dependent on having been
initialized (OnBackendInitialized triggers the Step(SYNC_EVERYTHING)), so I
don't think this holds true.

[akalin, 2011/10/22 03:28:38]

Called by some unittests; see comment. :/

+  // initialized.
   encryption_pending_ = encrypt_everything;
+  // Callers shouldn't try to disable encrypt everything once it has
+  // already succeeded.
+  DCHECK(!encrypt_everything_);
 }
 
 bool ProfileSyncService::encryption_pending() const {
+  // We may be called during the setup process before we're
+  // initialized.

[Nicolas Zea, 2011/10/21 14:29:07]

Comment that this is because it's used by IsEncryptedDatatypeEnabled, which is
itself used by IsPassphraseRequiredForDecryption. :-/

[akalin, 2011/10/22 03:28:38]

Done.

   return encryption_pending_;
 }
 
 bool ProfileSyncService::EncryptEverythingEnabled() const {
-  if (!backend_.get() || !backend_initialized_) {
-    NOTREACHED() << "Cannot check encryption without initialized backend.";
-    return false;
-  }
-  return backend_->EncryptEverythingEnabled();
+  DCHECK(backend_initialized_);
+  return encrypt_everything_;
 }
 
-// This will open a transaction to get the encrypted types. Do not call this
-// if you already have a transaction open.
 void ProfileSyncService::GetEncryptedDataTypes(
     syncable::ModelTypeSet* encrypted_types) const {
   CHECK(encrypted_types);
-  if (backend_.get()) {
-    *encrypted_types = backend_->GetEncryptedDataTypes();
-    DCHECK(encrypted_types->count(syncable::PASSWORDS));
-  } else {
-    // Either we are in an unrecoverable error or the sync is not yet done
-    // initializing. In either case just return the sensitive types. During
-    // sync initialization the UI might need to know what our encrypted
-    // types are.
-    *encrypted_types = browser_sync::Cryptographer::SensitiveTypes();
-    DCHECK(encrypted_types->count(syncable::PASSWORDS));
-  }
+  // We may be called during the setup process before we're
+  // initialized.

[Nicolas Zea, 2011/10/21 14:29:07]

Add something like "In this case, we'll default to the sensitive types."

[akalin, 2011/10/22 03:28:38]

Done.

+  *encrypted_types = encrypted_types_;
+  DCHECK_GT(encrypted_types->count(syncable::PASSWORDS), 0u);
 }
 
 void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) {
   NotifyObservers();
   if (is_sync_managed) {
     DisableForUser();
   } else if (HasSyncSetupCompleted() && AreCredentialsAvailable()) {
     StartUp();
   }
 }
@@ skipping 166 matching lines @@
             << "Unrecoverable error.";
   } else {
     VLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
             << "initialized";
   }
 }
 
 const FailedDatatypesHandler& ProfileSyncService::failed_datatypes_handler() {
   return failed_datatypes_handler_;
 }