[Sync] Cache encrypted types info in ProfileSyncService

chrome/browser/sync/internal_api/sync_manager.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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/command_line.h"
@@ skipping 1198 matching lines @@
         if (!child.InitByIdLookup(child_id)) {
           NOTREACHED();
           return;
         }
         child.SetPasswordSpecifics(child.GetPasswordSpecifics());
         child_id = child.GetSuccessorId();
       }
     }
   }
 
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                    OnEncryptionComplete(encrypted_types));
+  FOR_EACH_OBSERVER(
+      SyncManager::Observer, observers_,
+      OnEncryptionComplete(
+          encrypted_types, cryptographer->encrypt_everything()));
 }
 
 SyncManager::~SyncManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
   delete data_;
 }
 
 void SyncManager::AddChangeObserver(ChangeObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->AddChangeObserver(observer);
@@ skipping 362 matching lines @@
   // Only send an event if this is due to a cycle ending and this cycle
   // concludes a canonical "sync" process; that is, based on what is known
   // locally we are "all happy" and up-to-date.  There may be new changes on
   // the server, but we'll get them on a subsequent sync.
   //
   // Notifications are sent at the end of every sync cycle, regardless of
   // whether we should sync again.
   if (event.what_happened == SyncEngineEvent::SYNC_CYCLE_ENDED) {
     ModelSafeRoutingInfo enabled_types;
     registrar_->GetModelSafeRoutingInfo(&enabled_types);
+    bool send_encryption_complete_notification = false;
+    syncable::ModelTypeSet encrypted_types(
+        browser_sync::Cryptographer::SensitiveTypes());
+    bool encrypt_everything = false;
     {
       // Check to see if we need to notify the frontend that we have newly
       // encrypted types or that we require a passphrase.
       sync_api::ReadTransaction trans(FROM_HERE, GetUserShare());
       Cryptographer* cryptographer = trans.GetCryptographer();
       // If we've completed a sync cycle and the cryptographer isn't ready
       // yet, prompt the user for a passphrase.
       if (cryptographer->has_pending_keys()) {
         VLOG(1) << "OnPassPhraseRequired Sent";
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(sync_api::REASON_DECRYPTION));
       } else if (!cryptographer->is_ready() &&
                  event.snapshot->initial_sync_ended.test(syncable::NIGORI)) {
         VLOG(1) << "OnPassphraseRequired sent because cryptographer is not "
                 << "ready";
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(sync_api::REASON_ENCRYPTION));
+      } else {
+        send_encryption_complete_notification = true;
       }
 
+      encrypted_types = cryptographer->GetEncryptedTypes();
+      encrypt_everything = cryptographer->encrypt_everything();
       allstatus_.SetCryptographerReady(cryptographer->is_ready());
       allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
-      allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
+      allstatus_.SetEncryptedTypes(encrypted_types);
 
-      // If everything is in order(we have the passphrase) then there is no
-      // need to inform the listeners. They will just wait for sync
-      // completion event and if no errors have been raised it means
-      // encryption was succesful.
+      // If everything is in order (we have the passphrase) then we
+      // inform the listeners below right after we close the
+      // transaction.
+    }
+
+    if (send_encryption_complete_notification) {
+      VLOG(1) << "Sending OnEncryptionComplete";

[Nicolas Zea, 2011/10/20 18:40:41]

Should probably be VLOG(2), since this is going to happen on nearly every sync
cycle.

[akalin, 2011/10/21 02:24:17]

Removed.  Probably not necessary.

+      // TODO(akalin): Ideally, the Cryptographer would be the one
+      // sending out this notification, as it knows exactly when it
+      // does encryption (whereas we always send this at the end of a
+      // sync cycle, regardless of whether encryption was actually
+      // done).
+      FOR_EACH_OBSERVER(
+          SyncManager::Observer, observers_,
+          OnEncryptionComplete(encrypted_types, encrypt_everything));
     }
 
     if (!initialized_) {
       LOG(INFO) << "OnSyncCycleCompleted not sent because sync api is not "
                 << "initialized";
       return;
     }
 
     if (!event.snapshot->has_more_to_sync) {
-      VLOG(1) << "OnSyncCycleCompleted sent";
+      VLOG(1) << "Sending OnSyncCycleCompleted";
       FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                         OnSyncCycleCompleted(event.snapshot));
     }
 
     // This is here for tests, which are still using p2p notifications.
     //
     // TODO(chron): Consider changing this back to track has_more_to_sync
     // only notify peers if a successful commit has occurred.
     bool is_notifiable_commit =
         (event.snapshot->syncer_status.num_successful_commits > 0);
@@ skipping 428 matching lines @@
 
   for (syncable::ModelTypeSet::const_iterator i = types.begin();
        i != types.end(); ++i) {
     if (!lookup->initial_sync_ended_for_type(*i))
       return false;
   }
   return true;
 }
 
 }  // namespace sync_api