[Sync] Add passphrase/encryption info to chrome://sync.

chrome/browser/sync/engine/syncapi.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/engine/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
@@ skipping 1623 matching lines @@
   JsTransactionObserver js_transaction_observer_;
 };
 const int SyncManager::SyncInternal::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::SyncInternal::kPreferencesNudgeDelayMilliseconds = 2000;
 
 SyncManager::Observer::~Observer() {}
 
 SyncManager::SyncManager(const std::string& name)
     : data_(new SyncInternal(name)) {}
 
+SyncManager::Status::Status() {
+}
+
+SyncManager::Status::~Status() {
+}
+
 bool SyncManager::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
     HttpPostProviderFactory* post_factory,
     ModelSafeWorkerRegistrar* registrar,
     const std::string& user_agent,
     const SyncCredentials& credentials,
@@ skipping 204 matching lines @@
   }
   Cryptographer::UpdateResult result =
       cryptographer->Update(node.GetNigoriSpecifics());
   if (result == Cryptographer::NEEDS_PASSPHRASE) {
     ObserverList<SyncManager::Observer> temp_obs_list;
     CopyObservers(&temp_obs_list);
     FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
                       OnPassphraseRequired(sync_api::REASON_DECRYPTION));
   }
 
+  allstatus_.SetCryptographerReady(cryptographer->is_ready());
+  allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
+
   return cryptographer->is_ready();
 }
 
 void SyncManager::SyncInternal::StartSyncingNormally() {
   // Start the sync scheduler. This won't actually result in any
   // syncing until at least the DirectoryManager broadcasts the OPENED
   // event, and a valid server connection is detected.
   if (scheduler())  // NULL during certain unittests.
     scheduler()->Start(SyncScheduler::NORMAL_MODE, NULL);
 }
@@ skipping 217 matching lines @@
   // Note, we merge the current encrypted types with those requested. Once a
   // datatypes is marked as needing encryption, it is never unmarked.
   sync_pb::NigoriSpecifics nigori;
   nigori.CopyFrom(node.GetNigoriSpecifics());
   syncable::ModelTypeSet current_encrypted_types = GetEncryptedTypes(&trans);
   syncable::ModelTypeSet newly_encrypted_types;
   std::set_union(current_encrypted_types.begin(), current_encrypted_types.end(),
                  encrypted_types.begin(), encrypted_types.end(),
                  std::inserter(newly_encrypted_types,
                                newly_encrypted_types.begin()));
+  allstatus_.SetEncryptedTypes(newly_encrypted_types);
   if (newly_encrypted_types == current_encrypted_types)
     return;  // Set of encrypted types did not change.
   syncable::FillNigoriEncryptedTypes(newly_encrypted_types, &nigori);
   node.SetNigoriSpecifics(nigori);
 
   cryptographer->SetEncryptedTypes(nigori);
 
   // TODO(zea): only reencrypt this datatype? ReEncrypting everything is a
   // safer approach, and should not impact anything that is already encrypted
   // (redundant changes are ignored).
@@ skipping 438 matching lines @@
                           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";
         ObserverList<SyncManager::Observer> temp_obs_list;
         CopyObservers(&temp_obs_list);
         FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
                           OnPassphraseRequired(sync_api::REASON_ENCRYPTION));
       }
+
+      allstatus_.SetCryptographerReady(cryptographer->is_ready());
+      allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
+      allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
+
       // 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 (!initialized_) {
       LOG(INFO) << "OnSyncCycleCompleted not sent because sync api is not "
                 << "initialized";
       return;
@@ skipping 437 matching lines @@
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api