suppress user/password dialog when re-enabling sync

chrome/browser/sync/profile_sync_service.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 "chrome/browser/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 22 matching lines @@
 #include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/backend_migrator.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/chrome_report_unrecoverable_error.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/glue/session_data_type_controller.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
 #include "chrome/browser/sync/internal_api/configure_reason.h"
 #include "chrome/browser/sync/internal_api/sync_manager.h"
+#include "chrome/browser/sync/internal_api/write_node.h"
+#include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/profile_sync_components_factory_impl.h"
 #include "chrome/browser/sync/sync_global_error.h"
 #include "chrome/browser/sync/user_selectable_sync_type.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/global_error_service.h"
 #include "chrome/browser/ui/global_error_service_factory.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
@@ skipping 141 matching lines @@
 
   RegisterAuthNotifications();
 
   if (!HasSyncSetupCompleted())
     DisableForUser();  // Clean up in case of previous crash / setup abort.
 
   TryStart();
 }
 
 void ProfileSyncService::TryStart() {
+  LOG(WARNING) << "TryStart";
   if (!sync_prefs_.IsStartSuppressed() && AreCredentialsAvailable()) {
     if (HasSyncSetupCompleted() || auto_start_enabled_) {
       // If sync setup has completed we always start the backend.
       // If autostart is enabled, but we haven't completed sync setup, we try to
       // start sync anyway, since it's possible we crashed/shutdown after
       // logging in but before the backend finished initializing the last time.
       // Note that if we haven't finished setting up sync, backend bring up will
       // be done by the wizard.
       StartUp();
     }
   } else if (HasSyncSetupCompleted()) {
     TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
     if (token_service && token_service->TokensLoadedFromDB() &&
         !AreCredentialsAvailable()) {
       // The token service has lost sync's tokens. We cannot recover from this
       // without signing back in, which is not yet supported. For now, we
       // trigger an unrecoverable error.
       OnUnrecoverableError(FROM_HERE, "Sync credentials lost.");
     }
+  } else {
+    LOG(WARNING) << "TryStart: did nothing.";
   }
 }
 
 void ProfileSyncService::RegisterAuthNotifications() {
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_AVAILABLE,
                  content::Source<TokenService>(token_service));
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
@@ skipping 92 matching lines @@
   scoped_refptr<net::URLRequestContextGetter> request_context_getter(
       profile_->GetRequestContext());
 
   if (delete_stale_data)
     ClearStaleErrors();
 
   backend_unrecoverable_error_handler_.reset(
     new browser_sync::BackendUnrecoverableErrorHandler(
         MakeWeakHandle(AsWeakPtr())));
 
