Convert string16 -> base::string16 in components/

components/autofill/renderer/form_autofill_util.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_autofill_util.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 86 matching lines @@
 // has leading whitespace.
 // A few examples:
 //  * CombineAndCollapseWhitespace("foo", "bar", false)       -> "foobar"
 //  * CombineAndCollapseWhitespace("foo", "bar", true)        -> "foo bar"
 //  * CombineAndCollapseWhitespace("foo ", "bar", false)      -> "foo bar"
 //  * CombineAndCollapseWhitespace("foo", " bar", false)      -> "foo bar"
 //  * CombineAndCollapseWhitespace("foo", " bar", true)       -> "foo bar"
 //  * CombineAndCollapseWhitespace("foo   ", "   bar", false) -> "foo bar"
 //  * CombineAndCollapseWhitespace(" foo", "bar ", false)     -> " foobar "
 //  * CombineAndCollapseWhitespace(" foo", "bar ", true)      -> " foo bar "
-const string16 CombineAndCollapseWhitespace(const string16& prefix,
-                                            const string16& suffix,
-                                            bool force_whitespace) {
-  string16 prefix_trimmed;
+const base::string16 CombineAndCollapseWhitespace(
+    const base::string16& prefix,
+    const base::string16& suffix,
+    bool force_whitespace) {
+  base::string16 prefix_trimmed;
   TrimPositions prefix_trailing_whitespace =
       TrimWhitespace(prefix, TRIM_TRAILING, &prefix_trimmed);
 
   // Recursively compute the children's text.
-  string16 suffix_trimmed;
+  base::string16 suffix_trimmed;
   TrimPositions suffix_leading_whitespace =
       TrimWhitespace(suffix, TRIM_LEADING, &suffix_trimmed);
 
   if (prefix_trailing_whitespace || suffix_leading_whitespace ||
       force_whitespace) {
     return prefix_trimmed + ASCIIToUTF16(" ") + suffix_trimmed;
   } else {
     return prefix_trimmed + suffix_trimmed;
   }
 }
 
 // This is a helper function for the FindChildText() function (see below).
 // Search depth is limited with the |depth| parameter.
-string16 FindChildTextInner(const WebNode& node, int depth) {
+base::string16 FindChildTextInner(const WebNode& node, int depth) {
   if (depth <= 0 || node.isNull())
-    return string16();
+    return base::string16();
 
   // Skip over comments.
   if (node.nodeType() == WebNode::CommentNode)
     return FindChildTextInner(node.nextSibling(), depth - 1);
 
   if (node.nodeType() != WebNode::ElementNode &&
       node.nodeType() != WebNode::TextNode)
-    return string16();
+    return base::string16();
 
   // Ignore elements known not to contain inferable labels.
   if (node.isElementNode()) {
     const WebElement element = node.toConst<WebElement>();
     if (IsOptionElement(element) ||
         IsScriptElement(element) ||
         IsNoScriptElement(element) ||
         (element.isFormControlElement() &&
          IsAutofillableElement(element.toConst<WebFormControlElement>()))) {
-      return string16();
+      return base::string16();
     }
   }
 
   // Extract the text exactly at this node.
-  string16 node_text = node.nodeValue();
+  base::string16 node_text = node.nodeValue();
 
   // Recursively compute the children's text.
   // Preserve inter-element whitespace separation.
-  string16 child_text = FindChildTextInner(node.firstChild(), depth - 1);
+  base::string16 child_text = FindChildTextInner(node.firstChild(), depth - 1);
   bool add_space = node.nodeType() == WebNode::TextNode && node_text.empty();
   node_text = CombineAndCollapseWhitespace(node_text, child_text, add_space);
 
   // Recursively compute the siblings' text.
   // Again, preserve inter-element whitespace separation.
-  string16 sibling_text = FindChildTextInner(node.nextSibling(), depth - 1);
+  base::string16 sibling_text =
+      FindChildTextInner(node.nextSibling(), depth - 1);
   add_space = node.nodeType() == WebNode::TextNode && node_text.empty();
   node_text = CombineAndCollapseWhitespace(node_text, sibling_text, add_space);
 
   return node_text;
 }
 
 // Returns the aggregated values of the descendants of |element| that are
 // non-empty text nodes.  This is a faster alternative to |innerText()| for
 // performance critical operations.  It does a full depth-first search so can be
 // used when the structure is not directly known.  However, unlike with
 // |innerText()|, the search depth and breadth are limited to a fixed threshold.
 // Whitespace is trimmed from text accumulated at descendant nodes.
-string16 FindChildText(const WebNode& node) {
+base::string16 FindChildText(const WebNode& node) {
   if (node.isTextNode())
     return node.nodeValue();
 
   WebNode child = node.firstChild();
 
   const int kChildSearchDepth = 10;
-  string16 node_text = FindChildTextInner(child, kChildSearchDepth);
+  base::string16 node_text = FindChildTextInner(child, kChildSearchDepth);
   TrimWhitespace(node_text, TRIM_ALL, &node_text);
   return node_text;
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // a previous sibling of |element|,
 // e.g. Some Text <input ...>
 // or   Some <span>Text</span> <input ...>
 // or   <p>Some Text</p><input ...>
 // or   <label>Some Text</label> <input ...>
 // or   Some Text <img><input ...>
 // or   <b>Some Text</b><br/> <input ...>.
-string16 InferLabelFromPrevious(const WebFormControlElement& element) {
-  string16 inferred_label;
+base::string16 InferLabelFromPrevious(const WebFormControlElement& element) {
+  base::string16 inferred_label;
   WebNode previous = element;
   while (true) {
     previous = previous.previousSibling();
     if (previous.isNull())
       break;
 
     // Skip over comments.
     WebNode::NodeType node_type = previous.nodeType();
     if (node_type == WebNode::CommentNode)
       continue;
 
     // Otherwise, only consider normal HTML elements and their contents.
     if (node_type != WebNode::TextNode &&
         node_type != WebNode::ElementNode)
       break;
 
     // A label might be split across multiple "lightweight" nodes.
     // Coalesce any text contained in multiple consecutive
     //  (a) plain text nodes or
     //  (b) inline HTML elements that are essentially equivalent to text nodes.
     CR_DEFINE_STATIC_LOCAL(WebString, kBold, ("b"));
     CR_DEFINE_STATIC_LOCAL(WebString, kStrong, ("strong"));
     CR_DEFINE_STATIC_LOCAL(WebString, kSpan, ("span"));
     CR_DEFINE_STATIC_LOCAL(WebString, kFont, ("font"));
     if (previous.isTextNode() ||
         HasTagName(previous, kBold) || HasTagName(previous, kStrong) ||
         HasTagName(previous, kSpan) || HasTagName(previous, kFont)) {
-      string16 value = FindChildText(previous);
+      base::string16 value = FindChildText(previous);
       // A text node's value will be empty if it is for a line break.
       bool add_space = previous.isTextNode() && value.empty();
       inferred_label =
           CombineAndCollapseWhitespace(value, inferred_label, add_space);
       continue;
     }
 
     // If we have identified a partial label and have reached a non-lightweight
     // element, consider the label to be complete.
-    string16 trimmed_label;
+    base::string16 trimmed_label;
     TrimWhitespace(inferred_label, TRIM_ALL, &trimmed_label);
     if (!trimmed_label.empty())
       break;
 
     // <img> and <br> tags often appear between the input element and its
     // label text, so skip over them.
     CR_DEFINE_STATIC_LOCAL(WebString, kImage, ("img"));
     CR_DEFINE_STATIC_LOCAL(WebString, kBreak, ("br"));
     if (HasTagName(previous, kImage) || HasTagName(previous, kBreak))
       continue;
 
     // We only expect <p> and <label> tags to contain the full label text.
     CR_DEFINE_STATIC_LOCAL(WebString, kPage, ("p"));
     CR_DEFINE_STATIC_LOCAL(WebString, kLabel, ("label"));
     if (HasTagName(previous, kPage) || HasTagName(previous, kLabel))
       inferred_label = FindChildText(previous);
 
     break;
   }
 
   TrimWhitespace(inferred_label, TRIM_ALL, &inferred_label);
   return inferred_label;
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // enclosing list item,
 // e.g. <li>Some Text<input ...><input ...><input ...></tr>
-string16 InferLabelFromListItem(const WebFormControlElement& element) {
+base::string16 InferLabelFromListItem(const WebFormControlElement& element) {
   WebNode parent = element.parentNode();
   CR_DEFINE_STATIC_LOCAL(WebString, kListItem, ("li"));
   while (!parent.isNull() && parent.isElementNode() &&
          !parent.to<WebElement>().hasTagName(kListItem)) {
     parent = parent.parentNode();
   }
 
   if (!parent.isNull() && HasTagName(parent, kListItem))
     return FindChildText(parent);
 
-  return string16();
+  return base::string16();
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // surrounding table structure,
 // e.g. <tr><td>Some Text</td><td><input ...></td></tr>
 // or   <tr><th>Some Text</th><td><input ...></td></tr>
 // or   <tr><td><b>Some Text</b></td><td><b><input ...></b></td></tr>
 // or   <tr><th><b>Some Text</b></th><td><b><input ...></b></td></tr>
-string16 InferLabelFromTableColumn(const WebFormControlElement& element) {
+base::string16 InferLabelFromTableColumn(const WebFormControlElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kTableCell, ("td"));
   WebNode parent = element.parentNode();
   while (!parent.isNull() && parent.isElementNode() &&
          !parent.to<WebElement>().hasTagName(kTableCell)) {
     parent = parent.parentNode();
   }
 
   if (parent.isNull())
-    return string16();
+    return base::string16();
 
   // Check all previous siblings, skipping non-element nodes, until we find a
   // non-empty text block.
-  string16 inferred_label;
+  base::string16 inferred_label;
   WebNode previous = parent.previousSibling();
   CR_DEFINE_STATIC_LOCAL(WebString, kTableHeader, ("th"));
   while (inferred_label.empty() && !previous.isNull()) {
     if (HasTagName(previous, kTableCell) || HasTagName(previous, kTableHeader))
       inferred_label = FindChildText(previous);
 
     previous = previous.previousSibling();
   }
 
   return inferred_label;
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // surrounding table structure,
 // e.g. <tr><td>Some Text</td></tr><tr><td><input ...></td></tr>
-string16 InferLabelFromTableRow(const WebFormControlElement& element) {
+base::string16 InferLabelFromTableRow(const WebFormControlElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kTableRow, ("tr"));
   WebNode parent = element.parentNode();
   while (!parent.isNull() && parent.isElementNode() &&
          !parent.to<WebElement>().hasTagName(kTableRow)) {
     parent = parent.parentNode();
   }
 
   if (parent.isNull())
-    return string16();
+    return base::string16();
 
   // Check all previous siblings, skipping non-element nodes, until we find a
   // non-empty text block.
-  string16 inferred_label;
+  base::string16 inferred_label;
   WebNode previous = parent.previousSibling();
   while (inferred_label.empty() && !previous.isNull()) {
     if (HasTagName(previous, kTableRow))
       inferred_label = FindChildText(previous);
 
     previous = previous.previousSibling();
   }
 
   return inferred_label;
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // a surrounding div table,
 // e.g. <div>Some Text<span><input ...></span></div>
 // e.g. <div>Some Text</div><div><input ...></div>
-string16 InferLabelFromDivTable(const WebFormControlElement& element) {
+base::string16 InferLabelFromDivTable(const WebFormControlElement& element) {
   WebNode node = element.parentNode();
   bool looking_for_parent = true;
 
   // Search the sibling and parent <div>s until we find a candidate label.
-  string16 inferred_label;
+  base::string16 inferred_label;
   CR_DEFINE_STATIC_LOCAL(WebString, kDiv, ("div"));
   CR_DEFINE_STATIC_LOCAL(WebString, kTable, ("table"));
   CR_DEFINE_STATIC_LOCAL(WebString, kFieldSet, ("fieldset"));
   while (inferred_label.empty() && !node.isNull()) {
     if (HasTagName(node, kDiv)) {
       looking_for_parent = false;
       inferred_label = FindChildText(node);
     } else if (looking_for_parent &&
                (HasTagName(node, kTable) || HasTagName(node, kFieldSet))) {
       // If the element is in a table or fieldset, its label most likely is too.
@@ skipping 11 matching lines @@
       node = node.previousSibling();
   }
 
   return inferred_label;
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // a surrounding definition list,
 // e.g. <dl><dt>Some Text</dt><dd><input ...></dd></dl>
 // e.g. <dl><dt><b>Some Text</b></dt><dd><b><input ...></b></dd></dl>
-string16 InferLabelFromDefinitionList(const WebFormControlElement& element) {
+base::string16 InferLabelFromDefinitionList(
+    const WebFormControlElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kDefinitionData, ("dd"));
   WebNode parent = element.parentNode();
   while (!parent.isNull() && parent.isElementNode() &&
          !parent.to<WebElement>().hasTagName(kDefinitionData))
     parent = parent.parentNode();
 
   if (parent.isNull() || !HasTagName(parent, kDefinitionData))
-    return string16();
+    return base::string16();
 
   // Skip by any intervening text nodes.
   WebNode previous = parent.previousSibling();
   while (!previous.isNull() && previous.isTextNode())
     previous = previous.previousSibling();
 
   CR_DEFINE_STATIC_LOCAL(WebString, kDefinitionTag, ("dt"));
   if (previous.isNull() || !HasTagName(previous, kDefinitionTag))
-    return string16();
+    return base::string16();
 
   return FindChildText(previous);
 }
 
 // Infers corresponding label for |element| from surrounding context in the DOM,
 // e.g. the contents of the preceding <p> tag or text element.
-string16 InferLabelForElement(const WebFormControlElement& element) {
-  string16 inferred_label = InferLabelFromPrevious(element);
+base::string16 InferLabelForElement(const WebFormControlElement& element) {
+  base::string16 inferred_label = InferLabelFromPrevious(element);
   if (!inferred_label.empty())
     return inferred_label;
 
   // If we didn't find a label, check for list item case.
   inferred_label = InferLabelFromListItem(element);
   if (!inferred_label.empty())
     return inferred_label;
 
   // If we didn't find a label, check for table cell case.
   inferred_label = InferLabelFromTableColumn(element);
@@ skipping 10 matching lines @@
   if (!inferred_label.empty())
     return inferred_label;
 
   // If we didn't find a label, check for div table case.
   return InferLabelFromDivTable(element);
 }
 
 // Fills |option_strings| with the values of the <option> elements present in
 // |select_element|.
 void GetOptionStringsFromElement(const WebSelectElement& select_element,
-                                 std::vector<string16>* option_values,
-                                 std::vector<string16>* option_contents) {
+                                 std::vector<base::string16>* option_values,
+                                 std::vector<base::string16>* option_contents) {
   DCHECK(!select_element.isNull());
 
   option_values->clear();
   option_contents->clear();
   WebVector<WebElement> list_items = select_element.listItems();
   option_values->reserve(list_items.size());
   option_contents->reserve(list_items.size());
   for (size_t i = 0; i < list_items.size(); ++i) {
     if (IsOptionElement(list_items[i])) {
       const WebOptionElement option = list_items[i].toConst<WebOptionElement>();
@@ skipping 28 matching lines @@
   }
 
   // It's possible that the site has injected fields into the form after the
   // page has loaded, so we can't assert that the size of the cached control
   // elements is equal to the size of the fields in |form|.  Fortunately, the
   // one case in the wild where this happens, paypal.com signup form, the fields
   // are appended to the end of the form and are not visible.
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement* element = &control_elements[i];
 
-    if (string16(element->nameForAutofill()) != data.fields[i].name) {
+    if (base::string16(element->nameForAutofill()) != data.fields[i].name) {
       // This case should be reachable only for pathological websites, which
       // rename form fields while the user is interacting with the Autofill
       // popup.  I (isherman) am not aware of any such websites, and so am
       // optimistically including a NOTREACHED().  If you ever trip this check,
       // please file a bug against me.
       NOTREACHED();
       continue;
     }
 
     bool is_initiating_element = (*element == initiating_element);
@@ skipping 109 matching lines @@
   if (!element)
     return false;
 
   return element->isCheckbox() || element->isRadioButton();
 }
 
 bool IsAutofillableInputElement(const WebInputElement* element) {
   return IsTextInput(element) || IsCheckableElement(element);
 }
 
-const string16 GetFormIdentifier(const WebFormElement& form) {
-  string16 identifier = form.name();
+const base::string16 GetFormIdentifier(const WebFormElement& form) {
+  base::string16 identifier = form.name();
   CR_DEFINE_STATIC_LOCAL(WebString, kId, ("id"));
   if (identifier.empty())
     identifier = form.getAttribute(kId);
 
   return identifier;
 }
 
 bool ClickElement(const WebDocument& document,
                   const WebElementDescriptor& element_descriptor) {
   WebString web_descriptor = WebString::fromUTF8(element_descriptor.descriptor);
@@ skipping 93 matching lines @@
     DCHECK(IsSelectElement(element));
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
     GetOptionStringsFromElement(select_element,
                                 &field->option_values,
                                 &field->option_contents);
   }
 
   if (!(extract_mask & EXTRACT_VALUE))
     return;
 
-  string16 value;
+  base::string16 value;
   if (IsAutofillableInputElement(input_element)) {
     value = input_element->value();
   } else {
     DCHECK(IsSelectElement(element));
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
     value = select_element.value();
 
     // Convert the |select_element| value to text if requested.
     if (extract_mask & EXTRACT_OPTION_TEXT) {
       WebVector<WebElement> list_items = select_element.listItems();
@@ skipping 41 matching lines @@
   form->origin = frame->document().url();
   form->action = frame->document().completeURL(form_element.action());
   form->user_submitted = form_element.wasUserSubmitted();
 
   // If the completed URL is not valid, just use the action we get from
   // WebKit.
   if (!form->action.is_valid())
     form->action = GURL(form_element.action());
 
   // A map from a FormFieldData's name to the FormFieldData itself.
-  std::map<string16, FormFieldData*> name_map;
+  std::map<base::string16, FormFieldData*> name_map;
 
   // The extracted FormFields.  We use pointers so we can store them in
   // |name_map|.
   ScopedVector<FormFieldData> form_fields;
 
   WebVector<WebFormControlElement> control_elements;
   form_element.getFormControlElements(control_elements);
 
   // A vector of bools that indicate whether each field in the form meets the
   // requirements and thus will be in the resulting |form|.
@@ skipping 31 matching lines @@
   // element, get the corresponding form control element, use the form control
   // element's name as a key into the <name, FormFieldData> map to find the
   // previously created FormFieldData and set the FormFieldData's label to the
   // label.firstChild().nodeValue() of the label element.
   WebNodeList labels = form_element.getElementsByTagName(kLabel);
   for (unsigned i = 0; i < labels.length(); ++i) {
     WebLabelElement label = labels.item(i).to<WebLabelElement>();
     WebFormControlElement field_element =
         label.correspondingControl().to<WebFormControlElement>();
 
-    string16 element_name;
+    base::string16 element_name;
     if (field_element.isNull()) {
       // Sometimes site authors will incorrectly specify the corresponding
       // field element's name rather than its id, so we compensate here.
       element_name = label.getAttribute(kFor);
     } else if (
         !field_element.isFormControlElement() ||
         field_element.formControlType() == kHidden) {
       continue;
     } else {
       element_name = field_element.nameForAutofill();
     }
 
-    std::map<string16, FormFieldData*>::iterator iter =
+    std::map<base::string16, FormFieldData*>::iterator iter =
         name_map.find(element_name);
     if (iter != name_map.end()) {
-      string16 label_text = FindChildText(label);
+      base::string16 label_text = FindChildText(label);
 
       // Concatenate labels because some sites might have multiple label
       // candidates.
       if (!iter->second->label.empty() && !label_text.empty())
         iter->second->label += ASCIIToUTF16(" ");
       iter->second->label += label_text;
     }
   }
 
   // Loop through the form control elements, extracting the label text from
@@ skipping 148 matching lines @@
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
 }
 
 }  // namespace autofill