Move Autofill Payments integration checkbox to the sync settings page.

chrome/browser/ui/webui/options/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/options/sync_setup_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 44 matching lines @@
 syncer::ModelTypeSet GetAllTypes() {
   return syncer::UserSelectableTypes();
 }
 
 enum SyncAllDataConfig {
   SYNC_ALL_DATA,
   CHOOSE_WHAT_TO_SYNC,
   SYNC_NOTHING
 };
 
 enum EncryptAllConfig {

[brettw, 2016/01/15 20:30:41]

The existing system seems to be explicitly trying to avoid using booleans for
the setup here. It makes the setup call sites much more readable. Can you add an
enum for the payments integration too like the encryption option, and replace
the boolean with it?

[Justin Donnelly, 2016/01/15 21:16:51]

Good point. Done.

   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 base::DictionaryValue* extra_values,
                              SyncAllDataConfig sync_all,
                              syncer::ModelTypeSet types,
                              const std::string& passphrase,
-                             EncryptAllConfig encrypt_all) {
+                             EncryptAllConfig encrypt_all,
+                             bool payments_integration_enabled) {
   base::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));
   result.SetBoolean("preferencesSynced", types.Has(syncer::PREFERENCES));
   result.SetBoolean("tabsSynced", types.Has(syncer::PROXY_TABS));
   result.SetBoolean("themesSynced", types.Has(syncer::THEMES));
   result.SetBoolean("typedUrlsSynced", types.Has(syncer::TYPED_URLS));
   result.SetBoolean("wifiCredentialsSynced",
                     types.Has(syncer::WIFI_CREDENTIALS));
+  result.SetBoolean("paymentsIntegrationEnabled", payments_integration_enabled);
   std::string args;
   base::JSONWriter::Write(result, &args);
   return args;
 }
 
 // Checks whether the passed |dictionary| contains a |key| with the given
 // |expected_value|. If |omit_if_false| is true, then the value should only
 // be present if |expected_value| is true.
 void CheckBool(const base::DictionaryValue* dictionary,
                const std::string& key,
@@ skipping 402 matching lines @@
       .WillRepeatedly(Return(false));
   // Open the web UI.
   handler_->OpenSyncSetup(nullptr);
 
   ASSERT_FALSE(handler_->is_configuring_sync());
 }
 
 #endif  // #if !defined(OS_CHROMEOS)
 
 TEST_F(SyncSetupHandlerTest, TestSyncEverything) {
-  std::string args = GetConfiguration(
-      NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_PASSWORDS);
+  std::string args = GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(),
+                                      std::string(), ENCRYPT_PASSWORDS, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .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_F(SyncSetupHandlerTest, TestSyncNothing) {
-  std::string args = GetConfiguration(
-      NULL, SYNC_NOTHING, GetAllTypes(), std::string(), ENCRYPT_PASSWORDS);
+  std::string args = GetConfiguration(NULL, SYNC_NOTHING, GetAllTypes(),
+                                      std::string(), ENCRYPT_PASSWORDS, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, RequestStop(ProfileSyncService::CLEAR_DATA));
   SetupInitializedProfileSyncService();
   handler_->HandleConfigure(&list_args);
 
   // We expect a call to SyncSetupOverlay.showSyncSetupPage.
   ASSERT_EQ(1U, web_ui_.call_data().size());
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   EXPECT_EQ("SyncSetupOverlay.showSyncSetupPage", data.function_name());
 }
 
 TEST_F(SyncSetupHandlerTest, TurnOnEncryptAll) {
-  std::string args = GetConfiguration(
-      NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_ALL_DATA);
+  std::string args = GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(),
+                                      std::string(), ENCRYPT_ALL_DATA, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsEncryptEverythingAllowed())
       .WillRepeatedly(Return(true));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, EnableEncryptEverything());
   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_F(SyncSetupHandlerTest, TestPassphraseStillRequired) {
-  std::string args = GetConfiguration(
-      NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_PASSWORDS);
+  std::string args = GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(),
+                                      std::string(), ENCRYPT_PASSWORDS, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
   SetDefaultExpectationsForConfigPage();
 
   // We should navigate back to the configure page since we need a passphrase.
   handler_->HandleConfigure(&list_args);
 
   ExpectConfig();
 }
 
 TEST_F(SyncSetupHandlerTest, SuccessfullySetPassphrase) {
   base::DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", true);
-  std::string args = GetConfiguration(&dict,
-                                      SYNC_ALL_DATA,
-                                      GetAllTypes(),
-                                      "gaiaPassphrase",
-                                      ENCRYPT_PASSWORDS);
+  std::string args =
+      GetConfiguration(&dict, SYNC_ALL_DATA, GetAllTypes(), "gaiaPassphrase",
+                       ENCRYPT_PASSWORDS, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   // Act as if an encryption passphrase is required the first time, then never
   // again after that.
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired()).WillOnce(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
   EXPECT_CALL(*mock_pss_, SetDecryptionPassphrase("gaiaPassphrase")).
       WillOnce(Return(true));
 
   handler_->HandleConfigure(&list_args);
   // We should navigate to "done" page since we finished configuring.
   ExpectDone();
 }
 
 TEST_F(SyncSetupHandlerTest, SelectCustomEncryption) {
   base::DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", false);
-  std::string args = GetConfiguration(&dict,
-                                      SYNC_ALL_DATA,
-                                      GetAllTypes(),
-                                      "custom_passphrase",
-                                      ENCRYPT_PASSWORDS);
+  std::string args =
+      GetConfiguration(&dict, SYNC_ALL_DATA, GetAllTypes(), "custom_passphrase",
+                       ENCRYPT_PASSWORDS, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
   EXPECT_CALL(*mock_pss_,
               SetEncryptionPassphrase("custom_passphrase",
                                       ProfileSyncService::EXPLICIT));
 
   handler_->HandleConfigure(&list_args);
   // We should navigate to "done" page since we finished configuring.
   ExpectDone();
 }
 
 TEST_F(SyncSetupHandlerTest, UnsuccessfullySetPassphrase) {
   base::DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", true);
-  std::string args = GetConfiguration(&dict,
-                                      SYNC_ALL_DATA,
-                                      GetAllTypes(),
-                                      "invalid_passphrase",
-                                      ENCRYPT_PASSWORDS);
+  std::string args =
+      GetConfiguration(&dict, SYNC_ALL_DATA, GetAllTypes(),
+                       "invalid_passphrase", ENCRYPT_PASSWORDS, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
@@ skipping 15 matching lines @@
 }
 
 // Walks through each user selectable type, and tries to sync just that single
 // data type.
 TEST_F(SyncSetupHandlerTest, TestSyncIndividualTypes) {
   syncer::ModelTypeSet user_selectable_types = GetAllTypes();
   syncer::ModelTypeSet::Iterator it;
   for (it = user_selectable_types.First(); it.Good(); it.Inc()) {
     syncer::ModelTypeSet type_to_set;
     type_to_set.Put(it.Get());
-    std::string args = GetConfiguration(NULL,
-                                        CHOOSE_WHAT_TO_SYNC,
-                                        type_to_set,
-                                        std::string(),
-                                        ENCRYPT_PASSWORDS);
+    std::string args = GetConfiguration(NULL, CHOOSE_WHAT_TO_SYNC, type_to_set,
+                                        std::string(), ENCRYPT_PASSWORDS, true);
     base::ListValue list_args;
     list_args.Append(new base::StringValue(args));
     EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
         .WillRepeatedly(Return(false));
     SetupInitializedProfileSyncService();
     EXPECT_CALL(*mock_pss_,
                 OnUserChoseDatatypes(false, ModelTypeSetMatches(type_to_set)));
     handler_->HandleConfigure(&list_args);
 
     ExpectDone();
     Mock::VerifyAndClearExpectations(mock_pss_);
     web_ui_.ClearTrackedCalls();
   }
 }
 
 TEST_F(SyncSetupHandlerTest, TestSyncAllManually) {
-  std::string args = GetConfiguration(NULL,
-                                      CHOOSE_WHAT_TO_SYNC,
-                                      GetAllTypes(),
-                                      std::string(),
-                                      ENCRYPT_PASSWORDS);
+  std::string args = GetConfiguration(NULL, CHOOSE_WHAT_TO_SYNC, GetAllTypes(),
+                                      std::string(), ENCRYPT_PASSWORDS, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_,
               OnUserChoseDatatypes(false, ModelTypeSetMatches(GetAllTypes())));
   handler_->HandleConfigure(&list_args);
@@ skipping 73 matching lines @@
   CheckBool(dictionary, "appsRegistered", true);
   CheckBool(dictionary, "autofillRegistered", true);
   CheckBool(dictionary, "bookmarksRegistered", true);
   CheckBool(dictionary, "extensionsRegistered", true);
   CheckBool(dictionary, "passwordsRegistered", true);
   CheckBool(dictionary, "preferencesRegistered", true);
   CheckBool(dictionary, "wifiCredentialsRegistered", true);
   CheckBool(dictionary, "tabsRegistered", true);
   CheckBool(dictionary, "themesRegistered", true);
   CheckBool(dictionary, "typedUrlsRegistered", true);
+  CheckBool(dictionary, "paymentsIntegrationEnabled", true);
   CheckBool(dictionary, "showPassphrase", false);
   CheckBool(dictionary, "usePassphrase", false);
   CheckBool(dictionary, "passphraseFailed", false);
   CheckBool(dictionary, "encryptAllData", false);
   CheckConfigDataTypeArguments(dictionary, SYNC_ALL_DATA, GetAllTypes());
 }
 
 TEST_F(SyncSetupHandlerTest, ShowSetupManuallySyncAll) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
@@ skipping 124 matching lines @@
 
   ExpectConfig();
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   const base::DictionaryValue* dictionary = nullptr;
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", false);
   CheckBool(dictionary, "encryptAllDataAllowed", false);
 }
 
 TEST_F(SyncSetupHandlerTest, TurnOnEncryptAllDisallowed) {
-  std::string args = GetConfiguration(
-      NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_ALL_DATA);
+  std::string args = GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(),
+                                      std::string(), ENCRYPT_ALL_DATA, true);
   base::ListValue list_args;
   list_args.Append(new base::StringValue(args));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, IsEncryptEverythingAllowed())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, EnableEncryptEverything()).Times(0);
   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();
 }