Update safe_browsing code to use WebElementCollection instead of WebNodeCollection

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"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chrome/renderer/safe_browsing/feature_extractor_clock.h"
 #include "chrome/renderer/safe_browsing/features.h"
 #include "content/public/renderer/render_view.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebElement.h"
+#include "third_party/WebKit/public/web/WebElementCollection.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
-#include "third_party/WebKit/public/web/WebNodeCollection.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 namespace safe_browsing {
 
 // This time should be short enough that it doesn't noticeably disrupt the
 // user's interaction with the page.
 const int PhishingDOMFeatureExtractor::kMaxTimePerChunkMs = 10;
 
 // Experimenting shows that we get a reasonable gain in performance by
 // increasing this up to around 10, but there's not much benefit in
@@ skipping 52 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.
-  blink::WebNodeCollection elements;
+  blink::WebElementCollection 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 45 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()) {
-    blink::WebNode cur_node;
+    blink::WebElement cur_element;
     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();
+      // We're resuming traversal of a frame, so just advance to the next
+      // element.
+      cur_element = 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();
+      cur_element = cur_frame_data_->elements.firstItem();
     }
 
-    for (; !cur_node.isNull();
-         cur_node = cur_frame_data_->elements.nextItem()) {
-      if (!cur_node.isElementNode()) {
-        continue;
-      }
-      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);
+    for (; !cur_element.isNull();
+         cur_element = cur_frame_data_->elements.nextItem()) {
+      if (cur_element.hasTagName("a")) {
+        HandleLink(cur_element);
+      } else if (cur_element.hasTagName("form")) {
+        HandleForm(cur_element);
+      } else if (cur_element.hasTagName("img")) {
+        HandleImage(cur_element);
+      } else if (cur_element.hasTagName("input")) {
+        HandleInput(cur_element);
+      } else if (cur_element.hasTagName("script")) {
+        HandleScript(cur_element);
       }
 
       if (++num_elements >= kClockCheckGranularity) {
         num_elements = 0;
         base::TimeTicks now = clock_->Now();
         if (now - page_feature_state_->start_time >=
             base::TimeDelta::FromMilliseconds(kMaxTotalTimeMs)) {
           DLOG(ERROR) << "Feature extraction took too long, giving up";
           // We expect this to happen infrequently, so record when it does.
           UMA_HISTOGRAM_COUNTS("SBClientPhishing.DOMFeatureTimeout", 1);
@@ skipping 287 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