Convert string16 -> base::string16 in components/

components/autofill/renderer/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/autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 48 matching lines @@
 // (so to avoid sending long strings through IPC).
 const size_t kMaximumTextSizeForAutofill = 1000;
 
 // The maximum number of data list elements to send to the browser process
 // via IPC (to prevent long IPC messages).
 const size_t kMaximumDataListSizeForAutofill = 30;
 
 const int kAutocheckoutClickTimeout = 3;
 
 void AppendDataListSuggestions(const WebKit::WebInputElement& element,
-                               std::vector<string16>* values,
-                               std::vector<string16>* labels,
-                               std::vector<string16>* icons,
+                               std::vector<base::string16>* values,
+                               std::vector<base::string16>* labels,
+                               std::vector<base::string16>* icons,
                                std::vector<int>* item_ids) {
   WebNodeCollection options = element.dataListOptions();
   if (options.isNull())
     return;
 
-  string16 prefix = element.editingValue();
+  base::string16 prefix = element.editingValue();
   if (element.isMultiple() &&
       element.formControlType() == WebString::fromUTF8("email")) {
-    std::vector<string16> parts;
+    std::vector<base::string16> parts;
     base::SplitStringDontTrim(prefix, ',', &parts);
     if (parts.size() > 0)
       TrimWhitespace(parts[parts.size() - 1], TRIM_LEADING, &prefix);
   }
   for (WebOptionElement option = options.firstItem().to<WebOptionElement>();
        !option.isNull(); option = options.nextItem().to<WebOptionElement>()) {
     if (!StartsWith(option.value(), prefix, false) ||
         option.value() == prefix ||
         !element.isValidValue(option.value()))
       continue;
 
     values->push_back(option.value());
     if (option.value() != option.label())
       labels->push_back(option.label());
     else
-      labels->push_back(string16());
-    icons->push_back(string16());
+      labels->push_back(base::string16());
+    icons->push_back(base::string16());
     item_ids->push_back(WebAutofillClient::MenuItemIDDataListEntry);
   }
 }
 
 // Trim the vectors before sending them to the browser process to ensure we
 // don't send too much data through the IPC.
