Rename WebKit namespace to blink (part 4)

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 "base/command_line.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLabelElement.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebNodeList.h"
 #include "third_party/WebKit/public/web/WebOptionElement.h"
 #include "third_party/WebKit/public/web/WebSelectElement.h"
 #include "third_party/WebKit/public/web/WebTextAreaElement.h"
 
-using WebKit::WebDocument;
-using WebKit::WebElement;
-using WebKit::WebExceptionCode;
-using WebKit::WebFormControlElement;
-using WebKit::WebFormElement;
-using WebKit::WebFrame;
-using WebKit::WebInputElement;
-using WebKit::WebLabelElement;
-using WebKit::WebNode;
-using WebKit::WebNodeList;
-using WebKit::WebOptionElement;
-using WebKit::WebSelectElement;
-using WebKit::WebTextAreaElement;
-using WebKit::WebString;
-using WebKit::WebVector;
+using blink::WebDocument;
+using blink::WebElement;
+using blink::WebExceptionCode;
+using blink::WebFormControlElement;
+using blink::WebFormElement;
+using blink::WebFrame;
+using blink::WebInputElement;
+using blink::WebLabelElement;
+using blink::WebNode;
+using blink::WebNodeList;
+using blink::WebOptionElement;
+using blink::WebSelectElement;
+using blink::WebTextAreaElement;
+using blink::WebString;
+using blink::WebVector;
 
 namespace autofill {
 namespace {
 
 // The maximum length allowed for form data.
 const size_t kMaxDataLength = 1024;
 
 // A bit field mask for FillForm functions to not fill some fields.
 enum FieldFilterMask {
   FILTER_NONE                       = 0,
@@ skipping 13 matching lines @@
 bool IsScriptElement(const WebElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kScript, ("script"));
   return element.hasTagName(kScript);
 }
 
 bool IsNoScriptElement(const WebElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kNoScript, ("noscript"));
   return element.hasTagName(kNoScript);
 }
 
-bool HasTagName(const WebNode& node, const WebKit::WebString& tag) {
+bool HasTagName(const WebNode& node, const blink::WebString& tag) {
   return node.isElementNode() && node.toConst<WebElement>().hasHTMLTagName(tag);
 }
 
 bool IsAutofillableElement(const WebFormControlElement& element) {
   const WebInputElement* input_element = toWebInputElement(&element);
   return IsAutofillableInputElement(input_element) ||
          IsSelectElement(element) ||
          IsTextAreaElement(element);
 }
 
@@ skipping 361 matching lines @@
       const WebOptionElement option = list_items[i].toConst<WebOptionElement>();
       option_values->push_back(option.value());
       option_contents->push_back(option.text());
     }
   }
 }
 
 // The callback type used by |ForEachMatchingFormField()|.
 typedef void (*Callback)(const FormFieldData&,
                          bool, /* is_initiating_element */
-                         WebKit::WebFormControlElement*);
+                         blink::WebFormControlElement*);
 
 // For each autofillable field in |data| that matches a field in the |form|,
 // the |callback| is invoked with the corresponding |form| field data.
 void ForEachMatchingFormField(const WebFormElement& form_element,
                               const WebElement& initiating_element,
                               const FormData& data,
                               FieldFilterMask filters,
                               bool force_override,
                               Callback callback) {
   std::vector<WebFormControlElement> control_elements;
@@ skipping 43 matching lines @@
       continue;
 
     callback(data.fields[i], is_initiating_element, element);
   }
 }
 
 // Sets the |field|'s value to the value in |data|.
 // Also sets the "autofilled" attribute, causing the background to be yellow.
 void FillFormField(const FormFieldData& data,
                    bool is_initiating_node,
-                   WebKit::WebFormControlElement* field) {
+                   blink::WebFormControlElement* field) {
   // Nothing to fill.
   if (data.value.empty())
     return;
 
   field->setAutofilled(true);
 
   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.
@@ skipping 20 matching lines @@
   } else {
     DCHECK(IsCheckableElement(input_element));
     input_element->setChecked(data.is_checked, true);
   }
 }
 
 // Sets the |field|'s "suggested" (non JS visible) value to the value in |data|.
 // Also sets the "autofilled" attribute, causing the background to be yellow.
 void PreviewFormField(const FormFieldData& data,
                       bool is_initiating_node,
-                      WebKit::WebFormControlElement* field) {
+                      blink::WebFormControlElement* field) {
   // Nothing to preview.
   if (data.value.empty())
     return;
 
   // Only preview 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))
     return;
 
@@ skipping 18 matching lines @@
       return "ID";
     case WebElementDescriptor::NONE:
       return "NONE";
   }
   NOTREACHED();
   return "UNKNOWN";
 }
 
 // Recursively checks whether |node| or any of its children have a non-empty
 // bounding box. The recursion depth is bounded by |depth|.
