Rename WebKit namespace to blink (part 4)

chrome/renderer/safe_browsing/phishing_dom_feature_extractor.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/safe_browsing/phishing_dom_feature_extractor.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
@@ skipping 74 matching lines @@
         start_time(start_time_ticks),
         num_iterations(0) {}
 
   ~PageFeatureState() {}
 };
 
 // Per-frame state
 struct PhishingDOMFeatureExtractor::FrameData {
   // This is our reference to document.all, which is an iterator over all
   // of the elements in the document.  It keeps track of our current position.
-  WebKit::WebNodeCollection elements;
+  blink::WebNodeCollection elements;
   // The domain of the document URL, stored here so that we don't need to
   // recompute it every time it's needed.
   std::string domain;
 };
 
 PhishingDOMFeatureExtractor::PhishingDOMFeatureExtractor(
     content::RenderView* render_view,
     FeatureExtractorClock* clock)
     : render_view_(render_view),
       clock_(clock),
@@ skipping 14 matching lines @@
   // starting a new extraction, so DCHECK this.
   CheckNoPendingExtraction();
   // However, in an opt build, we will go ahead and clean up the pending
   // extraction so that we can start in a known state.
   CancelPendingExtraction();
 
   features_ = features;
   done_callback_ = done_callback;
 
   page_feature_state_.reset(new PageFeatureState(clock_->Now()));
-  WebKit::WebView* web_view = render_view_->GetWebView();
+  blink::WebView* web_view = render_view_->GetWebView();
   if (web_view && web_view->mainFrame()) {
     cur_document_ = web_view->mainFrame()->document();
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PhishingDOMFeatureExtractor::ExtractFeaturesWithTimeout,
                  weak_factory_.GetWeakPtr()));
 }
 
@@ skipping 10 matching lines @@
 
   if (cur_document_.isNull()) {
     // This will only happen if we weren't able to get the document for the
     // main frame.  We'll treat this as an extraction failure.
     RunCallback(false);
     return;
   }
 
   int num_elements = 0;
   for (; !cur_document_.isNull(); cur_document_ = GetNextDocument()) {
-    WebKit::WebNode cur_node;
+    blink::WebNode cur_node;
     if (cur_frame_data_.get()) {
       // We're resuming traversal of a frame, so just advance to the next node.
       cur_node = cur_frame_data_->elements.nextItem();
       // When we resume the traversal, the first call to nextItem() potentially
       // has to walk through the document again from the beginning, if it was
       // modified between our chunks of work.  Log how long this takes, so we
       // can tell if it's too slow.
       UMA_HISTOGRAM_TIMES("SBClientPhishing.DOMFeatureResumeTime",
                           clock_->Now() - current_chunk_start_time);
     } else {
       // We just moved to a new frame, so update our frame state
       // and advance to the first element.
       ResetFrameData();
       cur_node = cur_frame_data_->elements.firstItem();
     }
 
     for (; !cur_node.isNull();
          cur_node = cur_frame_data_->elements.nextItem()) {
       if (!cur_node.isElementNode()) {
         continue;
       }
-      WebKit::WebElement element = cur_node.to<WebKit::WebElement>();
+      blink::WebElement element = cur_node.to<blink::WebElement>();
       if (element.hasTagName("a")) {
         HandleLink(element);
       } else if (element.hasTagName("form")) {
         HandleForm(element);
       } else if (element.hasTagName("img")) {
         HandleImage(element);
       } else if (element.hasTagName("input")) {
         HandleInput(element);
       } else if (element.hasTagName("script")) {
         HandleScript(element);
@@ skipping 35 matching lines @@
     // We're done with this frame, recalculate the FrameData when we
     // advance to the next frame.
     cur_frame_data_.reset();
   }
 
   InsertFeatures();
   RunCallback(true);
 }
 
 void PhishingDOMFeatureExtractor::HandleLink(
-    const WebKit::WebElement& element) {
+    const blink::WebElement& element) {
   // Count the number of times we link to a different host.
   if (!element.hasAttribute("href")) {
     DVLOG(1) << "Skipping anchor tag with no href";
     return;
   }
 
   // Retrieve the link and resolve the link in case it's relative.
-  WebKit::WebURL full_url = element.document().completeURL(
+  blink::WebURL full_url = element.document().completeURL(
       element.getAttribute("href"));
 
   std::string domain;
   bool is_external = IsExternalDomain(full_url, &domain);
   if (domain.empty()) {
     DVLOG(1) << "Could not extract domain from link: " << full_url;
     return;
   }
 
   if (is_external) {
     ++page_feature_state_->external_links;
 
     // Record each unique domain that we link to.
     page_feature_state_->external_domains.insert(domain);
   }
 
   // Check how many are https links.
   if (GURL(full_url).SchemeIs("https")) {
     ++page_feature_state_->secure_links;
   }
 
   ++page_feature_state_->total_links;
 }
 
 void PhishingDOMFeatureExtractor::HandleForm(
-    const WebKit::WebElement& element) {
+    const blink::WebElement& element) {
   // Increment the number of forms on this page.
   ++page_feature_state_->num_forms;
 
   // Record whether the action points to a different domain.
   if (!element.hasAttribute("action")) {
     return;
   }
 
-  WebKit::WebURL full_url = element.document().completeURL(
+  blink::WebURL full_url = element.document().completeURL(
       element.getAttribute("action"));
 
   std::string domain;
   bool is_external = IsExternalDomain(full_url, &domain);
   if (domain.empty()) {
     DVLOG(1) << "Could not extract domain from form action: " << full_url;
     return;
   }
 
   if (is_external) {
     ++page_feature_state_->action_other_domain;
   }
   ++page_feature_state_->total_actions;
 }
 
 void PhishingDOMFeatureExtractor::HandleImage(
-    const WebKit::WebElement& element) {
+    const blink::WebElement& element) {
   if (!element.hasAttribute("src")) {
     DVLOG(1) << "Skipping img tag with no src";
   }
 
   // Record whether the image points to a different domain.
-  WebKit::WebURL full_url = element.document().completeURL(
+  blink::WebURL full_url = element.document().completeURL(
       element.getAttribute("src"));
   std::string domain;
   bool is_external = IsExternalDomain(full_url, &domain);
   if (domain.empty()) {
     DVLOG(1) << "Could not extract domain from image src: " << full_url;
     return;
   }
 
   if (is_external) {
     ++page_feature_state_->img_other_domain;
   }
   ++page_feature_state_->total_imgs;
 }
 
 void PhishingDOMFeatureExtractor::HandleInput(
-    const WebKit::WebElement& element) {
+    const blink::WebElement& element) {
   // The HTML spec says that if the type is unspecified, it defaults to text.
   // In addition, any unrecognized type will be treated as a text input.
   //
   // Note that we use the attribute value rather than
   // WebFormControlElement::formControlType() for consistency with the
   // way the phishing classification model is created.
   std::string type = element.getAttribute("type").utf8();
   StringToLowerASCII(&type);
   if (type == "password") {
     ++page_feature_state_->num_pswd_inputs;
   } else if (type == "radio") {
     ++page_feature_state_->num_radio_inputs;
   } else if (type == "checkbox") {
     ++page_feature_state_->num_check_inputs;
   } else if (type != "submit" && type != "reset" && type != "file" &&
              type != "hidden" && type != "image" && type != "button") {
     // Note that there are a number of new input types in HTML5 that are not
     // handled above.  For now, we will consider these as text inputs since
     // they could be used to capture user input.
     ++page_feature_state_->num_text_inputs;
   }
 }
 
 void PhishingDOMFeatureExtractor::HandleScript(
-    const WebKit::WebElement& element) {
+    const blink::WebElement& element) {
   ++page_feature_state_->num_script_tags;
 }
 
 void PhishingDOMFeatureExtractor::CheckNoPendingExtraction() {
   DCHECK(done_callback_.is_null());
   DCHECK(!cur_frame_data_.get());
   DCHECK(cur_document_.isNull());
   if (!done_callback_.is_null() || cur_frame_data_.get() ||
       !cur_document_.isNull()) {
     LOG(ERROR) << "Extraction in progress, missing call to "
@@ skipping 27 matching lines @@
   DCHECK(!cur_frame_data_.get());
 
   cur_frame_data_.reset(new FrameData());
   cur_frame_data_->elements = cur_document_.all();
   cur_frame_data_->domain =
       net::registry_controlled_domains::GetDomainAndRegistry(
           cur_document_.url(),
           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
 }
 
-WebKit::WebDocument PhishingDOMFeatureExtractor::GetNextDocument() {
+blink::WebDocument PhishingDOMFeatureExtractor::GetNextDocument() {
   DCHECK(!cur_document_.isNull());
-  WebKit::WebFrame* frame = cur_document_.frame();
+  blink::WebFrame* frame = cur_document_.frame();
   // Advance to the next frame that contains a document, with no wrapping.
   if (frame) {
     while ((frame = frame->traverseNext(false))) {
       if (!frame->document().isNull()) {
         return frame->document();
       }
     }
   } else {
     // Keep track of how often frame traversal got "stuck" due to the
     // current subdocument getting removed from the frame tree.
     UMA_HISTOGRAM_COUNTS("SBClientPhishing.DOMFeatureFrameRemoved", 1);
   }
-  return WebKit::WebDocument();
+  return blink::WebDocument();
 }
 
 bool PhishingDOMFeatureExtractor::IsExternalDomain(const GURL& url,
                                                    std::string* domain) const {
   DCHECK(domain);
   DCHECK(cur_frame_data_.get());
 
   if (cur_frame_data_->domain.empty()) {
     return false;
   }
@@ skipping 71 matching lines @@
   // Record number of script tags (discretized for numerical stability.)
   if (page_feature_state_->num_script_tags > 1) {
     features_->AddBooleanFeature(features::kPageNumScriptTagsGTOne);
     if (page_feature_state_->num_script_tags > 6) {
       features_->AddBooleanFeature(features::kPageNumScriptTagsGTSix);
     }
   }
 }
 
 }  // namespace safe_browsing