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 <limits>
 #include <string>
 #include <vector>
 
@@ skipping 31 matching lines @@
 
 using blink::WebDataSource;
 using blink::WebElement;
 using blink::WebLocalFrame;
 using blink::WebNode;
 using blink::WebNodeList;
 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;
+// // 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;
+// 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 {
 
@@ skipping 33 matching lines @@
                                        static_cast<int>(scaled_size.height()));
 }
 
 }  // namespace
 
 PageInfo::PageInfo(PageInfoReceiver* context)
     : context_(context), capture_timer_(false, false) {
   DCHECK(context_);
 }
 
-// TODO(dglazkov): Refactor to remove the RenderFrame* argument.
-void PageInfo::CapturePageInfoLater(CaptureType capture_type,
-                                    RenderFrame* render_frame,
-                                    base::TimeDelta delay) {
-  capture_timer_.Start(
-      FROM_HERE, delay,
-      base::Bind(&PageInfo::CapturePageInfo, base::Unretained(this),
-                 render_frame, capture_type));
-}
+// // TODO(dglazkov): Refactor to remove the RenderFrame* argument.
+// void PageInfo::CapturePageInfoLater(CaptureType capture_type,
+//                                     RenderFrame* render_frame,
+//                                     base::TimeDelta delay) {
+//   capture_timer_.Start(
+//       FROM_HERE, delay,
+//       base::Bind(&PageInfo::CapturePageInfo, base::Unretained(this),
+//                  render_frame, capture_type));
+// }
 
 bool PageInfo::IsErrorPage(WebLocalFrame* frame) {
   WebDataSource* ds = frame->dataSource();
   return ds && ds->hasUnreachableURL();
 }
 
 void PageInfo::CapturePageInfo(RenderFrame* render_frame,
                                CaptureType capture_type) {
   if (!render_frame)
     return;
 
   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;
 
   if (IsErrorPage(frame))
     return;
 
   // Don't index/capture pages that are being prerendered.
   if (prerender::PrerenderHelper::IsPrerendering(render_frame)) {
     return;
@@ skipping 219 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;
-
-  page_info_.CapturePageInfoLater(
-      FINAL_CAPTURE, render_frame(),
-      base::TimeDelta::FromMilliseconds(
-          render_frame()->GetRenderView()->GetContentStateImmediately()
-              ? 0
-              : kDelayForCaptureMs));
+  // // TODO(dglazkov): This is only necessary for testing and indicates that
+  // // the tests that rely on this specific timing need to be rewritten to
+  // // avoid this kludge.
+  // if (render_frame()->GetRenderView()->GetContentStateImmediately()) {
+  //   page_info_.CapturePageInfo(render_frame(), FINAL_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;
+  // // 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()));
+}
 
-  page_info_.CapturePageInfoLater(
-      PRELIMINARY_CAPTURE, render_frame(),
-      base::TimeDelta::FromMilliseconds(kDelayForForcedCaptureMs));
+void ChromeRenderFrameObserver::DidMeaningfulLayout(
+    blink::WebMeaningfulLayout layout_type) {
+  switch (layout_type) {
+    case blink::WebMeaningfulLayout::FinishedParsing:
+      page_info_.CapturePageInfo(render_frame(), PRELIMINARY_CAPTURE);
+      break;
+    case blink::WebMeaningfulLayout::FinishedLoading:
+      page_info_.CapturePageInfo(render_frame(), FINAL_CAPTURE);
+      break;
+    default:
+      break;
+  }
 }
 
 void ChromeRenderFrameObserver::PageCaptured(base::string16* content,
                                              CaptureType capture_type) {
-  if (translate_helper_)
+  bool is_preliminary_capture = capture_type == PRELIMINARY_CAPTURE;
+  if (translate_helper_ && is_preliminary_capture)
     translate_helper_->PageCaptured(*content);
 
-  TRACE_EVENT0("renderer", "ChromeRenderViewObserver::CapturePageInfo");
+  TRACE_EVENT0("renderer", "ChromeRenderFrameObserver::CapturePageInfo");
 
 #if defined(FULL_SAFE_BROWSING)
   // Will swap out the string.
   if (phishing_classifier_)
-    phishing_classifier_->PageCaptured(content,
-                                       capture_type == PRELIMINARY_CAPTURE);
+    phishing_classifier_->PageCaptured(content, is_preliminary_capture);
 #endif
 }