[sync] Separate sign in from sync on Desktop Chrome

chrome/browser/ui/webui/sync_setup_handler_unittest.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/ui/webui/sync_setup_handler.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 40 matching lines @@
 const char kTestCaptchaImageUrl[] = "http://pizzamyheart/image";
 const char kTestCaptchaUnlockUrl[] = "http://pizzamyheart/unlock";
 
 // Returns a ModelTypeSet with all user selectable types set.
 syncer::ModelTypeSet GetAllTypes() {
   return syncer::UserSelectableTypes();
 }
 
 enum SyncAllDataConfig {
   SYNC_ALL_DATA,
-  CHOOSE_WHAT_TO_SYNC
+  CHOOSE_WHAT_TO_SYNC,
+  SYNC_NOTHING
 };
 
 enum EncryptAllConfig {
   ENCRYPT_ALL_DATA,
   ENCRYPT_PASSWORDS
 };
 
 // Create a json-format string with the key/value pairs appropriate for a call
 // to HandleConfigure(). If |extra_values| is non-null, then the values from
 // the passed dictionary are added to the json.
 std::string GetConfiguration(const DictionaryValue* extra_values,
                              SyncAllDataConfig sync_all,
                              syncer::ModelTypeSet types,
                              const std::string& passphrase,
                              EncryptAllConfig encrypt_all) {
   DictionaryValue result;
   if (extra_values)
     result.MergeDictionary(extra_values);
   result.SetBoolean("syncAllDataTypes", sync_all == SYNC_ALL_DATA);
+  result.SetBoolean("syncNothing", sync_all == SYNC_NOTHING);
   result.SetBoolean("encryptAllData", encrypt_all == ENCRYPT_ALL_DATA);
   result.SetBoolean("usePassphrase", !passphrase.empty());
   if (!passphrase.empty())
     result.SetString("passphrase", passphrase);
   // Add all of our data types.
   result.SetBoolean("appsSynced", types.Has(syncer::APPS));
   result.SetBoolean("autofillSynced", types.Has(syncer::AUTOFILL));
   result.SetBoolean("bookmarksSynced", types.Has(syncer::BOOKMARKS));
   result.SetBoolean("extensionsSynced", types.Has(syncer::EXTENSIONS));
   result.SetBoolean("passwordsSynced", types.Has(syncer::PASSWORDS));
@@ skipping 84 matching lines @@
   CheckBool(dictionary, "editableUser", user_is_editable);
 }
 
 // Checks to make sure that the values stored in |dictionary| match the values
 // expected by the showSyncSetupPage() JS function for a given set of data
 // types.
 void CheckConfigDataTypeArguments(DictionaryValue* dictionary,
                                   SyncAllDataConfig config,
                                   syncer::ModelTypeSet types) {
   CheckBool(dictionary, "syncAllDataTypes", config == SYNC_ALL_DATA);
+  CheckBool(dictionary, "syncNothing", config == SYNC_NOTHING);
   CheckBool(dictionary, "appsSynced", types.Has(syncer::APPS));
   CheckBool(dictionary, "autofillSynced", types.Has(syncer::AUTOFILL));
   CheckBool(dictionary, "bookmarksSynced", types.Has(syncer::BOOKMARKS));
   CheckBool(dictionary, "extensionsSynced", types.Has(syncer::EXTENSIONS));
   CheckBool(dictionary, "passwordsSynced", types.Has(syncer::PASSWORDS));
   CheckBool(dictionary, "preferencesSynced", types.Has(syncer::PREFERENCES));
   CheckBool(dictionary, "tabsSynced", types.Has(syncer::PROXY_TABS));
   CheckBool(dictionary, "themesSynced", types.Has(syncer::THEMES));
   CheckBool(dictionary, "typedUrlsSynced", types.Has(syncer::TYPED_URLS));
 }
@@ skipping 250 matching lines @@
 
 TEST_P(SyncSetupHandlerTest, Basic) {
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_P(SyncSetupHandlerTest, DisplayBasicLogin) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(false));
+  const GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
+  EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   handler_->HandleStartSignin(NULL);
   EXPECT_EQ(handler_.get(),
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 
   if (!SyncPromoUI::UseWebBasedSigninFlow()) {
     ASSERT_EQ(1U, web_ui_.call_data().size());
     const TestWebUI::CallData& data = web_ui_.call_data()[0];
@@ skipping 461 matching lines @@
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(true, _));
   handler_->HandleConfigure(&list_args);
 
   // Ensure that we navigated to the "done" state since we don't need a
   // passphrase.
   ExpectDone();
 }
 
+TEST_P(SyncSetupHandlerTest, TestSyncNothing) {
+  std::string args = GetConfiguration(
+      NULL, SYNC_NOTHING, GetAllTypes(), std::string(), ENCRYPT_PASSWORDS);
+  ListValue list_args;
+  list_args.Append(new StringValue(args));
+  EXPECT_CALL(*mock_pss_, DisableForUser());
+  SetupInitializedProfileSyncService();
+  handler_->HandleConfigure(&list_args);
+
+  // Ensure that the sync setup dialog was closed.
+  const TestWebUI::CallData& data = web_ui_.call_data()[0];
+  EXPECT_EQ("OptionsPage.closeOverlay", data.function_name);
+}
+
 TEST_P(SyncSetupHandlerTest, TurnOnEncryptAll) {
   std::string args = GetConfiguration(
       NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_ALL_DATA);
   ListValue list_args;
   list_args.Append(new StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
@@ skipping 385 matching lines @@
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", true);
 }
 
 INSTANTIATE_TEST_CASE_P(SyncSetupHandlerTestWithParam,
                         SyncSetupHandlerTest,
                         Values(true, false));