Revert of 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));
   }
 
-  // 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);
-  }
+  // 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));
 }
 
 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);
 
-  // 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)
+  if (translate_helper_)
     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::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;
-  }
+void ChromeRenderFrameObserver::CapturePageTextLater(
+    TextCaptureType capture_type,
+    base::TimeDelta delay) {
+  capture_timer_.Start(FROM_HERE, delay,
+                       base::Bind(&ChromeRenderFrameObserver::CapturePageText,
+                                  base::Unretained(this), capture_type));
 }