+  LOG(WARNING) << "Initializing backend";
   backend_->Initialize(
       this,
       MakeWeakHandle(sync_js_controller_.AsWeakPtr()),
       sync_service_url_,
       initial_types,
       credentials,
       delete_stale_data,
       backend_unrecoverable_error_handler_.get(),
       &browser_sync::ChromeReportUnrecoverableError);
 }
 
 void ProfileSyncService::CreateBackend() {
+  LOG(WARNING) << "CreateBackend";
   backend_.reset(
       new SyncBackendHost(profile_->GetDebugName(),
                           profile_, sync_prefs_.AsWeakPtr()));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncable::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncable::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
@@ skipping 255 matching lines @@
   failed_datatypes_handler_.UpdateFailedDatatypes(errors,
       FailedDatatypesHandler::RUNTIME);
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ReconfigureDatatypeManager,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ProfileSyncService::OnBackendInitialized(
     const WeakHandle<JsBackend>& js_backend, bool success) {
+  LOG(WARNING) << "OnBackendInitialized() : " << success;
   if (!HasSyncSetupCompleted()) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
 
   if (!success) {
     // Something went unexpectedly wrong.  Play it safe: nuke our current state
     // and prepare ourselves to try again later.
     DisableForUser();
@@ skipping 26 matching lines @@
   }
 
   if (HasSyncSetupCompleted()) {
     ConfigureDataTypeManager();
   } else {
     DCHECK(FirstSetupInProgress());
   }
 }
 
 void ProfileSyncService::OnSyncCycleCompleted() {
+  LOG(WARNING) << "OnSyncCycleCompleted";
   UpdateLastSyncedTime();
   if (GetSessionModelAssociator()) {
     // Trigger garbage collection of old sessions now that we've downloaded
     // any new session data. TODO(zea): Have this be a notification the session
     // model associator listens too. Also consider somehow plumbing the current
     // server time as last reported by CheckServerReachable, so we don't have to
     // rely on the local clock, which may be off significantly.
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&browser_sync::SessionModelAssociator::DeleteStaleSessions,
                    GetSessionModelAssociator()->AsWeakPtr()));
@@ skipping 92 matching lines @@
     default:
       NOTREACHED();
       return GoogleServiceAuthError(GoogleServiceAuthError::CONNECTION_FAILED);
   }
 }
 
 }  // namespace
 
 void ProfileSyncService::OnConnectionStatusChange(
     sync_api::ConnectionStatus status) {
+  LOG(WARNING) << "OnConnectionStatusChange";
   UpdateAuthErrorState(ConnectionStatusToAuthError(status));
 }
 
 void ProfileSyncService::OnStopSyncingPermanently() {
+  LOG(WARNING) << "OnStopSyncingPermanently";
   UpdateAuthErrorState(
       GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE));
   sync_prefs_.SetStartSuppressed(true);
   DisableForUser();
 }
 
 void ProfileSyncService::OnClearServerDataTimeout() {
+  LOG(WARNING) << "OnClearServerDataTimeout";
   if (clear_server_data_state_ != CLEAR_SUCCEEDED &&
       clear_server_data_state_ != CLEAR_FAILED) {
     clear_server_data_state_ = CLEAR_FAILED;
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnClearServerDataFailed() {
+  LOG(WARNING) << "OnClearServerDataFailed";
   clear_server_data_timer_.Stop();
 
   // Only once clear has succeeded there is no longer a need to transition to
   // a failed state as sync is disabled locally.  Also, no need to fire off
   // the observers if the state didn't change (i.e. it was FAILED before).
   if (clear_server_data_state_ != CLEAR_SUCCEEDED &&
       clear_server_data_state_ != CLEAR_FAILED) {
     clear_server_data_state_ = CLEAR_FAILED;
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnClearServerDataSucceeded() {
+  LOG(WARNING) << "OnClearServerDataSucceeded";
   clear_server_data_timer_.Stop();
 
   // Even if the timout fired, we still transition to the succeeded state as
   // we want UI to update itself and no longer allow the user to press "clear"
   if (clear_server_data_state_ != CLEAR_SUCCEEDED) {
     clear_server_data_state_ = CLEAR_SUCCEEDED;
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnPassphraseRequired(
     sync_api::PassphraseRequiredReason reason,
     const sync_pb::EncryptedData& pending_keys) {
+  LOG(WARNING) << "OnPassphraseRequired";
   DCHECK(backend_.get());
   DCHECK(backend_->IsNigoriEnabled());
 
   // TODO(lipalani) : add this check to other locations as well.
   if (unrecoverable_error_detected_) {
     // When unrecoverable error is detected we post a task to shutdown the
     // backend. The task might not have executed yet.
     return;
   }
 
   DVLOG(1) << "Passphrase required with reason: "
            << sync_api::PassphraseRequiredReasonToString(reason);
   passphrase_required_reason_ = reason;
 
   // Notify observers that the passphrase status may have changed.
   NotifyObservers();
 }
 
 void ProfileSyncService::OnPassphraseAccepted() {
+  LOG(WARNING) << "OnPassphraseAccepted";
   DVLOG(1) << "Received OnPassphraseAccepted.";
   // If we are not using an explicit passphrase, and we have a cache of the gaia
   // password, use it for encryption at this point.
   DCHECK(cached_passphrase_.empty()) <<
       "Passphrase no longer required but there is still a cached passphrase";
 
   // Reset passphrase_required_reason_ since we know we no longer require the
   // passphrase. We do this here rather than down in ResolvePassphraseRequired()
   // because that can be called by OnPassphraseRequired() if no encrypted data
   // types are enabled, and we don't want to clobber the true passphrase error.
@@ skipping 18 matching lines @@
   encrypted_types_ = encrypted_types;
   encrypt_everything_ = encrypt_everything;
   DVLOG(1) << "Encrypted types changed to "
            << syncable::ModelTypeSetToString(encrypted_types_)
            << " (encrypt everything is set to "
            << (encrypt_everything_ ? "true" : "false") << ")";
   DCHECK(encrypted_types_.Has(syncable::PASSWORDS));
 }
 
 void ProfileSyncService::OnEncryptionComplete() {
+  LOG(WARNING) << "OnEncryptionComplete";
   DVLOG(1) << "Encryption complete";
   if (encryption_pending_ && encrypt_everything_) {
     encryption_pending_ = false;
     // This is to nudge the integration tests when encryption is
     // finished.
     NotifyObservers();
   }
 }
 
 void ProfileSyncService::OnMigrationNeededForTypes(
     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);
 }
 
 void ProfileSyncService::OnActionableError(const SyncProtocolError& error) {
+  LOG(WARNING) << "OnActionableError";
   last_actionable_error_ = error;
   DCHECK_NE(last_actionable_error_.action,
             browser_sync::UNKNOWN_ACTION);
   switch (error.action) {
     case browser_sync::UPGRADE_CLIENT:
     case browser_sync::CLEAR_USER_DATA_AND_RESYNC:
     case browser_sync::ENABLE_SYNC_ON_ACCOUNT:
     case browser_sync::STOP_AND_RESTART_SYNC:
       // TODO(lipalani) : if setup in progress we want to display these
       // actions in the popup. The current experience might not be optimal for
@@ skipping 152 matching lines @@
         // Selected type has changed - log it.
         UMA_HISTOGRAM_ENUMERATION(
             "Sync.CustomSync",
             user_selectable_types[i],
             browser_sync::user_selectable_type::SELECTABLE_DATATYPE_COUNT + 1);
       }
     }
   }
 }
 
+void ProfileSyncService::RefreshSpareBootstrapToken(
+    const std::string& passphrase) {
+  // All accesses to the cryptographer are protected by a transaction.
+  sync_api::WriteTransaction trans(FROM_HERE, GetUserShare());

[Andrew T Wilson (Slow), 2012/04/03 22:22:33]

I think we want to create our own cryptographer here, not access one from a
transaction. We should not be grabbing any locks here (i.e. creating
Read/WriteTransaction objects in ProfileSyncService) since that can block the UI
thread. Nicolas can confirm the best way to get a local cryptographer.

[kochi, 2012/04/03 23:21:48]

Done as Nicolas suggested.

On 2012/04/03 22:22:33, Andrew T Wilson wrote:

+  browser_sync::Cryptographer* cryptographer = trans.GetCryptographer();
+  browser_sync::KeyParams key_params = {"localhost", "dummy", passphrase};
+  sync_api::WriteNode node(&trans);
+  if (!node.InitByTagLookup(browser_sync::kNigoriTag)) {

[Andrew T Wilson (Slow), 2012/04/03 22:22:33]

We don't need a real nigori node here - we can create a fake one like SyncBacken
dHost::CheckPassphraseAgainstCachedPendingKeys() does. In fact, do we even need
this nigori node (it's not used below?)

[kochi, 2012/04/03 23:21:48]

Done as Nicolas suggested.
On 2012/04/03 22:22:33, Andrew T Wilson wrote:

+    NOTREACHED();
+    return;
+  }
+
+  std::string bootstrap_token;
+  if (!cryptographer->AddKey(key_params)) {
+    NOTREACHED() << "Failed to add key to cryptographer.";
+  }
+  cryptographer->GetBootstrapToken(&bootstrap_token);
+  sync_prefs_.SetSpareBootstrapToken(bootstrap_token);
+}
+
 void ProfileSyncService::OnUserChoseDatatypes(bool sync_everything,
     syncable::ModelTypeSet chosen_types) {
   if (!backend_.get() &&
       unrecoverable_error_detected_ == false) {
     NOTREACHED();
     return;
   }
 
   UpdateSelectedTypesHistogram(sync_everything, chosen_types);
   sync_prefs_.SetKeepEverythingSynced(sync_everything);
@@ skipping 338 matching lines @@
           content::Details<const GoogleServiceSigninSuccessDetails>(
               details).ptr();
       DCHECK(!successful->password.empty());
       if (!sync_prefs_.IsStartSuppressed()) {
         cached_passphrase_ = successful->password;
         // Try to consume the passphrase we just cached. If the sync backend
         // is not running yet, the passphrase will remain cached until the
         // backend starts up.
         ConsumeCachedPassphraseIfPossible();
       }
+      RefreshSpareBootstrapToken(successful->password);
       if (!sync_initialized() ||
           GetAuthError().state() != GoogleServiceAuthError::NONE) {
         // Track the fact that we're still waiting for auth to complete.
         is_auth_in_progress_ = true;
       }
       break;
     }
     case chrome::NOTIFICATION_TOKEN_REQUEST_FAILED: {
+      LOG(WARNING) << "Got NOTIFICATION_TOKEN_REQUEST_FAILED";
       const TokenService::TokenRequestFailedDetails& token_details =
           *(content::Details<const TokenService::TokenRequestFailedDetails>(
               details).ptr());
       if (IsTokenServiceRelevant(token_details.service())) {
         GoogleServiceAuthError error(
             GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
         UpdateAuthErrorState(error);
       }
       break;
     }
     case chrome::NOTIFICATION_TOKEN_AVAILABLE: {
+      LOG(WARNING) << "Got NOTIFICATION_TOKEN_AVAILABLE";
       const TokenService::TokenAvailableDetails& token_details =
           *(content::Details<const TokenService::TokenAvailableDetails>(
               details).ptr());
       if (IsTokenServiceRelevant(token_details.service()) &&
           AreCredentialsAvailable()) {
         if (backend_initialized_)
           backend_->UpdateCredentials(GetCredentials());
         else if (!sync_prefs_.IsStartSuppressed())
           StartUp();
       }
       break;
     }
     case chrome::NOTIFICATION_TOKEN_LOADING_FINISHED: {
+      LOG(WARNING) << "Got NOTIFICATION_TOKEN_LOADING_FINISHED";
       // This notification gets fired when TokenService loads the tokens
       // from storage.
       if (AreCredentialsAvailable()) {
         // Initialize the backend if sync token was loaded.
         if (backend_initialized_) {
           backend_->UpdateCredentials(GetCredentials());
         }
         if (!sync_prefs_.IsStartSuppressed())
           StartUp();
       } else if (!auto_start_enabled_ &&
@@ skipping 54 matching lines @@
     return false;
 
   return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }
 
 void ProfileSyncService::StopAndSuppress() {
   sync_prefs_.SetStartSuppressed(true);
   ShutdownImpl(false);
 }
 
-void ProfileSyncService::UnsuppressAndStart() {
+void ProfileSyncService::Unsuppress() {
+  LOG(WARNING) << "Unsuppress()";

[Andrew T Wilson (Slow), 2012/04/03 22:22:33]

See previous comment - not sure if we should break this out.

[kochi, 2012/04/03 23:21:48]

Done.

   DCHECK(profile_);
   sync_prefs_.SetStartSuppressed(false);
+}
+
+void ProfileSyncService::UnsuppressAndStart() {
+  LOG(WARNING) << "UnsuppressAndStart()";
+  Unsuppress();
   // Set username in SigninManager, as SigninManager::OnGetUserInfoSuccess
   // is never called for some clients.
   if (signin_ && signin_->GetAuthenticatedUsername().empty()) {
     signin_->SetAuthenticatedUsername(sync_prefs_.GetGoogleServicesUsername());
   }
   TryStart();
 }
 
 void ProfileSyncService::AcknowledgeSyncedTypes() {
   sync_prefs_.AcknowledgeSyncedTypes(GetRegisteredDataTypes());
@@ skipping 35 matching lines @@
   // See http://stackoverflow.com/questions/6224121/is-new-this-myclass-undefined-behaviour-after-directly-calling-the-destru.
   ProfileSyncService* old_this = this;
   this->~ProfileSyncService();
   new(old_this) ProfileSyncService(
       new ProfileSyncComponentsFactoryImpl(profile,
                                            CommandLine::ForCurrentProcess()),
       profile,
       signin,
       behavior);
 }