[Sync] Cache encrypted types info in ProfileSyncService

chrome/browser/sync/util/cryptographer.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 "base/base64.h"
 #include "chrome/browser/sync/util/cryptographer.h"
 #include "chrome/browser/password_manager/encryptor.h"
 
 namespace browser_sync {
 
 const char kNigoriTag[] = "google_chrome_nigori";
 
 // We name a particular Nigori instance (ie. a triplet consisting of a hostname,
 // a username, and a password) by calling Permute on this string. Since the
 // output of Permute is always the same for a given triplet, clients will always
 // assign the same name to a particular triplet.
 const char kNigoriKeyName[] = "nigori-key";
 
+Cryptographer::Observer::~Observer() {}
+
 Cryptographer::Cryptographer()
     : default_nigori_(NULL),
       encrypt_everything_(false) {
   syncable::ModelTypeSet sensitive_types = SensitiveTypes();
   encrypted_types_.insert(sensitive_types.begin(), sensitive_types.end());
 }
 
 Cryptographer::~Cryptographer() {}
 
+void Cryptographer::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void Cryptographer::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void Cryptographer::Bootstrap(const std::string& restored_bootstrap_token) {
   if (is_initialized()) {
     NOTREACHED();
     return;
   }
 
   scoped_ptr<Nigori> nigori(UnpackBootstrapToken(restored_bootstrap_token));
   if (nigori.get())
     AddKeyImpl(nigori.release());
 }
@@ skipping 267 matching lines @@
     encrypted_types_.insert(syncable::APP_NOTIFICATIONS);
 
   // Note: the initial version with encryption did not support the
   // encrypt_everything field. If anything more than the sensitive types were
   // encrypted, it meant we were encrypting everything.
   syncable::ModelTypeSet sensitive_types = SensitiveTypes();
   encrypted_types_.insert(sensitive_types.begin(), sensitive_types.end());
   if (!nigori.has_encrypt_everything() &&
       encrypted_types_.size() > sensitive_types.size()) {
     set_encrypt_everything();
+    return;
   }
+
+  EmitEncryptedTypesChangeNotification();

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

Perhaps only emit if the types actually changed? (add and compare against
old_encrypted_types) This applies to here and in set_encrypt_everything and
SetEncryptedTypes

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

Done.

 }
 
 void Cryptographer::UpdateNigoriFromEncryptedTypes(
     sync_pb::NigoriSpecifics* nigori) const {
   nigori->set_encrypt_everything(encrypt_everything_);
   nigori->set_encrypt_bookmarks(
       encrypted_types_.count(syncable::BOOKMARKS) > 0);
   nigori->set_encrypt_preferences(
       encrypted_types_.count(syncable::PREFERENCES) > 0);
   nigori->set_encrypt_autofill_profile(
@@ skipping 10 matching lines @@
       encrypted_types_.count(syncable::SEARCH_ENGINES) > 0);
   nigori->set_encrypt_sessions(encrypted_types_.count(syncable::SESSIONS) > 0);
   nigori->set_encrypt_apps(encrypted_types_.count(syncable::APPS) > 0);
   nigori->set_encrypt_app_notifications(
       encrypted_types_.count(syncable::APP_NOTIFICATIONS) > 0);
 }
 
 void Cryptographer::set_encrypt_everything() {
   encrypt_everything_ = true;
   encrypted_types_ = syncable::GetAllRealModelTypes();
+  EmitEncryptedTypesChangeNotification();
 }
 
 bool Cryptographer::encrypt_everything() const {
   return encrypt_everything_;
 }
 
 void Cryptographer::SetEncryptedTypes(syncable::ModelTypeSet new_types) {
   encrypted_types_.insert(new_types.begin(), new_types.end());
+  EmitEncryptedTypesChangeNotification();
 }
 
 syncable::ModelTypeSet Cryptographer::GetEncryptedTypes() const {
   return encrypted_types_;
 }
 
+void Cryptographer::MarkEncryptionComplete() {
+  EmitEncryptedTypesChangeNotification();
+  FOR_EACH_OBSERVER(Observer, observers_, OnEncryptionComplete());
+}
+
+void Cryptographer::EmitEncryptedTypesChangeNotification() {
+  FOR_EACH_OBSERVER(
+      Observer, observers_,
+      OnEncryptedTypesChanged(encrypted_types_, encrypt_everything_));
+}
+
 void Cryptographer::InstallKeys(const std::string& default_key_name,
                                 const sync_pb::NigoriKeyBag& bag) {
   int key_size = bag.key_size();
   for (int i = 0; i < key_size; ++i) {
     const sync_pb::NigoriKey key = bag.key(i);
     // Only use this key if we don't already know about it.
     if (nigoris_.end() == nigoris_.find(key.name())) {
       scoped_ptr<Nigori> new_nigori(new Nigori);
       if (!new_nigori->InitByImport(key.user_key(),
                                     key.encryption_key(),
                                     key.mac_key())) {
         NOTREACHED();
         continue;
       }
       nigoris_[key.name()] = make_linked_ptr(new_nigori.release());
     }
   }
   DCHECK(nigoris_.end() != nigoris_.find(default_key_name));
   default_nigori_ = &*nigoris_.find(default_key_name);
 }
 
 }  // namespace browser_sync