From the enter-passphrase screen in sync setup, canceling should only disable...

chrome/browser/sync/sync_setup_flow.cc

 // Copyright (c) 2010 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/sync_setup_flow.h"
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
@@ skipping 27 matching lines @@
     L"//iframe[@id='passphrase']";
 static const wchar_t* kDoneIframeXPath = L"//iframe[@id='done']";
 
 void FlowHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback("SubmitAuth",
       NewCallback(this, &FlowHandler::HandleSubmitAuth));
   dom_ui_->RegisterMessageCallback("Configure",
       NewCallback(this, &FlowHandler::HandleConfigure));
   dom_ui_->RegisterMessageCallback("Passphrase",
       NewCallback(this, &FlowHandler::HandlePassphraseEntry));
+  dom_ui_->RegisterMessageCallback("PassphraseCancel",
+      NewCallback(this, &FlowHandler::HandlePassphraseCancel));
   dom_ui_->RegisterMessageCallback("FirstPassphrase",
       NewCallback(this, &FlowHandler::HandleFirstPassphrase));
   dom_ui_->RegisterMessageCallback("GoToDashboard",
       NewCallback(this, &FlowHandler::HandleGoToDashboard));
 }
 
 static bool GetAuthData(const std::string& json,
                         std::string* username,
                         std::string* password,
                         std::string* captcha,
@@ skipping 102 matching lines @@
   // Encyption settings.
   if (!result->GetBoolean("usePassphrase", &config->use_secondary_passphrase))
     return false;
   if (config->use_secondary_passphrase &&
       !result->GetString("passphrase", &config->secondary_passphrase))
     return false;
 
   return true;
 }
 
+static void DisablePasswordSync(ProfileSyncService* service) {

[tim (not reviewing), 2011/01/26 18:41:31]

at first I didn't like this, then I spent 10 minutes looking at alternatives,
and now I think it's good :)

I made a mental note to somehow remove the Activate/Deactivate data type stuff
from ProfileSyncService, since it has a very specific use case yet adds
confusion every time you go and try to "disable" a data type because there are
seemingly 4 to 5 ways to do it.

+  syncable::ModelTypeSet types;
+  service->GetPreferredDataTypes(&types);
+  types.erase(syncable::PASSWORDS);
+  service->OnUserChoseDatatypes(false, types);
+}
+
 void FlowHandler::HandleSubmitAuth(const ListValue* args) {
   std::string json(dom_ui_util::GetJsonResponseFromFirstArgumentInList(args));
   std::string username, password, captcha, access_code;
   if (json.empty())
     return;
 
   if (!GetAuthData(json, &username, &password, &captcha, &access_code)) {
     // The page sent us something that we didn't understand.
     // This probably indicates a programming error.
     NOTREACHED();
@@ skipping 34 matching lines @@
   if (!GetPassphrase(json, &passphrase)) {
     // Couldn't understand what the page sent.  Indicates a programming error.
     NOTREACHED();
     return;
   }
 
   DCHECK(flow_);
   flow_->OnPassphraseEntry(passphrase);
 }
 
+void FlowHandler::HandlePassphraseCancel(const ListValue* args) {
+  DCHECK(flow_);
+  flow_->OnPassphraseCancel();
+}
+
 void FlowHandler::HandleFirstPassphrase(const ListValue* args) {
   std::string json(dom_ui_util::GetJsonResponseFromFirstArgumentInList(args));
 
   if (json.empty())
     return;
 
   std::string option;
   std::string passphrase;
   if (!GetFirstPassphrase(json, &option, &passphrase)) {
     // Page sent result which couldn't be parsed.  Programming error.
@@ skipping 497 matching lines @@
 
   service_->OnUserChoseDatatypes(configuration.sync_everything,
                                  configuration.data_types);
 }
 
 void SyncSetupFlow::OnPassphraseEntry(const std::string& passphrase) {
   Advance(SyncSetupWizard::SETTING_UP);
   service_->SetPassphrase(passphrase, true, false);
 }
 
+void SyncSetupFlow::OnPassphraseCancel() {
+  // If the user cancels when being asked for the passphrase,
+  // just disable encrypted sync and continue setting up.
+  if (current_state_ == SyncSetupWizard::ENTER_PASSPHRASE)
+    DisablePasswordSync(service_);
+
+  Advance(SyncSetupWizard::SETTING_UP);
+}
+
 void SyncSetupFlow::OnFirstPassphraseEntry(const std::string& option,
                                            const std::string& passphrase) {
   Advance(SyncSetupWizard::SETTING_UP);
 
   if (option == "explicit") {
     service_->SetPassphrase(passphrase, true, true);
   } else if (option == "nothanks") {
     // User opted out of encrypted sync, need to turn off encrypted
     // data types.
-    syncable::ModelTypeSet registered_types;
-    service_->GetRegisteredDataTypes(&registered_types);
-    registered_types.erase(syncable::PASSWORDS);
-    service_->OnUserChoseDatatypes(false, registered_types);
+    DisablePasswordSync(service_);
   } else if (option == "google") {
     // Implicit passphrase already set up.
     Advance(SyncSetupWizard::DONE);
   }
 }
 
 void SyncSetupFlow::OnGoToDashboard() {
   BrowserList::GetLastActive()->OpenPrivacyDashboardTabAndActivate();
 }