Use static strings in autofill labeling.

chrome/renderer/autofill/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 "chrome/renderer/autofill/form_autofill_util.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 37 matching lines @@
 using autofill::ExtractAutofillableElements;
 using autofill::IsAutofillableInputElement;
 using autofill::IsCheckableElement;
 using autofill::IsSelectElement;
 using autofill::IsTextInput;
 
 // The maximum length allowed for form data.
 const size_t kMaxDataLength = 1024;
 
 bool IsOptionElement(const WebElement& element) {
-  return element.hasTagName("option");
+  CR_DEFINE_STATIC_LOCAL(WebString, kOption, ("option"));
+  return element.hasTagName(kOption);
 }
 
 bool IsScriptElement(const WebElement& element) {
-  return element.hasTagName("script");
+  CR_DEFINE_STATIC_LOCAL(WebString, kScript, ("script"));
+  return element.hasTagName(kScript);
 }
 
 bool IsNoScriptElement(const WebElement& element) {
-  return element.hasTagName("noscript");
+  CR_DEFINE_STATIC_LOCAL(WebString, kNoScript, ("noscript"));
+  return element.hasTagName(kNoScript);
 }
 
 bool HasTagName(const WebNode& node, const WebKit::WebString& tag) {
   return node.isElementNode() && node.toConst<WebElement>().hasTagName(tag);
 }
 
 bool IsAutofillableElement(const WebFormControlElement& element) {
   const WebInputElement* input_element = toWebInputElement(&element);
   return IsAutofillableInputElement(input_element) || IsSelectElement(element);
 }
@@ skipping 117 matching lines @@
 
     // 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, "b") || HasTagName(previous, "strong") ||
-        HasTagName(previous, "span") || HasTagName(previous, "font")) {
+        HasTagName(previous, kBold) || HasTagName(previous, kStrong) ||
+        HasTagName(previous, kSpan) || HasTagName(previous, kFont)) {
       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;
     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.
-    if (HasTagName(previous, "img") || HasTagName(previous, "br"))
+    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.
-    if (HasTagName(previous, "p") || HasTagName(previous, "label"))
+    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) {
   WebNode parent = element.parentNode();
+  CR_DEFINE_STATIC_LOCAL(WebString, kListItem, ("li"));
   while (!parent.isNull() && parent.isElementNode() &&
-         !parent.to<WebElement>().hasTagName("li")) {
+         !parent.to<WebElement>().hasTagName(kListItem)) {
     parent = parent.parentNode();
   }
 
-  if (!parent.isNull() && HasTagName(parent, "li"))
+  if (!parent.isNull() && HasTagName(parent, kListItem))
     return FindChildText(parent);
 
   return 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) {
+  CR_DEFINE_STATIC_LOCAL(WebString, kTableCell, ("td"));
   WebNode parent = element.parentNode();
   while (!parent.isNull() && parent.isElementNode() &&
-         !parent.to<WebElement>().hasTagName("td")) {
+         !parent.to<WebElement>().hasTagName(kTableCell)) {
     parent = parent.parentNode();
   }
 
   if (parent.isNull())
     return string16();
 
   // Check all previous siblings, skipping non-element nodes, until we find a
   // non-empty text block.
   string16 inferred_label;
   WebNode previous = parent.previousSibling();
+  CR_DEFINE_STATIC_LOCAL(WebString, kTableHeader, ("th"));
   while (inferred_label.empty() && !previous.isNull()) {
-    if (HasTagName(previous, "td") || HasTagName(previous, "th"))
+    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) {
+  CR_DEFINE_STATIC_LOCAL(WebString, kTableRow, ("tr"));
   WebNode parent = element.parentNode();
   while (!parent.isNull() && parent.isElementNode() &&
-         !parent.to<WebElement>().hasTagName("tr")) {
+         !parent.to<WebElement>().hasTagName(kTableRow)) {
     parent = parent.parentNode();
   }
 
   if (parent.isNull())
     return string16();
 
   // Check all previous siblings, skipping non-element nodes, until we find a
   // non-empty text block.
   string16 inferred_label;
   WebNode previous = parent.previousSibling();
   while (inferred_label.empty() && !previous.isNull()) {
-    if (HasTagName(previous, "tr"))
+    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) {
   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;
+  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, "div")) {
+    if (HasTagName(node, kDiv)) {
       looking_for_parent = false;
       inferred_label = FindChildText(node);
     } else if (looking_for_parent &&
-               (HasTagName(node, "table") || HasTagName(node, "fieldset"))) {
+               (HasTagName(node, kTable) || HasTagName(node, kFieldSet))) {
       // If the element is in a table or fieldset, its label most likely is too.
       break;
     }
 
     if (node.previousSibling().isNull()) {
       // If there are no more siblings, continue walking up the tree.
       looking_for_parent = true;
     }
 
     if (looking_for_parent)
       node = node.parentNode();
     else
       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) {
+  CR_DEFINE_STATIC_LOCAL(WebString, kDefinitionData, ("dd"));
   WebNode parent = element.parentNode();
   while (!parent.isNull() && parent.isElementNode() &&
-         !parent.to<WebElement>().hasTagName("dd"))
+         !parent.to<WebElement>().hasTagName(kDefinitionData))
     parent = parent.parentNode();
 
-  if (parent.isNull() || !HasTagName(parent, "dd"))
+  if (parent.isNull() || !HasTagName(parent, kDefinitionData))
     return string16();
 
   // Skip by any intervening text nodes.
   WebNode previous = parent.previousSibling();
   while (!previous.isNull() && previous.isTextNode())
     previous = previous.previousSibling();
 
-  if (previous.isNull() || !HasTagName(previous, "dt"))
+  CR_DEFINE_STATIC_LOCAL(WebString, kDefinitionTag, ("dt"));
+  if (previous.isNull() || !HasTagName(previous, kDefinitionTag))
     return 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);
   if (!inferred_label.empty())
