[Sync] Add keystore encryption info to about:sync

sync/internal_api/sync_manager_impl.cc

 // Copyright (c) 2012 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 "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "sync/internal_api/public/base/model_type_state_map.h"
 #include "sync/internal_api/public/base_node.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/internal_api/public/http_post_provider_factory.h"
 #include "sync/internal_api/public/internal_components_factory.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/user_share.h"
 #include "sync/internal_api/public/util/experiments.h"
+#include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/internal_api/syncapi_server_connection_manager.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/js/js_event_handler.h"
 #include "sync/js/js_reply_handler.h"
 #include "sync/notifier/invalidation_util.h"
 #include "sync/notifier/invalidator.h"
@@ skipping 36 matching lines @@
     case CONFIGURE_REASON_NEW_CLIENT:
       return GetUpdatesCallerInfo::NEW_CLIENT;
     case CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE:
       return GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE;
     default:
       NOTREACHED();
   }
   return GetUpdatesCallerInfo::UNKNOWN;
 }
 
+std::string GetKeystoreMigrationTimeStr(base::Time migration_time) {
+  std::string migration_time_str;
+  if (migration_time.is_null())
+    migration_time_str = "Not Migrated";
+  else
+    migration_time_str = GetTimeDebugString(migration_time);
+  return migration_time_str;
+}
+
 }  // namespace
 
 // A class to calculate nudge delays for types.
 class NudgeStrategy {
  public:
   static TimeDelta GetNudgeDelayTimeDelta(const ModelType& model_type,
                                           SyncManagerImpl* core) {
     NudgeDelayStrategy delay_type = GetNudgeDelayStrategy(model_type);
     return GetNudgeDelayTimeDeltaFromType(delay_type,
                                           model_type,
@@ skipping 276 matching lines @@
   SetJsEventHandler(event_handler);
 
   AddObserver(&debug_info_event_listener_);
 
   database_path_ = database_location.Append(
       syncable::Directory::kSyncDatabaseFilename);
   encryptor_ = encryptor;
   unrecoverable_error_handler_ = unrecoverable_error_handler;
   report_unrecoverable_error_function_ = report_unrecoverable_error_function;
 
+  allstatus_.SetHasKeystoreKey(
+      !restored_keystore_key_for_bootstrapping.empty());
   sync_encryption_handler_.reset(new SyncEncryptionHandlerImpl(
       &share_,
       encryptor,
       restored_key_for_bootstrapping,
       restored_keystore_key_for_bootstrapping));
   sync_encryption_handler_->AddObserver(this);
   sync_encryption_handler_->AddObserver(&debug_info_event_listener_);
   sync_encryption_handler_->AddObserver(&js_sync_encryption_handler_observer_);
 
   FilePath absolute_db_path(database_path_);
@@ skipping 131 matching lines @@
   // Does nothing.
 }
 
 void SyncManagerImpl::OnPassphraseAccepted() {
   // Does nothing.
 }
 
 void SyncManagerImpl::OnBootstrapTokenUpdated(
     const std::string& bootstrap_token,
     BootstrapTokenType type) {
-  // Does nothing.
+  if (type == KEYSTORE_BOOTSTRAP_TOKEN)
+    allstatus_.SetHasKeystoreKey(true);

[akalin, 2012/09/17 18:07:20]

SetHasKeystoreKey(type == KEYSTORE_BOOKSTRAP_TOKEN)?

[Nicolas Zea, 2012/09/17 21:00:24]

Can't, that will set the boolean to false if the non-keystore boostrap token is
updated (they can be updated independently of each other).

 }
 
 void SyncManagerImpl::OnEncryptedTypesChanged(ModelTypeSet encrypted_types,
                                               bool encrypt_everything) {
   allstatus_.SetEncryptedTypes(encrypted_types);
 }
 
 void SyncManagerImpl::OnEncryptionComplete() {
   // Does nothing.
 }
 
 void SyncManagerImpl::OnCryptographerStateChanged(
     Cryptographer* cryptographer) {
   allstatus_.SetCryptographerReady(cryptographer->is_ready());
   allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
+  allstatus_.SetKeystoreMigrationTime(
+      GetKeystoreMigrationTimeStr(
+          sync_encryption_handler_->GetKeystoreMigrationTime()));
 }
 
 void SyncManagerImpl::OnPassphraseTypeChanged(PassphraseType type) {
-  // Does nothing.
+  allstatus_.SetPassphraseType(PassphraseTypeToString(type));
+  allstatus_.SetKeystoreMigrationTime(
+      GetKeystoreMigrationTimeStr(
+          sync_encryption_handler_->GetKeystoreMigrationTime()));
 }
 
 void SyncManagerImpl::StartSyncingNormally(
     const ModelSafeRoutingInfo& routing_info) {
   // Start the sync scheduler.
   // TODO(sync): We always want the newest set of routes when we switch back
   // to normal mode. Figure out how to enforce set_routing_info is always
   // appropriately set and that it's only modified when switching to normal
   // mode.
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 779 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer