Sync UI: Use camelCase for variables sent to JS.

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/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 69 matching lines @@
                              EncryptAllConfig encrypt_all) {
   DictionaryValue result;
   if (extra_values)
     result.MergeDictionary(extra_values);
   result.SetBoolean("syncAllDataTypes", sync_all == SYNC_ALL_DATA);
   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("sync_apps", types.Has(syncable::APPS));
-  result.SetBoolean("sync_autofill", types.Has(syncable::AUTOFILL));
-  result.SetBoolean("sync_bookmarks", types.Has(syncable::BOOKMARKS));
-  result.SetBoolean("sync_extensions", types.Has(syncable::EXTENSIONS));
-  result.SetBoolean("sync_passwords", types.Has(syncable::PASSWORDS));
-  result.SetBoolean("sync_preferences", types.Has(syncable::PREFERENCES));
-  result.SetBoolean("sync_sessions", types.Has(syncable::SESSIONS));
-  result.SetBoolean("sync_themes", types.Has(syncable::THEMES));
-  result.SetBoolean("sync_typed_urls", types.Has(syncable::TYPED_URLS));
+  result.SetBoolean("appsSynced", types.Has(syncable::APPS));
+  result.SetBoolean("autofillSynced", types.Has(syncable::AUTOFILL));
+  result.SetBoolean("bookmarksSynced", types.Has(syncable::BOOKMARKS));
+  result.SetBoolean("extensionsSynced", types.Has(syncable::EXTENSIONS));
+  result.SetBoolean("passwordsSynced", types.Has(syncable::PASSWORDS));
+  result.SetBoolean("preferencesSynced", types.Has(syncable::PREFERENCES));
+  result.SetBoolean("sessionsSynced", types.Has(syncable::SESSIONS));
+  result.SetBoolean("themesSynced", types.Has(syncable::THEMES));
+  result.SetBoolean("typedUrlsSynced", types.Has(syncable::TYPED_URLS));
   std::string args;
   base::JSONWriter::Write(&result, &args);
   return args;
 }
 
 void CheckInt(const DictionaryValue* dictionary,
               const std::string& key,
               int expected_value) {
   int actual_value;
   EXPECT_TRUE(dictionary->GetInteger(key, &actual_value)) <<
@@ skipping 55 matching lines @@
   // named values set:
   //   error_message: custom error message to display.
   //   fatalError: true if there was a fatal error while logging in.
   //   error: GoogleServiceAuthError from previous login attempt (0 if none).
   //   user: The email the user most recently entered.
   //   editable_user: Whether the username field should be editable.
   //   captchaUrl: The captcha image to display to the user (empty if none).
   //
   // The code below validates these arguments.
 
-  CheckString(dictionary, "error_message", error_message, true);
+  CheckString(dictionary, "errorMessage", error_message, true);
   CheckString(dictionary, "user", user, false);
   CheckString(dictionary, "captchaUrl", captcha_url, false);
   CheckInt(dictionary, "error", error);
   CheckBool(dictionary, "fatalError", fatal_error, true);
-  CheckBool(dictionary, "editable_user", user_is_editable);
+  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,
                                   syncable::ModelTypeSet types) {
   CheckBool(dictionary, "syncAllDataTypes", config == SYNC_ALL_DATA);
-  CheckBool(dictionary, "sync_apps", types.Has(syncable::APPS));
-  CheckBool(dictionary, "sync_autofill", types.Has(syncable::AUTOFILL));
-  CheckBool(dictionary, "sync_bookmarks", types.Has(syncable::BOOKMARKS));
-  CheckBool(dictionary, "sync_extensions", types.Has(syncable::EXTENSIONS));
-  CheckBool(dictionary, "sync_passwords", types.Has(syncable::PASSWORDS));
-  CheckBool(dictionary, "sync_preferences", types.Has(syncable::PREFERENCES));
-  CheckBool(dictionary, "sync_sessions", types.Has(syncable::SESSIONS));
-  CheckBool(dictionary, "sync_themes", types.Has(syncable::THEMES));
-  CheckBool(dictionary, "sync_typed_urls", types.Has(syncable::TYPED_URLS));
+  CheckBool(dictionary, "appsSynced", types.Has(syncable::APPS));
+  CheckBool(dictionary, "autofillSynced", types.Has(syncable::AUTOFILL));
+  CheckBool(dictionary, "bookmarksSynced", types.Has(syncable::BOOKMARKS));
+  CheckBool(dictionary, "extensionsSynced", types.Has(syncable::EXTENSIONS));
+  CheckBool(dictionary, "passwordsSynced", types.Has(syncable::PASSWORDS));
+  CheckBool(dictionary, "preferencesSynced", types.Has(syncable::PREFERENCES));
+  CheckBool(dictionary, "sessionsSynced", types.Has(syncable::SESSIONS));
+  CheckBool(dictionary, "themesSynced", types.Has(syncable::THEMES));
+  CheckBool(dictionary, "typedUrlsSynced", types.Has(syncable::TYPED_URLS));
 }
 
 
 }  // namespace
 
 // Test instance of MockWebUI that tracks the data passed to
 // CallJavascriptFunction().
 class TestWebUI : public content::MockWebUI {
  public:
   virtual ~TestWebUI() {
@@ skipping 434 matching lines @@
 
   ExpectConfig();
 }
 
 TEST_F(SyncSetupHandlerTest, SuccessfullySetPassphrase) {
   DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", true);
   std::string args = GetConfiguration(&dict,
                                       SYNC_ALL_DATA,
                                       GetAllTypes(),
-                                      "gaia_passphrase",
+                                      "gaiaPassphrase",
                                       ENCRYPT_PASSWORDS);
   ListValue list_args;
   list_args.Append(new 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("gaia_passphrase")).
+  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) {
   DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", false);
@@ skipping 46 matching lines @@
   // We should navigate back to the configure page since we need a passphrase.
   handler_->HandleConfigure(&list_args);
 
   ExpectConfig();
 
   // Make sure we display an error message to the user due to the failed
   // passphrase.
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
-  CheckBool(dictionary, "passphrase_failed", true);
+  CheckBool(dictionary, "passphraseFailed", true);
 }
 
 // Walks through each user selectable type, and tries to sync just that single
 // data type.
 TEST_F(SyncSetupHandlerTest, TestSyncIndividualTypes) {
   for (size_t i = 0; i < arraysize(kUserSelectableTypes); ++i) {
     syncable::ModelTypeSet type_to_set;
     type_to_set.Put(kUserSelectableTypes[i]);
     std::string args = GetConfiguration(
         NULL, CHOOSE_WHAT_TO_SYNC, type_to_set, "", ENCRYPT_PASSWORDS);
@@ skipping 91 matching lines @@
   SetDefaultExpectationsForConfigPage();
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup(false);
 
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "showSyncEverythingPage", false);
   CheckBool(dictionary, "syncAllDataTypes", true);
-  CheckBool(dictionary, "apps_registered", true);
-  CheckBool(dictionary, "autofill_registered", true);
-  CheckBool(dictionary, "bookmarks_registered", true);
-  CheckBool(dictionary, "extensions_registered", true);
-  CheckBool(dictionary, "passwords_registered", true);
-  CheckBool(dictionary, "preferences_registered", true);
-  CheckBool(dictionary, "sessions_registered", true);
-  CheckBool(dictionary, "themes_registered", true);
-  CheckBool(dictionary, "typed_urls_registered", true);
-  CheckBool(dictionary, "show_passphrase", false);
+  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, "sessionsRegistered", true);
+  CheckBool(dictionary, "themesRegistered", true);
+  CheckBool(dictionary, "typedUrlsRegistered", true);
+  CheckBool(dictionary, "showPassphrase", false);
   CheckBool(dictionary, "usePassphrase", false);
-  CheckBool(dictionary, "passphrase_failed", 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));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
@@ skipping 50 matching lines @@
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
 
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup(false);
 
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
-  CheckBool(dictionary, "show_passphrase", true);
+  CheckBool(dictionary, "showPassphrase", true);
   CheckBool(dictionary, "usePassphrase", false);
-  CheckBool(dictionary, "passphrase_failed", false);
+  CheckBool(dictionary, "passphraseFailed", false);
 }
 
 TEST_F(SyncSetupHandlerTest, ShowSetupCustomPassphraseRequired) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(true));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
 
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup(false);
 
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
-  CheckBool(dictionary, "show_passphrase", true);
+  CheckBool(dictionary, "showPassphrase", true);
   CheckBool(dictionary, "usePassphrase", true);
-  CheckBool(dictionary, "passphrase_failed", false);
+  CheckBool(dictionary, "passphraseFailed", false);
 }
 
 TEST_F(SyncSetupHandlerTest, ShowSetupEncryptAll) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
   EXPECT_CALL(*mock_pss_, EncryptEverythingEnabled()).
       WillRepeatedly(Return(true));
 
   // This should display the sync setup dialog (not login).
   handler_->OpenSyncSetup(false);
 
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", true);
 }