@@ skipping 212 matching lines @@
 }
 
 bool IsAutofillableInputElement(const WebInputElement* element) {
   // TODO(ramankk): Uncomment IsCheckableElement part once we have solution
   // for the observed performance regression.
   return IsTextInput(element); // || IsCheckableElement(element);
 }
 
 const string16 GetFormIdentifier(const WebFormElement& form) {
   string16 identifier = form.name();
+  CR_DEFINE_STATIC_LOCAL(WebString, kId, ("id"));
   if (identifier.empty())
-    identifier = form.getAttribute(WebString("id"));
+    identifier = form.getAttribute(kId);
 
   return identifier;
 }
 
 bool ClickElement(const WebDocument& document,
                   const WebElementDescriptor& element_descriptor) {
   WebString web_descriptor = WebString::fromUTF8(element_descriptor.descriptor);
   WebKit::WebElement element;
 
   switch (element_descriptor.retrieval_method) {
@@ skipping 48 matching lines @@
 
     autofillable_elements->push_back(element);
   }
 }
 
 void WebFormControlElementToFormField(const WebFormControlElement& element,
                                       ExtractMask extract_mask,
                                       FormFieldData* field) {
   DCHECK(field);
   DCHECK(!element.isNull());
+  CR_DEFINE_STATIC_LOCAL(WebString, kAutocomplete, ("autocomplete"));
 
   // The label is not officially part of a WebFormControlElement; however, the
   // labels for all form control elements are scraped from the DOM and set in
   // WebFormElementToFormData.
   field->name = element.nameForAutofill();
   field->form_control_type = UTF16ToUTF8(element.formControlType());
   field->autocomplete_attribute =
-      UTF16ToUTF8(element.getAttribute("autocomplete"));
+      UTF16ToUTF8(element.getAttribute(kAutocomplete));
   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 (!IsAutofillableElement(element))
     return;
 
@@ skipping 50 matching lines @@
   field->value = value;
 }
 
 bool WebFormElementToFormData(
     const WebKit::WebFormElement& form_element,
     const WebKit::WebFormControlElement& form_control_element,
     RequirementsMask requirements,
     ExtractMask extract_mask,
     FormData* form,
     FormFieldData* field) {
+  CR_DEFINE_STATIC_LOCAL(WebString, kLabel, ("label"));
+  CR_DEFINE_STATIC_LOCAL(WebString, kFor, ("for"));
+  CR_DEFINE_STATIC_LOCAL(WebString, kHidden, ("hidden"));
+
   const WebFrame* frame = form_element.document().frame();
   if (!frame)
     return false;
 
   if (requirements & REQUIRE_AUTOCOMPLETE && !form_element.autoComplete())
     return false;
 
   form->name = GetFormIdentifier(form_element);
   form->method = form_element.method();
   form->origin = frame->document().url();
@@ skipping 45 matching lines @@
   // If we failed to extract any fields, give up.  Also, to avoid overly
   // expensive computation, we impose a maximum number of allowable fields.
   if (form_fields.empty() || form_fields.size() > kMaxParseableFields)
     return false;
 
   // Loop through the label elements inside the form element.  For each label
   // 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("label");
+  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;
     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("for");
+      element_name = label.getAttribute(kFor);
     } else if (
         !field_element.isFormControlElement() ||
-        field_element.formControlType() == WebString::fromUTF8("hidden")) {
+        field_element.formControlType() == kHidden) {
       continue;
     } else {
       element_name = field_element.nameForAutofill();
     }
 
     std::map<string16, FormFieldData*>::iterator iter =
         name_map.find(element_name);
     if (iter != name_map.end()) {
       string16 label_text = FindChildText(label);
 
@@ skipping 154 matching lines @@
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
 }
 
 }  // namespace autofill