-bool IsWebNodeVisibleImpl(const WebKit::WebNode& node, const int depth) {
+bool IsWebNodeVisibleImpl(const blink::WebNode& node, const int depth) {
   if (depth < 0)
     return false;
   if (node.hasNonEmptyBoundingBox())
     return true;
 
   // The childNodes method is not a const method. Therefore it cannot be called
   // on a const reference. Therefore we need a const cast.
-  const WebKit::WebNodeList& children =
-      const_cast<WebKit::WebNode&>(node).childNodes();
+  const blink::WebNodeList& children =
+      const_cast<blink::WebNode&>(node).childNodes();
   size_t length = children.length();
   for (size_t i = 0; i < length; ++i) {
-    const WebKit::WebNode& item = children.item(i);
+    const blink::WebNode& item = children.item(i);
     if (IsWebNodeVisibleImpl(item, depth - 1))
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 const size_t kMaxParseableFields = 200;
 
@@ skipping 34 matching lines @@
 
 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 IsWebNodeVisible(const WebKit::WebNode& node) {
+bool IsWebNodeVisible(const blink::WebNode& node) {
   // In the bug http://crbug.com/237216 the form's bounding box is empty
   // however the form has non empty children. Thus we need to look at the
   // form's children.
   int kNodeSearchDepth = 2;
   return IsWebNodeVisibleImpl(node, kNodeSearchDepth);
 }
 
 bool ClickElement(const WebDocument& document,
                   const WebElementDescriptor& element_descriptor) {
   WebString web_descriptor = WebString::fromUTF8(element_descriptor.descriptor);
-  WebKit::WebElement element;
+  blink::WebElement element;
 
   switch (element_descriptor.retrieval_method) {
     case WebElementDescriptor::CSS_SELECTOR: {
       WebExceptionCode ec = 0;
       element = document.querySelector(web_descriptor, ec);
       if (ec)
         DVLOG(1) << "Query selector failed. Error code: " << ec << ".";
       break;
     }
     case WebElementDescriptor::ID:
@@ skipping 122 matching lines @@
 
   // Constrain the maximum data length to prevent a malicious site from DOS'ing
   // the browser: http://crbug.com/49332
   if (value.size() > kMaxDataLength)
     value = value.substr(0, kMaxDataLength);
 
   field->value = value;
 }
 
 bool WebFormElementToFormData(
-    const WebKit::WebFormElement& form_element,
-    const WebKit::WebFormControlElement& form_control_element,
+    const blink::WebFormElement& form_element,
+    const blink::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)
@@ skipping 258 matching lines @@
     if (!IsAutofillableInputElement(input_element))
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
 }
 
-bool IsWebpageEmpty(const WebKit::WebFrame* frame) {
-  WebKit::WebDocument document = frame->document();
+bool IsWebpageEmpty(const blink::WebFrame* frame) {
+  blink::WebDocument document = frame->document();
 
   return IsWebElementEmpty(document.head()) &&
          IsWebElementEmpty(document.body());
 }
 
-bool IsWebElementEmpty(const WebKit::WebElement& element) {
+bool IsWebElementEmpty(const blink::WebElement& element) {
   // This array contains all tags which can be present in an empty page.
   const char* const kAllowedValue[] = {
     "script",
     "meta",
     "title",
   };
   const size_t kAllowedValueLength = arraysize(kAllowedValue);
 
   if (element.isNull())
     return true;
   // The childNodes method is not a const method. Therefore it cannot be called
   // on a const reference. Therefore we need a const cast.
-  const WebKit::WebNodeList& children =
-      const_cast<WebKit::WebElement&>(element).childNodes();
+  const blink::WebNodeList& children =
+      const_cast<blink::WebElement&>(element).childNodes();
   for (size_t i = 0; i < children.length(); ++i) {
-    const WebKit::WebNode& item = children.item(i);
+    const blink::WebNode& item = children.item(i);
 
     if (item.isTextNode() &&
         !ContainsOnlyWhitespaceASCII(item.nodeValue().utf8()))
       return false;
 
     // We ignore all other items with names which begin with
     // the character # because they are not html tags.
     if (item.nodeName().utf8()[0] == '#')
       continue;
 
     bool tag_is_allowed = false;
     // Test if the item name is in the kAllowedValue array
     for (size_t allowed_value_index = 0;
          allowed_value_index < kAllowedValueLength; ++allowed_value_index) {
       if (HasTagName(item,
                      WebString::fromUTF8(kAllowedValue[allowed_value_index]))) {
         tag_is_allowed = true;
         break;
       }
     }
     if (!tag_is_allowed)
       return false;
   }
   return true;
 }
 
 }  // namespace autofill