Use explicit WebString conversions in autofill

components/autofill/content/renderer/form_autofill_util.cc

 // Copyright 2013 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/content/renderer/form_autofill_util.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
@@ skipping 140 matching lines @@
           element.hasHTMLTagName("td") ||
           element.hasHTMLTagName("table");
 }
 
 // Returns the colspan for a <td> / <th>. Defaults to 1.
 size_t CalculateTableCellColumnSpan(const WebElement& element) {
   DCHECK(element.hasHTMLTagName("td") || element.hasHTMLTagName("th"));
 
   size_t span = 1;
   if (element.hasAttribute("colspan")) {
-    base::string16 colspan = element.getAttribute("colspan");
+    base::string16 colspan = element.getAttribute("colspan").utf16();
     // Do not check return value to accept imperfect conversions.
     base::StringToSizeT(colspan, &span);
     // Handle overflow.
     if (span == std::numeric_limits<size_t>::max())
       span = 1;
     span = std::max(span, static_cast<size_t>(1));
   }
 
   return span;
 }
@@ skipping 58 matching lines @@
         (element.isFormControlElement() &&
          IsAutofillableElement(element.toConst<WebFormControlElement>()))) {
       return base::string16();
     }
 
     if (element.hasHTMLTagName("div") && base::ContainsKey(divs_to_skip, node))
       return base::string16();
   }
 
   // Extract the text exactly at this node.
-  base::string16 node_text = node.nodeValue();
+  base::string16 node_text = node.nodeValue().utf16();
 
   // Recursively compute the children's text.
   // Preserve inter-element whitespace separation.
   base::string16 child_text =
       FindChildTextInner(node.firstChild(), depth - 1, divs_to_skip);
   bool add_space = node.isTextNode() && node_text.empty();
   node_text = CombineAndCollapseWhitespace(node_text, child_text, add_space);
 
   // Recursively compute the siblings' text.
   // Again, preserve inter-element whitespace separation.
   base::string16 sibling_text =
       FindChildTextInner(node.nextSibling(), depth - 1, divs_to_skip);
   add_space = node.isTextNode() && node_text.empty();
   node_text = CombineAndCollapseWhitespace(node_text, sibling_text, add_space);
 
   return node_text;
 }
 
 // Same as FindChildText() below, but with a list of div nodes to skip.
 // TODO(thestig): See if other FindChildText() callers can benefit from this.
 base::string16 FindChildTextWithIgnoreList(
     const WebNode& node,
     const std::set<WebNode>& divs_to_skip) {
   if (node.isTextNode())
-    return node.nodeValue();
+    return node.nodeValue().utf16();
 
   WebNode child = node.firstChild();
 
   const int kChildSearchDepth = 10;
   base::string16 node_text =
       FindChildTextInner(child, kChildSearchDepth, divs_to_skip);
   base::TrimWhitespace(node_text, base::TRIM_ALL, &node_text);
   return node_text;
 }
 
