Convert string16 -> base::string16 in components/

components/autofill/renderer/password_autofill_agent.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 "components/autofill/renderer/password_autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "components/autofill/common/autofill_messages.h"
@@ skipping 13 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
 namespace {
 
 // The size above which we stop triggering autocomplete.
 static const size_t kMaximumTextSizeForAutocomplete = 1000;
 
 // Maps element names to the actual elements to simplify form filling.
-typedef std::map<string16, WebKit::WebInputElement>
+typedef std::map<base::string16, WebKit::WebInputElement>
     FormInputElementMap;
 
 // Utility struct for form lookup and autofill. When we parse the DOM to look up
 // a form, in addition to action and origin URL's we have to compare all
 // necessary form elements. To avoid having to look these up again when we want
 // to fill the form, the FindFormElements function stores the pointers
 // in a FormElements* result, referenced to ensure they are safe to use.
 struct FormElements {
   WebKit::WebFormElement form_element;
   FormInputElementMap input_elements;
@@ skipping 103 matching lines @@
 }
 
 bool IsElementEditable(const WebKit::WebInputElement& element) {
   return element.isEnabled() && !element.isReadOnly();
 }
 
 void FillForm(FormElements* fe, const FormData& data) {
   if (!fe->form_element.autoComplete())
     return;
 
-  std::map<string16, string16> data_map;
+  std::map<base::string16, base::string16> data_map;
   for (size_t i = 0; i < data.fields.size(); i++)
     data_map[data.fields[i].name] = data.fields[i].value;
 
   for (FormInputElementMap::iterator it = fe->input_elements.begin();
        it != fe->input_elements.end(); ++it) {
     WebKit::WebInputElement element = it->second;
     // Don't fill a form that has pre-filled values distinct from the ones we
     // want to fill with.
     if (!element.value().isEmpty() && element.value() != data_map[it->first])
       return;
@@ skipping 13 matching lines @@
 }
 
 void SetElementAutofilled(WebKit::WebInputElement* element, bool autofilled) {
   if (element->isAutofilled() == autofilled)
     return;
   element->setAutofilled(autofilled);
   // Notify any changeEvent listeners.
   element->dispatchFormControlChangeEvent();
 }
 
-bool DoUsernamesMatch(const string16& username1,
-                      const string16& username2,
+bool DoUsernamesMatch(const base::string16& username1,
+                      const base::string16& username2,
                       bool exact_match) {
   if (exact_match)
     return username1 == username2;
   return StartsWith(username1, username2, true);
 }
 
 }  // namespace
 
 namespace autofill {
 
@@ skipping 42 matching lines @@
       login_to_password_info_.find(element);
   if (iter == login_to_password_info_.end())
     return false;
 
   // The input text is being changed, so any autofilled password is now
   // outdated.
   WebKit::WebInputElement username = element;  // We need a non-const.
   WebKit::WebInputElement password = iter->second.password_field;
   SetElementAutofilled(&username, false);
   if (password.isAutofilled()) {
-    password.setValue(string16());
+    password.setValue(base::string16());
     SetElementAutofilled(&password, false);
   }
 
   // If wait_for_username is true we will fill when the username loses focus.
   if (iter->second.fill_data.wait_for_username)
     return false;
 
   if (!IsElementEditable(element) ||
       !element.isText() ||
       !element.autoComplete()) {
@@ skipping 212 matching lines @@
         field,
         form_data));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, private:
 
 void PasswordAutofillAgent::GetSuggestions(
     const PasswordFormFillData& fill_data,
-    const string16& input,
-    std::vector<string16>* suggestions) {
+    const base::string16& input,
+    std::vector<base::string16>* suggestions) {
   if (StartsWith(fill_data.basic_data.fields[0].value, input, false))
     suggestions->push_back(fill_data.basic_data.fields[0].value);
 
   PasswordFormFillData::LoginCollection::const_iterator iter;
   for (iter = fill_data.additional_logins.begin();
        iter != fill_data.additional_logins.end(); ++iter) {
     if (StartsWith(iter->first, input, false))
       suggestions->push_back(iter->first);
   }
 }
 
 bool PasswordAutofillAgent::ShowSuggestionPopup(
     const PasswordFormFillData& fill_data,
     const WebKit::WebInputElement& user_input) {
   WebKit::WebFrame* frame = user_input.document().frame();
   if (!frame)
     return false;
 
   WebKit::WebView* webview = frame->view();
   if (!webview)
     return false;
 
-  std::vector<string16> suggestions;
+  std::vector<base::string16> suggestions;
   GetSuggestions(fill_data, user_input.value(), &suggestions);
 
   if (disable_popup_) {
     FormData form;
     FormFieldData field;
     FindFormAndFieldForInputElement(
         user_input, &form, &field, REQUIRE_NONE);
 
     WebKit::WebInputElement selected_element = user_input;
     gfx::Rect bounding_box(selected_element.boundsInViewportSpace());
 
     float scale = web_view_->pageScaleFactor();
     gfx::RectF bounding_box_scaled(bounding_box.x() * scale,
                                    bounding_box.y() * scale,
                                    bounding_box.width() * scale,
                                    bounding_box.height() * scale);
     Send(new AutofillHostMsg_ShowPasswordSuggestions(routing_id(),
                                                      field,
                                                      bounding_box_scaled,
                                                      suggestions));
     return !suggestions.empty();
   }
 
 
   if (suggestions.empty()) {
     webview->hidePopups();
     return false;
   }
 
-  std::vector<string16> labels(suggestions.size());
-  std::vector<string16> icons(suggestions.size());
+  std::vector<base::string16> labels(suggestions.size());
+  std::vector<base::string16> icons(suggestions.size());
   std::vector<int> ids(suggestions.size(),
                        WebKit::WebAutofillClient::MenuItemIDPasswordEntry);
   webview->applyAutofillSuggestions(
       user_input, suggestions, labels, icons, ids);
   return true;
 }
 
 bool PasswordAutofillAgent::FillUserNameAndPassword(
     WebKit::WebInputElement* username_element,
     WebKit::WebInputElement* password_element,
     const PasswordFormFillData& fill_data,
     bool exact_username_match,
     bool set_selection) {
-  string16 current_username = username_element->value();
+  base::string16 current_username = username_element->value();
   // username and password will contain the match found if any.
-  string16 username;
-  string16 password;
+  base::string16 username;
+  base::string16 password;
 
   // Look for any suitable matches to current field text.
   if (DoUsernamesMatch(fill_data.basic_data.fields[0].value, current_username,
                        exact_username_match)) {
     username = fill_data.basic_data.fields[0].value;
     password = fill_data.basic_data.fields[1].value;
   } else {
     // Scan additional logins for a match.
     PasswordFormFillData::LoginCollection::const_iterator iter;
     for (iter = fill_data.additional_logins.begin();
@@ skipping 76 matching lines @@
   LoginToPasswordInfoMap::iterator iter = login_to_password_info_.find(input);
   if (iter == login_to_password_info_.end())
     return false;
 
   *found_input = input;
   *found_password = iter->second;
   return true;
 }
 
 }  // namespace autofill