Convert string16 -> base::string16 in components/

components/autofill/renderer/form_cache.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/form_cache.h"
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "components/autofill/common/autofill_constants.h"
 #include "components/autofill/common/form_data.h"
@@ skipping 173 matching lines @@
   ExtractAutofillableElements(form_element, autofill::REQUIRE_NONE,
                               &control_elements);
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement control_element = control_elements[i];
     WebInputElement* input_element = toWebInputElement(&control_element);
     if (IsTextInput(input_element)) {
       // We don't modify the value of disabled fields.
       if (!input_element->isEnabled())
         continue;
 
-      input_element->setValue(string16(), true);
+      input_element->setValue(base::string16(), true);
       input_element->setAutofilled(false);
 
       // Clearing the value in the focused node (above) can cause selection
       // to be lost. We force selection range to restore the text cursor.
       if (element == *input_element) {
         int length = input_element->value().length();
         input_element->setSelectionRange(length, length);
       }
     } else if (IsSelectElement(control_element)) {
       WebSelectElement select_element = control_element.to<WebSelectElement>();
 
-      std::map<const WebSelectElement, string16>::const_iterator
+      std::map<const WebSelectElement, base::string16>::const_iterator
           initial_value_iter = initial_select_values_.find(select_element);
       if (initial_value_iter != initial_select_values_.end() &&
           select_element.value() != initial_value_iter->second) {
         select_element.setValue(initial_value_iter->second);
         select_element.dispatchFormControlChangeEvent();
       }
     } else {
       WebInputElement input_element = control_element.to<WebInputElement>();
       DCHECK(IsCheckableElement(&input_element));
       std::map<const WebInputElement, bool>::const_iterator it =
@@ skipping 23 matching lines @@
       form_element = web_forms[i];
 
       // Note: matching on the form name here which is not guaranteed to be
       // unique for the page, nor is it guaranteed to be non-empty.  Ideally, we
       // would have a way to uniquely identify the form cross-process.  For now,
       // we'll check form name and form action for identity.
       // Also note that WebString() == WebString(string16()) does not evaluate
       // to |true| -- WebKit distinguishes between a "null" string (lhs) and an
       // "empty" string (rhs).  We don't want that distinction, so forcing to
       // string16.
-      string16 element_name = GetFormIdentifier(form_element);
+      base::string16 element_name = GetFormIdentifier(form_element);
       GURL action(form_element.document().completeURL(form_element.action()));
       if (element_name == form.data.name && action == form.data.action) {
         found_form = true;
         break;
       }
     }
   }
 
   if (!found_form)
     return false;
 
   std::vector<WebFormControlElement> control_elements;
   ExtractAutofillableElements(form_element, autofill::REQUIRE_NONE,
                               &control_elements);
   if (control_elements.size() != form.fields.size()) {
     // Keep things simple.  Don't show predictions for forms that were modified
     // between page load and the server's response to our query.
     return false;
   }
 
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement* element = &control_elements[i];
 
-    if (string16(element->nameForAutofill()) != form.data.fields[i].name) {
+    if (base::string16(element->nameForAutofill()) !=
+        form.data.fields[i].name) {
       // Keep things simple.  Don't show predictions for elements whose names
       // were modified between page load and the server's response to our query.
       continue;
     }
 
     std::string placeholder = form.fields[i].overall_type;
-    string16 title = l10n_util::GetStringFUTF16(
+    base::string16 title = l10n_util::GetStringFUTF16(
         IDS_AUTOFILL_SHOW_PREDICTIONS_TITLE,
         UTF8ToUTF16(form.fields[i].heuristic_type),
         UTF8ToUTF16(form.fields[i].server_type),
         UTF8ToUTF16(form.fields[i].signature),
         UTF8ToUTF16(form.signature),
         UTF8ToUTF16(form.experiment_id));
     if (!element->hasAttribute("placeholder"))
       element->setAttribute("placeholder", WebString(UTF8ToUTF16(placeholder)));
     element->setAttribute("title", WebString(title));
   }
 
   return true;
 }
 
 }  // namespace autofill