@@ skipping 87 matching lines @@
 // Useful for cases like: <span><input type="checkbox">Label For Checkbox</span>
 base::string16 InferLabelFromNext(const WebFormControlElement& element) {
   return InferLabelFromSibling(element, true /* forward? */);
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // the placeholder text. e.g. <input placeholder="foo">
 base::string16 InferLabelFromPlaceholder(const WebFormControlElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kPlaceholder, ("placeholder"));
   if (element.hasAttribute(kPlaceholder))
-    return element.getAttribute(kPlaceholder);
+    return element.getAttribute(kPlaceholder).utf16();
 
   return base::string16();
 }
 
 // Helper for |InferLabelForElement()| that infers a label, from
 // the value attribute when it is present and user has not typed in (if
 // element's value attribute is same as the element's value).
 base::string16 InferLabelFromValueAttr(const WebFormControlElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kValue, ("value"));
   if (element.hasAttribute(kValue) && element.getAttribute(kValue) ==
       element.value()) {
-    return element.getAttribute(kValue);
+    return element.getAttribute(kValue).utf16();
   }
 
   return base::string16();
 }
 
 // Helper for |InferLabelForElement()| that infers a label, if possible, from
 // enclosing list item,
 // e.g. <li>Some Text<input ...><input ...><input ...></li>
 base::string16 InferLabelFromListItem(const WebFormControlElement& element) {
   WebNode parent = element.parentNode();
@@ skipping 363 matching lines @@
   // the browser, without entirely breaking autocomplete for some extreme
   // legitimate sites: http://crbug.com/49332 and http://crbug.com/363094
   if (list_items.size() > kMaxListSize)
     return;
 
   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>();
-      option_values->push_back(option.value());
-      option_contents->push_back(option.text());
+      option_values->push_back(option.value().utf16());
+      option_contents->push_back(option.text().utf16());
     }
   }
 }
 
 // The callback type used by |ForEachMatchingFormField()|.
 typedef void (*Callback)(const FormFieldData&,
                          bool, /* is_initiating_element */
                          blink::WebFormControlElement*);
 
 void ForEachMatchingFormFieldCommon(
@@ skipping 12 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 (base::string16(element->nameForAutofill()) != data.fields[i].name) {
+    if (element->nameForAutofill().utf16() != 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 80 matching lines @@
   WebInputElement* input_element = toWebInputElement(field);
   if (IsCheckableElement(input_element)) {
     input_element->setChecked(IsChecked(data.check_status), true);
   } else {
     base::string16 value = data.value;
     if (IsTextInput(input_element) || IsMonthInput(input_element)) {
       // If the maxlength attribute contains a negative value, maxLength()
       // returns the default maxlength value.
       TruncateString(&value, input_element->maxLength());
     }
-    field->setAutofillValue(value);
+    field->setAutofillValue(blink::WebString::fromUTF16(value));
   }
   // Setting the form might trigger JavaScript, which is capable of
   // destroying the frame.
   if (!field->document().frame())
     return;
 
   field->setAutofilled(true);
 
   if (is_initiating_node &&
       ((IsTextInput(input_element) || IsMonthInput(input_element)) ||
@@ skipping 17 matching lines @@
   if (!data.is_autofilled)
     return;
 
   // Preview input, textarea and select fields. For input fields, excludes
   // checkboxes and radio buttons, as there is no provision for
   // setSuggestedCheckedValue in WebInputElement.
   WebInputElement* input_element = toWebInputElement(field);
   if (IsTextInput(input_element) || IsMonthInput(input_element)) {
     // If the maxlength attribute contains a negative value, maxLength()
     // returns the default maxlength value.
-    input_element->setSuggestedValue(
-      data.value.substr(0, input_element->maxLength()));
+    input_element->setSuggestedValue(blink::WebString::fromUTF16(
+        data.value.substr(0, input_element->maxLength())));
     input_element->setAutofilled(true);
   } else if (IsTextAreaElement(*field) || IsSelectElement(*field)) {
-    field->setSuggestedValue(data.value);
+    field->setSuggestedValue(blink::WebString::fromUTF16(data.value));
     field->setAutofilled(true);
   }
 
   if (is_initiating_node &&
       (IsTextInput(input_element) || IsTextAreaElement(*field))) {
     // Select the part of the text that the user didn't type.
-    PreviewSuggestion(field->suggestedValue(), field->value(), field);
+    PreviewSuggestion(field->suggestedValue().utf16(), field->value().utf16(),
+                      field);
   }
 }
 
 // Extracts the fields from |control_elements| with |extract_mask| to
 // |form_fields|. The extracted fields are also placed in |element_map|.
 // |form_fields| and |element_map| should start out empty.
 // |fields_extracted| should have as many elements as |control_elements|,
 // initialized to false.
 // Returns true if the number of fields extracted is within
 // [1, kMaxParseableFields].
@@ skipping 46 matching lines @@
 
   for (WebElement item = labels.firstItem(); !item.isNull();
        item = labels.nextItem()) {
     WebLabelElement label = item.to<WebLabelElement>();
     WebElement control = label.correspondingControl();
     FormFieldData* field_data = nullptr;
 
     if (control.isNull()) {
       // Sometimes site authors will incorrectly specify the corresponding
       // field element's name rather than its id, so we compensate here.
-      base::string16 element_name = label.getAttribute(kFor);
+      base::string16 element_name = label.getAttribute(kFor).utf16();
       if (element_name.empty())
         continue;
       // Look through the list for elements with this name. There can actually
       // be more than one. In this case, the label may not be particularly
       // useful, so just discard it.
       for (const auto& iter : *element_map) {
         if (iter.second->name == element_name) {
           if (field_data) {
             field_data = nullptr;
             break;
@@ skipping 281 matching lines @@
   return element->isCheckbox() || element->isRadioButton();
 }
 
 bool IsAutofillableInputElement(const WebInputElement* element) {
   return IsTextInput(element) ||
          IsMonthInput(element) ||
          IsCheckableElement(element);
 }
 
 const base::string16 GetFormIdentifier(const WebFormElement& form) {
-  base::string16 identifier = form.name();
+  base::string16 identifier = form.name().utf16();
   CR_DEFINE_STATIC_LOCAL(WebString, kId, ("id"));
   if (identifier.empty())
-    identifier = form.getAttribute(kId);
+    identifier = form.getAttribute(kId).utf16();
 
   return identifier;
 }
 
 bool IsWebNodeVisible(const blink::WebNode& node) {
   // TODO(esprehn): This code doesn't really check if the node is visible, just
   // if the node takes up space in the layout. Does it want to check opacity,
   // transform, and visibility too?
   if (!node.isElementNode())
     return false;
@@ skipping 30 matching lines @@
   DCHECK(field);
   DCHECK(!element.isNull());
   CR_DEFINE_STATIC_LOCAL(WebString, kAutocomplete, ("autocomplete"));
   CR_DEFINE_STATIC_LOCAL(WebString, kId, ("id"));
   CR_DEFINE_STATIC_LOCAL(WebString, kRole, ("role"));
   CR_DEFINE_STATIC_LOCAL(WebString, kPlaceholder, ("placeholder"));
   CR_DEFINE_STATIC_LOCAL(WebString, kClass, ("class"));
 
   // Save both id and name attributes, if present. If there is only one of them,
   // it will be saved to |name|. See HTMLFormControlElement::nameForAutofill.
-  field->name = element.nameForAutofill();
-  base::string16 id = element.getAttribute(kId);
+  field->name = element.nameForAutofill().utf16();
+  base::string16 id = element.getAttribute(kId).utf16();
   if (id != field->name)
     field->id = id;
 
   field->form_control_type = element.formControlType().utf8();
   field->autocomplete_attribute = element.getAttribute(kAutocomplete).utf8();
   if (field->autocomplete_attribute.size() > kMaxDataLength) {
     // Discard overly long attribute values to avoid DOS-ing the browser
     // process.  However, send over a default string to indicate that the
     // attribute was present.
     field->autocomplete_attribute = "x-max-data-length-exceeded";
   }
-  if (base::LowerCaseEqualsASCII(
-          base::StringPiece16(element.getAttribute(kRole)), "presentation"))
+  if (base::LowerCaseEqualsASCII(element.getAttribute(kRole).utf16(),
+                                 "presentation"))
     field->role = FormFieldData::ROLE_ATTRIBUTE_PRESENTATION;
 
-  field->placeholder = element.getAttribute(kPlaceholder);
+  field->placeholder = element.getAttribute(kPlaceholder).utf16();
   if (element.hasAttribute(kClass))
-    field->css_classes = element.getAttribute(kClass);
+    field->css_classes = element.getAttribute(kClass).utf16();
 
   if (field_value_and_properties_map) {
     FieldValueAndPropertiesMaskMap::const_iterator it =
         field_value_and_properties_map->find(element);
     if (it != field_value_and_properties_map->end())
       field->properties_mask = it->second.second;
   }
 
   if (!IsAutofillableElement(element))
     return;
@@ skipping 30 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;
 
-  base::string16 value = element.value();
+  base::string16 value = element.value().utf16();
 
   if (IsSelectElement(element) && (extract_mask & EXTRACT_OPTION_TEXT)) {
     const WebSelectElement select_element = element.toConst<WebSelectElement>();
     // Convert the |select_element| value to text if requested.
     WebVector<WebElement> list_items = select_element.listItems();
     for (size_t i = 0; i < list_items.size(); ++i) {
       if (IsOptionElement(list_items[i])) {
         const WebOptionElement option_element =
             list_items[i].toConst<WebOptionElement>();
-        if (option_element.value() == value) {
-          value = option_element.text();
+        if (option_element.value().utf16() == value) {
+          value = option_element.text().utf16();
           break;
         }
       }
     }
   }
 
   // Constrain the maximum data length to prevent a malicious site from DOS'ing
   // the browser: http://crbug.com/49332
   TruncateString(&value, kMaxDataLength);
 
@@ skipping 79 matching lines @@
   if (!lang.empty() &&
       !base::StartsWith(lang, "en", base::CompareCase::INSENSITIVE_ASCII)) {
     return UnownedFormElementsAndFieldSetsToFormData(
         fieldsets, control_elements, element, document, nullptr, extract_mask,
         form, field);
   }
 
   // A potential problem is that this only checks document.title(), but should
   // actually check the main frame's title. Thus it may make bad decisions for
   // iframes.
-  base::string16 title(base::ToLowerASCII(base::string16(document.title())));
+  base::string16 title(base::ToLowerASCII(document.title().utf16()));
 
   // Don't check the path for url's without a standard format path component,
   // such as data:.
   std::string path;
   GURL url(document.url());
   if (url.IsStandard())
     path = base::ToLowerASCII(url.path());
 
   const char* const kKeywords[] = {
     "payment",
@@ skipping 242 matching lines @@
     // Zero selection start is for password manager, which can show usernames
     // that do not begin with the user input value.
     selection_start = (offset == base::string16::npos) ? 0 : offset;
   }
 
   input_element->setSelectionRange(selection_start, suggestion.length());
 }
 
 }  // namespace form_util
 }  // namespace autofill