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

chrome/renderer/autofill/password_autofill_agent_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 "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "components/autofill/common/autofill_messages.h"
 #include "components/autofill/common/form_data.h"
 #include "components/autofill/common/form_field_data.h"
@@ skipping 233 matching lines @@
 TEST_F(PasswordAutofillAgentTest, NoInitialAutocompleteForReadOnly) {
   password_element_.setAttribute(WebString::fromUTF8("readonly"),
                                  WebString::fromUTF8("true"));
 
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Only the username should have been autocompleted.
   // TODO(jcivelli): may be we should not event fill the username?
-  CheckTextFieldsState(kAliceUsername, true, "", false);
+  CheckTextFieldsState(kAliceUsername, true, std::string(), false);
 }
 
 // Tests that having a non-matching username precludes the autocomplete.
 TEST_F(PasswordAutofillAgentTest, NoInitialAutocompleteForFilledField) {
   username_element_.setValue(WebString::fromUTF8("bogus"));
 
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Neither field should be autocompleted.
-  CheckTextFieldsState("bogus", false, "", false);
+  CheckTextFieldsState("bogus", false, std::string(), false);
 }
 
 // Tests that having a matching username does not preclude the autocomplete.
 TEST_F(PasswordAutofillAgentTest, InitialAutocompleteForMatchingFilledField) {
   username_element_.setValue(WebString::fromUTF8(kAliceUsername));
 
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // The username and password should have been autocompleted.
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 }
 
 // Tests that editing the password clears the autocompleted password field.
 TEST_F(PasswordAutofillAgentTest, PasswordClearOnEdit) {
   // Simulate the browser sending back the login info, it triggers the
   // autocomplete.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Simulate the user changing the username to some unknown username.
   SimulateUsernameChange("alicia", true);
 
   // The password should have been cleared.
-  CheckTextFieldsState("alicia", false, "", false);
+  CheckTextFieldsState("alicia", false, std::string(), false);
 }
 
 // Tests that we only autocomplete on focus lost and with a full username match
 // when |wait_for_username| is true.
 TEST_F(PasswordAutofillAgentTest, WaitUsername) {
   // Simulate the browser sending back the login info.
   fill_data_.wait_for_username = true;
   SimulateOnFillPasswordForm(fill_data_);
 
   // No auto-fill should have taken place.
-  CheckTextFieldsState("", false, "", false);
+  CheckTextFieldsState(std::string(), false, std::string(), false);
 
   // No autocomplete should happen when text is entered in the username.
   SimulateUsernameChange("a", true);
-  CheckTextFieldsState("a", false, "", false);
+  CheckTextFieldsState("a", false, std::string(), false);
   SimulateUsernameChange("al", true);
-  CheckTextFieldsState("al", false, "", false);
+  CheckTextFieldsState("al", false, std::string(), false);
   SimulateUsernameChange(kAliceUsername, true);
-  CheckTextFieldsState(kAliceUsername, false, "", false);
+  CheckTextFieldsState(kAliceUsername, false, std::string(), false);
 
   // Autocomplete should happen only when the username textfield is blurred with
   // a full match.
   username_element_.setValue("a");
   autofill_agent_->textFieldDidEndEditing(username_element_);
-  CheckTextFieldsState("a", false, "", false);
+  CheckTextFieldsState("a", false, std::string(), false);
   username_element_.setValue("al");
   autofill_agent_->textFieldDidEndEditing(username_element_);
-  CheckTextFieldsState("al", false, "", false);
+  CheckTextFieldsState("al", false, std::string(), false);
   username_element_.setValue("alices");
   autofill_agent_->textFieldDidEndEditing(username_element_);
-  CheckTextFieldsState("alices", false, "", false);
+  CheckTextFieldsState("alices", false, std::string(), false);
   username_element_.setValue(ASCIIToUTF16(kAliceUsername));
   autofill_agent_->textFieldDidEndEditing(username_element_);
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
 }
 
 // Tests that inline autocompletion works properly.
 TEST_F(PasswordAutofillAgentTest, InlineAutocomplete) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
@@ skipping 11 matching lines @@
   // Now the user types the next letter of the same username, 'l'.
   SimulateUsernameChange("al", true);
   // Now the fields should have the same value, but the selection should have a
   // different start value.
   CheckTextFieldsState(kAliceUsername, true, kAlicePassword, true);
   CheckUsernameSelection(2, 5);
 
   // Test that deleting does not trigger autocomplete.
   SimulateKeyDownEvent(username_element_, ui::VKEY_BACK);
   SimulateUsernameChange("alic", true);
-  CheckTextFieldsState("alic", false, "", false);
+  CheckTextFieldsState("alic", false, std::string(), false);
   CheckUsernameSelection(4, 4);  // No selection.
   // Reset the last pressed key to something other than backspace.
   SimulateKeyDownEvent(username_element_, ui::VKEY_A);
 
   // Now lets say the user goes astray from the stored username and types the
   // letter 'f', spelling 'alf'.  We don't know alf (that's just sad), so in
   // practice the username should no longer be 'alice' and the selected range
   // should be empty.
   SimulateUsernameChange("alf", true);
-  CheckTextFieldsState("alf", false, "", false);
+  CheckTextFieldsState("alf", false, std::string(), false);
   CheckUsernameSelection(3, 3);  // No selection.
 
   // Ok, so now the user removes all the text and enters the letter 'b'.
   SimulateUsernameChange("b", true);
   // The username and password fields should match the 'bob' entry.
   CheckTextFieldsState(kBobUsername, true, kBobPassword, true);
   CheckUsernameSelection(1, 3);
 
   // Then, the user again removes all the text and types an uppercase 'C'.
   SimulateUsernameChange("C", true);
   // The username and password fields should match the 'Carol' entry.
   CheckTextFieldsState(kCarolUsername, true, kCarolPassword, true);
   CheckUsernameSelection(1, 5);
   // Finally, the user removes all the text and types a lowercase 'c'.  We only
   // want case-sensitive autocompletion, so the username and the selected range
   // should be empty.
   SimulateUsernameChange("c", true);
-  CheckTextFieldsState("c", false, "", false);
+  CheckTextFieldsState("c", false, std::string(), false);
   CheckUsernameSelection(1, 1);
 }
 
 // Tests that accepting an item in the suggestion drop-down works.
 TEST_F(PasswordAutofillAgentTest, SuggestionAccept) {
   // Simulate the browser sending back the login info.
   SimulateOnFillPasswordForm(fill_data_);
 
   // Clear the text fields to start fresh.
   ClearUsernameAndPasswordFields();
@@ skipping 19 matching lines @@
   ClearUsernameAndPasswordFields();
 
   // To simulate accepting an item in the suggestion drop-down we just mimic
   // what the WebView does: it sets the element value then calls
   // didSelectAutofillSuggestion on the renderer.
   autofill_agent_->didSelectAutofillSuggestion(username_element_,
                                                ASCIIToUTF16(kAliceUsername),
                                                WebKit::WebString(),
                                                0);
   // Autocomplete should not have kicked in.
-  CheckTextFieldsState("", false, "", false);
+  CheckTextFieldsState(std::string(), false, std::string(), false);
 }
 
 }  // namespace autofill