Rewrite std::string("") to std::string(), Linux edition.

chrome/browser/ui/webui/options/preferences_browsertest.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/preferences_browsertest.h"
 
 #include <iostream>
 #include <sstream>
 
 #include "base/json/json_reader.h"
@@ skipping 325 matching lines @@
   base::JSONWriter::Write(commit_ptr.get(), &commit_json);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.set" << type.c_str() << "Pref("
              << "      '" << name.c_str() << "',"
              << "      " << value_json.c_str() << ","
              << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), &observed_json));
-  VerifyObservedPref(observed_json, name, value, "", false, !commit);
+  VerifyObservedPref(observed_json, name, value, std::string(), false, !commit);
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyClearPref(const std::string& name,
                                              const base::Value* value,
                                              bool commit) {
   if (commit)
     ExpectClearCommit(name);
   else
     ExpectNoCommit(name);
@@ skipping 21 matching lines @@
              << "        '" << name.c_str() << "');});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, controlledBy, false, false);
 }
 
 void PreferencesBrowserTest::VerifySetCommit(const std::string& name,
                                              const base::Value* value) {
   ExpectSetCommit(name, value);
-  VerifyCommit(name, value, "");
+  VerifyCommit(name, value, std::string());
   VerifyAndClearExpectations();
 }
 
 void PreferencesBrowserTest::VerifyClearCommit(const std::string& name,
                                                const base::Value* value) {
   ExpectClearCommit(name);
   VerifyCommit(name, value, "recommended");
   VerifyAndClearExpectations();
 }
 
@@ skipping 70 matching lines @@
 }
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, FetchPrefs) {
   UseDefaultTestPrefs(true);
   std::string observed_json;
 
   // Verify notifications when default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, default_values_,
-                      "", false, false);
+  VerifyObservedPrefs(
+      observed_json, pref_names_, default_values_, std::string(), false, false);
 
   // Verify notifications when recommended values are in effect.
   SetUserPolicies(policy_names_, non_default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "recommended", false, false);
 
   // Verify notifications when mandatory values are in effect.
   SetUserPolicies(policy_names_, non_default_values_,
                   policy::POLICY_LEVEL_MANDATORY);
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "policy", true, false);
 
   // Verify notifications when user-modified values are in effect.
   ClearUserPolicies();
   SetUserValues(pref_names_, non_default_values_);
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
-                      "", false, false);
+  VerifyObservedPrefs(observed_json,
+                      pref_names_,
+                      non_default_values_,
+                      std::string(),
+                      false,
+                      false);
 }
 
 // Verifies that setting a user-modified pref value through the JavaScript
 // Preferences class fires the correct notification in JavaScript and causes the
 // change to be committed to the C++ backend.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, SetPrefs) {
   UseDefaultTestPrefs(false);
 
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i)
@@ skipping 31 matching lines @@
 // Verifies that when the user-modified value of a dialog pref is set and the
 // change then rolled back through the JavaScript Preferences class, the correct
 // notifications fire and no commit to the C++ backend occurs.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, DialogPrefsSetRollback) {
   UseDefaultTestPrefs(false);
 
   // Verify behavior when default values are in effect.
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifySetPref(pref_names_[i], types_[i], non_default_values_[i], false);
-    VerifyRollback(pref_names_[i], default_values_[i], "");
+    VerifyRollback(pref_names_[i], default_values_[i], std::string());
   }
 
   // Verify behavior when recommended values are in effect.
   SetUserPolicies(policy_names_, default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifySetPref(pref_names_[i], types_[i], non_default_values_[i], false);
     VerifyRollback(pref_names_[i], default_values_[i], "recommended");
   }
@@ skipping 21 matching lines @@
 // correct notifications fire and no commit to the C++ backend occurs.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, DialogPrefsClearRollback) {
   UseDefaultTestPrefs(false);
 
   SetUserPolicies(policy_names_, default_values_,
                   policy::POLICY_LEVEL_RECOMMENDED);
   SetUserValues(pref_names_, non_default_values_);
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
   for (size_t i = 0; i < pref_names_.size(); ++i) {
     VerifyClearPref(pref_names_[i], default_values_[i], false);
-    VerifyRollback(pref_names_[i], non_default_values_[i], "");
+    VerifyRollback(pref_names_[i], non_default_values_[i], std::string());
   }
 }
 
 // Verifies that when preference values change in the C++ backend, the correct
 // notifications fire in JavaScript.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, NotificationsOnBackendChanges) {
   UseDefaultTestPrefs(false);
   std::string observed_json;
 
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
@@ skipping 11 matching lines @@
   SetUserPolicies(policy_names_, non_default_values_,
                   policy::POLICY_LEVEL_MANDATORY);
   FinishObserving(&observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "policy", true, false);
 
   // Verify notifications when default values come into effect.
   StartObserving();
   ClearUserPolicies();
   FinishObserving(&observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, default_values_,
-                      "", false, false);
+  VerifyObservedPrefs(
+      observed_json, pref_names_, default_values_, std::string(), false, false);
 
   // Verify notifications when user-modified values come into effect.
   StartObserving();
   SetUserValues(pref_names_, non_default_values_);
   FinishObserving(&observed_json);
-  VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
-                      "", false, false);
+  VerifyObservedPrefs(observed_json,
+                      pref_names_,
+                      non_default_values_,
+                      std::string(),
+                      false,
+                      false);
 }
 
 #if defined(OS_CHROMEOS)
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for pref values handled by the
 // CoreChromeOSOptionsHandler class.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, ChromeOSDeviceFetchPrefs) {
   std::vector<base::Value*> decorated_non_default_values;
   std::string observed_json;
@@ skipping 92 matching lines @@
   // Do not set the Boolean pref. It will toogle automatically.
   for (size_t i = 1; i < pref_names_.size(); ++i)
     chromeos::proxy_cros_settings_parser::SetProxyPrefValue(
         profile, pref_names_[i], non_default_values_[i]->DeepCopy());
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_,
                       "", false, false);
 }
 
 #endif