Sync UI: Use camelCase for variables sent to JS.

chrome/browser/ui/webui/sync_setup_handler.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 "base/bind.h"
 #include "base/basictypes.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 53 matching lines @@
 
 const char* kDataTypeNames[] = {
   "apps",
   "autofill",
   "bookmarks",
   "extensions",
   "passwords",
   "preferences",
   "sessions",
   "themes",
-  "typed_urls"
+  "typedUrls"
 };
 
 const syncable::ModelType kDataTypes[] = {
   syncable::APPS,
   syncable::AUTOFILL,
   syncable::BOOKMARKS,
   syncable::EXTENSIONS,
   syncable::PASSWORDS,
   syncable::PREFERENCES,
   syncable::SESSIONS,
@@ skipping 11 matching lines @@
                  std::string* captcha,
                  std::string* access_code) {
   scoped_ptr<Value> parsed_value(base::JSONReader::Read(json));
   if (!parsed_value.get() || !parsed_value->IsType(Value::TYPE_DICTIONARY))
     return false;
 
   DictionaryValue* result = static_cast<DictionaryValue*>(parsed_value.get());
   if (!result->GetString("user", username) ||
       !result->GetString("pass", password) ||
       !result->GetString("captcha", captcha) ||
-      !result->GetString("access_code", access_code)) {
+      !result->GetString("accessCode", access_code)) {
       return false;
   }
   return true;
 }
 
 bool GetConfiguration(const std::string& json, SyncConfigInfo* config) {
   scoped_ptr<Value> parsed_value(base::JSONReader::Read(json));
   DictionaryValue* result;
   if (!parsed_value.get() || !parsed_value->GetAsDictionary(&result)) {
     DLOG(ERROR) << "GetConfiguration() not passed a Dictionary";
     return false;
   }
 
   if (!result->GetBoolean("syncAllDataTypes", &config->sync_everything)) {
     DLOG(ERROR) << "GetConfiguration() not passed a syncAllDataTypes value";
     return false;
   }
 
   for (size_t i = 0; i < arraysize(kDataTypeNames); ++i) {
-    std::string key_name = std::string("sync_") + kDataTypeNames[i];
+    std::string key_name = kDataTypeNames[i] + std::string("Synced");
     bool sync_value;
     if (!result->GetBoolean(key_name, &sync_value)) {
       DLOG(ERROR) << "GetConfiguration() not passed a value for " << key_name;
       return false;
     }
     if (sync_value)
       config->data_types.Put(kDataTypes[i]);
   }
 
   // Encryption settings.
@@ skipping 205 matching lines @@
   // SigninTracker.
   signin_tracker_.reset();
   configuring_sync_ = true;
   ProfileSyncService* service = GetSyncService();
   DCHECK(service->sync_initialized()) <<
       "Cannot configure sync until the sync backend is initialized";
 
   // Setup args for the sync configure screen:
   //   showSyncEverythingPage: false to skip directly to the configure screen
   //   syncAllDataTypes: true if the user wants to sync everything
-  //   <data_type>_registered: true if the associated data type is supported
-  //   sync_<data_type>: true if the user wants to sync that specific data type
+  //   <data_type>Registered: true if the associated data type is supported
+  //   <data_type>Synced: true if the user wants to sync that specific data type
   //   encryptionEnabled: true if sync supports encryption
   //   encryptAllData: true if user wants to encrypt all data (not just
   //       passwords)
   //   usePassphrase: true if the data is encrypted with a secondary passphrase
   //   show_passphrase: true if a passphrase is needed to decrypt the sync data
-  // TODO(atwilson): Convert all to unix_hacker style (http://crbug.com/119646).
   DictionaryValue args;
 
   // Tell the UI layer which data types are registered/enabled by the user.
   const syncable::ModelTypeSet registered_types =
       service->GetRegisteredDataTypes();
   const syncable::ModelTypeSet preferred_types =
       service->GetPreferredDataTypes();
   for (size_t i = 0; i < kNumDataTypes; ++i) {
     const std::string key_name = kDataTypeNames[i];
-    args.SetBoolean(key_name + "_registered",
+    args.SetBoolean(key_name + "Registered",
                     registered_types.Has(kDataTypes[i]));
-    args.SetBoolean("sync_" + key_name, preferred_types.Has(kDataTypes[i]));
+    args.SetBoolean(key_name + "Synced", preferred_types.Has(kDataTypes[i]));
   }
   browser_sync::SyncPrefs sync_prefs(GetProfile()->GetPrefs());
-  args.SetBoolean("passphrase_failed", passphrase_failed);
+  args.SetBoolean("passphraseFailed", passphrase_failed);
   args.SetBoolean("showSyncEverythingPage", !show_advanced);
   args.SetBoolean("syncAllDataTypes", sync_prefs.HasKeepEverythingSynced());
   args.SetBoolean("encryptAllData", service->EncryptEverythingEnabled());
   args.SetBoolean("usePassphrase", service->IsUsingSecondaryPassphrase());
   // We call IsPassphraseRequired() here, instead of calling
   // IsPassphraseRequiredForDecryption(), because we want to show the passphrase
   // UI even if no encrypted data types are enabled.
-  args.SetBoolean("show_passphrase", service->IsPassphraseRequired());
+  args.SetBoolean("showPassphrase", service->IsPassphraseRequired());
 
   StringValue page("configure");
   web_ui()->CallJavascriptFunction(
       "SyncSetupOverlay.showSyncSetupPage", page, args);
 }
 
 void SyncSetupHandler::ConfigureSyncDone() {
   StringValue page("done");
   web_ui()->CallJavascriptFunction(
       "SyncSetupOverlay.showSyncSetupPage", page);
@@ skipping 83 matching lines @@
   } else {
     // Fresh login attempt - lock in the authenticated username if there is
     // one (don't let the user change it).
     user = GetSignin()->GetAuthenticatedUsername();
     error = 0;
     editable_user = user.empty();
   }
   DictionaryValue args;
   args.SetString("user", user);
   args.SetInteger("error", error);
-  args.SetBoolean("editable_user", editable_user);
+  args.SetBoolean("editableUser", editable_user);
   if (!error_message.empty())
-    args.SetString("error_message", error_message);
+    args.SetString("errorMessage", error_message);
   if (fatal_error)
     args.SetBoolean("fatalError", true);
   args.SetString("captchaUrl", captcha);
   StringValue page("login");
   web_ui()->CallJavascriptFunction(
       "SyncSetupOverlay.showSyncSetupPage", page, args);
 }
 
 // TODO(kochi): Handle error conditions (timeout, other failures).
 void SyncSetupHandler::DisplaySpinner() {
@@ skipping 404 matching lines @@
     if (i != current_profile_index && AreUserNamesEqual(
         cache.GetUserNameOfProfileAtIndex(i), username_utf16)) {
       *error_message = l10n_util::GetStringUTF16(
           IDS_SYNC_USER_NAME_IN_USE_ERROR);
       return false;
     }
   }
 
   return true;
 }