Rename RFO::FrameWillClose() to reflect its actual purpose.

chrome/renderer/page_load_histograms.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.
 
 // TODO(bmcquade): delete this class in October 2016, as it is deprecated by the
 // new PageLoad.* UMA histograms.
 
 #include "chrome/renderer/page_load_histograms.h"
 
 #include <stddef.h>
@@ skipping 19 matching lines @@
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/url_pattern.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPerformance.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "url/gurl.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/renderer/extensions/chrome_extensions_renderer_client.h"
 #include "extensions/renderer/dispatcher.h"
 #endif
 
 using blink::WebDataSource;
-using blink::WebFrame;
+using blink::WebLocalFrame;
 using blink::WebPerformance;
 using blink::WebString;
 using base::Time;
 using base::TimeDelta;
 using content::DocumentState;
 
 const size_t kPLTCount = 100;
 
 namespace {
 
@@ skipping 64 matching lines @@
 URLPattern::SchemeMasks GetSupportedSchemeType(const GURL& url) {
   if (url.SchemeIs("http"))
     return URLPattern::SCHEME_HTTP;
   else if (url.SchemeIs("https"))
     return URLPattern::SCHEME_HTTPS;
   return static_cast<URLPattern::SchemeMasks>(0);
 }
 
 // Helper function to check for string in 'via' header. Returns true if
 // |via_value| is one of the values listed in the Via header.
-bool ViaHeaderContains(WebFrame* frame, const std::string& via_value) {
+bool ViaHeaderContains(WebLocalFrame* frame, const std::string& via_value) {
   const char kViaHeaderName[] = "Via";
   std::vector<std::string> values;
   // Multiple via headers have already been coalesced and hence each value
   // separated by a comma corresponds to a proxy. The value added by a proxy is
   // not expected to contain any commas.
   // Example., Via: 1.0 Compression proxy, 1.1 Google Instant Proxy Preview
   values = base::SplitString(
       frame->dataSource()->response().httpHeaderField(kViaHeaderName).utf8(),
       ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   return std::find(values.begin(), values.end(), via_value) != values.end();
@@ skipping 374 matching lines @@
             begin_to_finish_all_loads);
         break;
       default:
         break;
     }
   }
 }
 
 }  // namespace
 
-PageLoadHistograms::PageLoadHistograms(content::RenderView* render_view)
-    : content::RenderViewObserver(render_view) {
-}
+PageLoadHistograms::PageLoadHistograms(content::RenderFrame* render_frame)
+    : content::RenderFrameObserver(render_frame), helper_(this) {}
 
 PageLoadHistograms::~PageLoadHistograms() {
 }
 
-void PageLoadHistograms::Dump(WebFrame* frame) {
+void PageLoadHistograms::Dump() {
+  WebLocalFrame* frame = render_frame()->GetWebFrame();
+
   // We only dump histograms for main frames.
   // In the future, it may be interesting to tag subframes and dump them too.
-  if (!frame || frame->parent())
-    return;
-
-  // If the main frame lives in a different process, don't do anything.
-  // Histogram data will be recorded by the real main frame.
-  if (frame->isWebRemoteFrame())
-    return;
+  DCHECK(frame && !frame->parent());
 
   // Only dump for supported schemes.
   URLPattern::SchemeMasks scheme_type =
       GetSupportedSchemeType(frame->document().url());
   if (scheme_type == 0)
     return;
 
   // Don't dump stats for the NTP, as PageLoadHistograms should only be recorded
   // for pages visited due to an explicit user navigation.
   if (SearchBouncer::GetInstance()->IsNewTabPage(frame->document().url())) {
@@ skipping 32 matching lines @@
   // sure that we send the histograms generated. Without this call, pages
   // that don't have an on-close-handler might generate data that is lost if
   // the renderer is shutdown abruptly (e.g. the user closed the tab).
   // TODO(bcwhite): Remove completely when persistence is on-by-default.
   if (!base::GlobalHistogramAllocator::Get()) {
     content::RenderThread::Get()->UpdateHistograms(
         content::kHistogramSynchronizerReservedSequenceNumber);
   }
 }
 
-void PageLoadHistograms::FrameWillClose(WebFrame* frame) {
-  Dump(frame);
-}
-
-void PageLoadHistograms::ClosePage() {
-  // TODO(davemoore) This code should be removed once willClose() gets
-  // called when a page is destroyed. page_load_histograms_.Dump() is safe
-  // to call multiple times for the same frame, but it will simplify things.
-  Dump(render_view()->GetWebView()->mainFrame());
+void PageLoadHistograms::WillCommitProvisionalLoad() {
+  Dump();
 }
 
 void PageLoadHistograms::LogPageLoadTime(const DocumentState* document_state,
                                          const WebDataSource* ds) const {
   // Because this function gets called on every page load,
   // take extra care to optimize it away if logging is turned off.
   if (logging::LOG_INFO < logging::GetMinLogLevel())
     return;
 
   DCHECK(document_state);
   DCHECK(ds);
   GURL url(ds->request().url());
   Time start = document_state->start_load_time();
   Time finish = document_state->finish_load_time();
   // TODO(mbelshe): should we log more stats?
   VLOG(1) << "PLT: " << (finish - start).InMilliseconds() << "ms "
           << url.spec();
 }
 
 void PageLoadHistograms::OnDestruct() {
   delete this;
 }
+
+PageLoadHistograms::Helper::Helper(PageLoadHistograms* histograms)
+    : RenderViewObserver(histograms->render_frame()->GetRenderView()),
+      histograms_(histograms) {
+}
+
+void PageLoadHistograms::Helper::ClosePage() {
+  histograms_->Dump();
+}
+
+void PageLoadHistograms::Helper::OnDestruct() {
+}