Modify the base::JSONReader interface to take a set of options rather than a boolean flag.

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 77 matching lines @@
 
 static const size_t kNumDataTypes = arraysize(kDataTypes);
 COMPILE_ASSERT(arraysize(kDataTypeNames) == arraysize(kDataTypes),
                kDataTypes_does_not_match_kDataTypeNames);
 
 bool GetAuthData(const std::string& json,
                  std::string* username,
                  std::string* password,
                  std::string* captcha,
                  std::string* access_code) {
-  scoped_ptr<Value> parsed_value(base::JSONReader::Read(json, false));
+  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)) {
       return false;
   }
   return true;
 }
 
 bool GetConfiguration(const std::string& json, SyncConfigInfo* config) {
-  scoped_ptr<Value> parsed_value(base::JSONReader::Read(json, false));
+  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;
   }
@@ skipping 30 matching lines @@
     }
     if (!result->GetString("passphrase", &config->passphrase)) {
       DLOG(ERROR) << "GetConfiguration() not passed a passphrase value";
       return false;
     }
   }
   return true;
 }
 
 bool GetPassphrase(const std::string& json, std::string* passphrase) {
-  scoped_ptr<Value> parsed_value(base::JSONReader::Read(json, false));
+  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());
   return result->GetString("passphrase", passphrase);
 }
 
 string16 NormalizeUserName(const string16& user) {
   if (user.find_first_of(ASCIIToUTF16("@")) != string16::npos)
     return user;
@@ skipping 538 matching lines @@
   if (configuration.passphrase_is_gaia && !configuration.passphrase.empty())
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_PASSPHRASE);
   if (!configuration.sync_everything)
     ProfileMetrics::LogProfileSyncInfo(ProfileMetrics::SYNC_CHOOSE);
 }
 
 void SyncSetupHandler::HandleAttachHandler(const ListValue* args) {
   bool force_login = false;
   std::string json;
   if (args->GetString(0, &json) && !json.empty()) {
-    scoped_ptr<Value> parsed_value(base::JSONReader::Read(json, false));
+    scoped_ptr<Value> parsed_value(base::JSONReader::Read(json));
     DictionaryValue* result = static_cast<DictionaryValue*>(parsed_value.get());
     result->GetBoolean("forceLogin", &force_login);
   }
 
   OpenSyncSetup(force_login);
 }
 
 void SyncSetupHandler::HandleShowErrorUI(const ListValue* args) {
   DCHECK(!configuring_sync_);
 
@@ skipping 167 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;
 }