Switch the page-capturing machinery to use the new hooks.

chrome/renderer/chrome_render_frame_observer.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 "chrome/renderer/chrome_render_frame_observer.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <string>
@@ skipping 35 matching lines @@
 #endif
 
 using blink::WebDataSource;
 using blink::WebElement;
 using blink::WebLocalFrame;
 using blink::WebNode;
 using blink::WebString;
 using content::SSLStatus;
 using content::RenderFrame;
 
-// Delay in milliseconds that we'll wait before capturing the page contents.
-static const int kDelayForCaptureMs = 500;
-
-// Typically, we capture the page data once the page is loaded.
-// Sometimes, the page never finishes to load, preventing the page capture
-// To workaround this problem, we always perform a capture after the following
-// delay.
-static const int kDelayForForcedCaptureMs = 6000;
-
 // Maximum number of characters in the document to index.
 // Any text beyond this point will be clipped.
 static const size_t kMaxIndexChars = 65535;
 
 // Constants for UMA statistic collection.
 static const char kTranslateCaptureText[] = "Translate.CaptureText";
 
 namespace {
 
 // If the source image is null or occupies less area than
@@ skipping 30 matching lines @@
                                        skia::ImageOperations::RESIZE_GOOD,
                                        static_cast<int>(scaled_size.width()),
                                        static_cast<int>(scaled_size.height()));
 }
 
 }  // namespace
 
 ChromeRenderFrameObserver::ChromeRenderFrameObserver(
     content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
-      capture_timer_(false, false),
       translate_helper_(nullptr),
       phishing_classifier_(nullptr) {
   // Don't do anything for subframes.
   if (!render_frame->IsMainFrame())
     return;
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (!command_line.HasSwitch(switches::kDisableClientSidePhishingDetection))
     OnSetClientSidePhishingDetection(true);
@@ skipping 174 matching lines @@
   if (frame->parent())
     return;
 
   GURL osdd_url = frame->document().openSearchDescriptionURL();
   if (!osdd_url.is_empty()) {
     Send(new ChromeViewHostMsg_PageHasOSDD(
         routing_id(), frame->document().url(), osdd_url,
         search_provider::AUTODETECTED_PROVIDER));
   }
 
-  // Don't capture pages that have pending redirect or location change.
-  if (frame->isNavigationScheduled())
-    return;
-
-  CapturePageTextLater(
-      FINAL_CAPTURE,
-      base::TimeDelta::FromMilliseconds(
-          render_frame()->GetRenderView()->GetContentStateImmediately()
-              ? 0
-              : kDelayForCaptureMs));
+  // TODO(dglazkov): This is only necessary for ChromeRenderViewTests,
+  // since they don't actually pump frames. These tests will need
+  // to be rewritten eventually (there is no ChromeRenderView anymore).
+  if (render_frame()->GetRenderView()->GetContentStateImmediately()) {
+    CapturePageText(PRELIMINARY_CAPTURE);
+  }
 }
 
 void ChromeRenderFrameObserver::DidStartProvisionalLoad() {
   // Let translate_helper do any preparatory work for loading a URL.
   if (!translate_helper_)
     return;
 
   translate_helper_->PrepareForUrl(
       render_frame()->GetWebFrame()->document().url());
 }
 
 void ChromeRenderFrameObserver::DidCommitProvisionalLoad(
     bool is_new_navigation,
     bool is_same_page_navigation) {
   WebLocalFrame* frame = render_frame()->GetWebFrame();
 
   // Don't do anything for subframes.
   if (frame->parent())
     return;
 
-  // Don't capture pages being not new, with pending redirect, or location
-  // change.
-  if (!is_new_navigation || frame->isNavigationScheduled())
-    return;
-
   base::debug::SetCrashKeyValue(
       crash_keys::kViewCount,
       base::SizeTToString(content::RenderView::GetRenderViewCount()));
-
-  CapturePageTextLater(PRELIMINARY_CAPTURE, base::TimeDelta::FromMilliseconds(
-                                                kDelayForForcedCaptureMs));
 }
 
 void ChromeRenderFrameObserver::CapturePageText(TextCaptureType capture_type) {
   WebLocalFrame* frame = render_frame()->GetWebFrame();
   if (!frame)
     return;
 
+  // Don't capture pages that have pending redirect or location change.
+  if (frame->isNavigationScheduled())
+    return;
+
   // Don't index/capture pages that are in view source mode.
   if (frame->isViewSourceModeEnabled())
     return;
 
   // Don't capture text of the error pages.
   WebDataSource* ds = frame->dataSource();
   if (ds && ds->hasUnreachableURL())
     return;
 
   // Don't index/capture pages that are being prerendered.
   if (prerender::PrerenderHelper::IsPrerendering(render_frame()))
     return;
 
   base::TimeTicks capture_begin_time = base::TimeTicks::Now();
 
   // Retrieve the frame's full text (up to kMaxIndexChars), and pass it to the
   // translate helper for language detection and possible translation.
   base::string16 contents = frame->contentAsText(kMaxIndexChars);
 
   UMA_HISTOGRAM_TIMES(kTranslateCaptureText,
                       base::TimeTicks::Now() - capture_begin_time);
 
-  if (translate_helper_)
+  // We should run language detection only once. Parsing finishes before
+  // the page loads, so let's pick that timing.
+  if (translate_helper_ && capture_type == PRELIMINARY_CAPTURE)
     translate_helper_->PageCaptured(contents);
 
   TRACE_EVENT0("renderer", "ChromeRenderFrameObserver::CapturePageText");
 
 #if defined(SAFE_BROWSING_CSD)
   // Will swap out the string.
   if (phishing_classifier_)
     phishing_classifier_->PageCaptured(&contents,
                                        capture_type == PRELIMINARY_CAPTURE);
 #endif
 }
 
-void ChromeRenderFrameObserver::CapturePageTextLater(
-    TextCaptureType capture_type,
-    base::TimeDelta delay) {
-  capture_timer_.Start(FROM_HERE, delay,
-                       base::Bind(&ChromeRenderFrameObserver::CapturePageText,
-                                  base::Unretained(this), capture_type));
+void ChromeRenderFrameObserver::DidMeaningfulLayout(
+    blink::WebMeaningfulLayout layout_type) {
+  switch (layout_type) {
+    case blink::WebMeaningfulLayout::FinishedParsing:
+      CapturePageText(PRELIMINARY_CAPTURE);
+      break;
+    case blink::WebMeaningfulLayout::FinishedLoading:
+      CapturePageText(FINAL_CAPTURE);
+      break;
+    default:
+      break;
+  }
 }