-void TrimDataListsForIPC(std::vector<string16>* values,
-                         std::vector<string16>* labels,
-                         std::vector<string16>* icons,
+void TrimDataListsForIPC(std::vector<base::string16>* values,
+                         std::vector<base::string16>* labels,
+                         std::vector<base::string16>* icons,
                          std::vector<int>* unique_ids) {
   // Limit the size of the vectors.
   if (values->size() > kMaximumDataListSizeForAutofill) {
     values->resize(kMaximumDataListSizeForAutofill);
     labels->resize(kMaximumDataListSizeForAutofill);
     icons->resize(kMaximumDataListSizeForAutofill);
     unique_ids->resize(kMaximumDataListSizeForAutofill);
   }
 
   // Limit the size of the strings in the vectors
@@ skipping 371 matching lines @@
   if (password_autofill_agent_->TextFieldHandlingKeyDown(element, event)) {
     element_ = element;
     return;
   }
 
   if (event.windowsKeyCode == ui::VKEY_DOWN ||
       event.windowsKeyCode == ui::VKEY_UP)
     ShowSuggestions(element, true, true, true);
 }
 
-void AutofillAgent::OnSuggestionsReturned(int query_id,
-                                          const std::vector<string16>& values,
-                                          const std::vector<string16>& labels,
-                                          const std::vector<string16>& icons,
-                                          const std::vector<int>& unique_ids) {
+void AutofillAgent::OnSuggestionsReturned(
+    int query_id,
+    const std::vector<base::string16>& values,
+    const std::vector<base::string16>& labels,
+    const std::vector<base::string16>& icons,
+    const std::vector<int>& unique_ids) {
   if (query_id != autofill_query_id_)
     return;
 
   if (element_.isNull() || !element_.isFocusable())
     return;
 
-  std::vector<string16> v(values);
-  std::vector<string16> l(labels);
-  std::vector<string16> i(icons);
+  std::vector<base::string16> v(values);
+  std::vector<base::string16> l(labels);
+  std::vector<base::string16> i(icons);
   std::vector<int> ids(unique_ids);
 
   if (!element_.autoComplete() && !v.empty()) {
     // If autofill is disabled and we had suggestions, show a warning instead.
     v.assign(1, l10n_util::GetStringUTF16(IDS_AUTOFILL_WARNING_FORM_DISABLED));
-    l.assign(1, string16());
-    i.assign(1, string16());
+    l.assign(1, base::string16());
+    i.assign(1, base::string16());
     ids.assign(1, WebAutofillClient::MenuItemIDWarningMessage);
   } else if (ids.size() > 1 &&
              ids[0] == WebAutofillClient::MenuItemIDWarningMessage) {
     // If we received an autofill warning plus some autocomplete suggestions,
     // remove the autofill warning.
     v.erase(v.begin());
     l.erase(l.begin());
     i.erase(i.begin());
     ids.erase(ids.begin());
   }
@@ skipping 11 matching lines @@
   // items, identified by |unique_ids| having at least one valid value.
   bool has_autofill_item = false;
   for (size_t i = 0; i < ids.size(); ++i) {
     if (ids[i] > 0) {
       has_autofill_item = true;
       break;
     }
   }
 
   if (has_autofill_item) {
-    v.push_back(string16());
-    l.push_back(string16());
-    i.push_back(string16());
+    v.push_back(base::string16());
+    l.push_back(base::string16());
+    i.push_back(base::string16());
     ids.push_back(WebAutofillClient::MenuItemIDSeparator);
 
     if (FormWithElementIsAutofilled(element_)) {
       // The form has been auto-filled, so give the user the chance to clear the
       // form.  Append the 'Clear form' menu item.
       v.push_back(l10n_util::GetStringUTF16(IDS_AUTOFILL_CLEAR_FORM_MENU_ITEM));
-      l.push_back(string16());
-      i.push_back(string16());
+      l.push_back(base::string16());
+      i.push_back(base::string16());
       ids.push_back(WebAutofillClient::MenuItemIDClearForm);
     }
 
     // Append the 'Chrome Autofill options' menu item;
     v.push_back(l10n_util::GetStringUTF16(IDS_AUTOFILL_OPTIONS_POPUP));
-    l.push_back(string16());
-    i.push_back(string16());
+    l.push_back(base::string16());
+    i.push_back(base::string16());
     ids.push_back(WebAutofillClient::MenuItemIDAutofillOptions);
   }
 
   CombineDataListEntriesAndShow(element_, v, l, i, ids, has_autofill_item);
 }
 
 void AutofillAgent::CombineDataListEntriesAndShow(
     const WebKit::WebInputElement& element,
-    const std::vector<string16>& values,
-    const std::vector<string16>& labels,
-    const std::vector<string16>& icons,
+    const std::vector<base::string16>& values,
+    const std::vector<base::string16>& labels,
+    const std::vector<base::string16>& icons,
     const std::vector<int>& item_ids,
     bool has_autofill_item) {
-  std::vector<string16> v;
-  std::vector<string16> l;
-  std::vector<string16> i;
+  std::vector<base::string16> v;
+  std::vector<base::string16> l;
+  std::vector<base::string16> i;
   std::vector<int> ids;
 
   AppendDataListSuggestions(element, &v, &l, &i, &ids);
 
   // If there are both <datalist> items and Autofill suggestions, add a
   // separator between them.
   if (!v.empty() && !values.empty()) {
-    v.push_back(string16());
-    l.push_back(string16());
-    i.push_back(string16());
+    v.push_back(base::string16());
+    l.push_back(base::string16());
+    i.push_back(base::string16());
     ids.push_back(WebAutofillClient::MenuItemIDSeparator);
   }
 
   // Append the Autofill suggestions.
   v.insert(v.end(), values.begin(), values.end());
   l.insert(l.end(), labels.begin(), labels.end());
   i.insert(i.end(), icons.begin(), icons.end());
   ids.insert(ids.end(), item_ids.begin(), item_ids.end());
 
   if (v.empty()) {
     // No suggestions, any popup currently showing is obsolete.
     HideAutofillUi();
     return;
   }
 
   WebKit::WebView* web_view = render_view()->GetWebView();
   if (!web_view)
     return;
 
   // Send to WebKit for display.
   web_view->applyAutofillSuggestions(element, v, l, i, ids);
 
   Send(new AutofillHostMsg_DidShowAutofillSuggestions(
       routing_id(),
       has_autofill_item && !has_shown_autofill_popup_for_current_edit_));
   has_shown_autofill_popup_for_current_edit_ |= has_autofill_item;
 }
 
-void AutofillAgent::AcceptDataListSuggestion(const string16& suggested_value) {
-  string16 new_value = suggested_value;
+void AutofillAgent::AcceptDataListSuggestion(
+    const base::string16& suggested_value) {
+  base::string16 new_value = suggested_value;
   // If this element takes multiple values then replace the last part with
   // the suggestion.
   if (element_.isMultiple() &&
       element_.formControlType() == WebString::fromUTF8("email")) {
-    std::vector<string16> parts;
+    std::vector<base::string16> parts;
 
     base::SplitStringDontTrim(element_.editingValue(), ',', &parts);
     if (parts.size() == 0)
-      parts.push_back(string16());
+      parts.push_back(base::string16());
 
-    string16 last_part = parts.back();
+    base::string16 last_part = parts.back();
     // We want to keep just the leading whitespace.
     for (size_t i = 0; i < last_part.size(); ++i) {
       if (!IsWhitespace(last_part[i])) {
         last_part = last_part.substr(0, i);
         break;
       }
     }
     last_part.append(suggested_value);
     parts[parts.size() - 1] = last_part;
 
@@ skipping 41 matching lines @@
 }
 
 void AutofillAgent::OnSetAutofillActionPreview() {
   autofill_action_ = AUTOFILL_PREVIEW;
 }
 
 void AutofillAgent::OnClearPreviewedForm() {
   didClearAutofillSelection(element_);
 }
 
-void AutofillAgent::OnSetNodeText(const string16& value) {
+void AutofillAgent::OnSetNodeText(const base::string16& value) {
   SetNodeText(value, &element_);
 }
 
-void AutofillAgent::OnAcceptDataListSuggestion(const string16& value) {
+void AutofillAgent::OnAcceptDataListSuggestion(const base::string16& value) {
   AcceptDataListSuggestion(value);
 }
 
-void AutofillAgent::OnAcceptPasswordAutofillSuggestion(const string16& value) {
+void AutofillAgent::OnAcceptPasswordAutofillSuggestion(
+    const base::string16& value) {
   // We need to make sure this is handled here because the browser process
   // skipped it handling because it believed it would be handled here. If it
   // isn't handled here then the browser logic needs to be updated.
   bool handled = password_autofill_agent_->DidAcceptAutofillSuggestion(
       element_,
       value);
   DCHECK(handled);
 }
 
 void AutofillAgent::OnGetAllForms() {
@@ skipping 91 matching lines @@
     return;
 
   // If autocomplete is disabled at the form level, then we might want to show a
   // warning in place of suggestions.  However, if autocomplete is disabled
   // specifically for this field, we never want to show a warning.  Otherwise,
   // we might interfere with custom popups (e.g. search suggestions) used by the
   // website.  Note that we cannot use the WebKit method element.autoComplete()
   // as it does not allow us to distinguish the case where autocomplete is
   // disabled for *both* the element and for the form.
   // Also, if the field has no name, then we won't have values.
-  const string16 autocomplete_attribute = element.getAttribute("autocomplete");
+  const base::string16 autocomplete_attribute =
+      element.getAttribute("autocomplete");
   if (LowerCaseEqualsASCII(autocomplete_attribute, "off") ||
       element.nameForAutofill().isEmpty()) {
-    CombineDataListEntriesAndShow(element, std::vector<string16>(),
-                                  std::vector<string16>(),
-                                  std::vector<string16>(),
+    CombineDataListEntriesAndShow(element, std::vector<base::string16>(),
+                                  std::vector<base::string16>(),
+                                  std::vector<base::string16>(),
                                   std::vector<int>(), false);
     return;
   }
 
   QueryAutofillSuggestions(element, display_warning_if_disabled);
 }
 
 void AutofillAgent::QueryAutofillSuggestions(const WebInputElement& element,
                                              bool display_warning_if_disabled) {
   if (!element.document().frame())
@@ skipping 19 matching lines @@
   if (!FindFormAndFieldForInputElement(element, &form, &field, requirements)) {
     // If we didn't find the cached form, at least let autocomplete have a shot
     // at providing suggestions.
     WebFormControlElementToFormField(element, EXTRACT_VALUE, &field);
   }
 
   gfx::RectF bounding_box_scaled =
       GetScaledBoundingBox(web_view_->pageScaleFactor(), &element_);
 
   // Find the datalist values and send them to the browser process.
-  std::vector<string16> data_list_values;
-  std::vector<string16> data_list_labels;
-  std::vector<string16> data_list_icons;
+  std::vector<base::string16> data_list_values;
+  std::vector<base::string16> data_list_labels;
+  std::vector<base::string16> data_list_icons;
   std::vector<int> data_list_unique_ids;
   AppendDataListSuggestions(element_,
                             &data_list_values,
                             &data_list_labels,
                             &data_list_icons,
                             &data_list_unique_ids);
 
   TrimDataListsForIPC(&data_list_values,
                       &data_list_labels,
                       &data_list_icons,
@@ skipping 30 matching lines @@
   if (!FindFormAndFieldForInputElement(node.toConst<WebInputElement>(), &form,
                                        &field, REQUIRE_AUTOCOMPLETE)) {
     return;
   }
 
   autofill_action_ = action;
   Send(new AutofillHostMsg_FillAutofillFormData(
       routing_id(), autofill_query_id_, form, field, unique_id));
 }
 
-void AutofillAgent::SetNodeText(const string16& value,
+void AutofillAgent::SetNodeText(const base::string16& value,
                                 WebKit::WebInputElement* node) {
   did_set_node_text_ = true;
-  string16 substring = value;
+  base::string16 substring = value;
   substring = substring.substr(0, node->maxLength());
 
   node->setEditingValue(substring);
 }
 
 void AutofillAgent::HideAutofillUi() {
   WebKit::WebView* web_view = render_view()->GetWebView();
   if (web_view)
     web_view->hidePopups();
 
   HideHostAutofillUi();
 }
 
 void AutofillAgent::HideHostAutofillUi() {
   Send(new AutofillHostMsg_HideAutofillUi(routing_id()));
 }
 
 }  // namespace autofill