[Prerender] first contentful paint histograms.

chrome/browser/prerender/prerender_manager.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/browser/prerender/prerender_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 157 matching lines @@
 
 PrerenderManager::PrerenderManager(Profile* profile)
     : profile_(profile),
       prerender_contents_factory_(PrerenderContents::CreateFactory()),
       prerender_history_(new PrerenderHistory(kHistoryLength)),
       histograms_(new PrerenderHistograms()),
       profile_network_bytes_(0),
       last_recorded_profile_network_bytes_(0),
       clock_(new base::DefaultClock()),
       tick_clock_(new base::DefaultTickClock()),
+      page_load_metric_observer_disabled_(false),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   last_prerender_start_time_ =
       GetCurrentTimeTicks() -
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 
   // Certain experiments override our default config_ values.
   switch (PrerenderManager::GetMode()) {
     case PrerenderManager::PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP:
@@ skipping 150 matching lines @@
   // First, try to find prerender data with the correct session storage
   // namespace.
   // TODO(ajwong): This doesn't handle isolated apps correctly.
   PrerenderData* prerender_data = FindPrerenderData(
       url,
       web_contents->GetController().GetDefaultSessionStorageNamespace());
   if (!prerender_data)
     return false;
   DCHECK(prerender_data->contents());
 
-  if (prerender_data->contents()->prerender_mode() != FULL_PRERENDER)
+  if (prerender_data->contents()->prerender_mode() != FULL_PRERENDER) {
     return false;
+  }
 
   std::unique_ptr<WebContents> new_web_contents = SwapInternal(
       url, web_contents, prerender_data, params->should_replace_current_entry);
   if (!new_web_contents)
     return false;
 
   // Record the new target_contents for the callers.
   params->target_contents = new_web_contents.release();
   return true;
 }
@@ skipping 221 matching lines @@
                                               is_redirect, is_no_store);
 }
 
 void PrerenderManager::RecordPrefetchRedirectCount(Origin origin,
                                                    bool is_main_resource,
                                                    int redirect_count) {
   histograms_->RecordPrefetchRedirectCount(origin, is_main_resource,
                                            redirect_count);
 }
 
-void PrerenderManager::RecordFirstContentfulPaint(const GURL& url,
-                                                  bool is_no_store,
-                                                  base::TimeDelta time) {
+void PrerenderManager::RecordNoStateFirstContentfulPaint(const GURL& url,
+                                                         bool is_no_store,
+                                                         base::TimeDelta time) {
   CleanUpOldNavigations(&prefetches_, base::TimeDelta::FromMinutes(30));
 
   // Compute the prefetch age.
   base::TimeDelta prefetch_age;
   Origin origin = ORIGIN_NONE;
   for (auto it = prefetches_.crbegin(); it != prefetches_.crend(); ++it) {
     if (it->url == url) {
       prefetch_age = GetCurrentTimeTicks() - it->time;
       origin = it->origin;
       break;
     }
   }
 
-  histograms_->RecordFirstContentfulPaint(origin, is_no_store, time,
-                                          prefetch_age);
+  histograms_->RecordNoStateFirstContentfulPaint(origin, is_no_store, time,
+                                                 prefetch_age);
 
   // Loading a prefetched URL resets the revalidation bypass. Remove the url
   // from the prefetch list for more accurate metrics.
   prefetches_.erase(
       std::remove_if(prefetches_.begin(), prefetches_.end(),
                      [url](const NavigationRecord& r) { return r.url == url; }),
       prefetches_.end());
 }
 
+void PrerenderManager::RecordPerceivedFirstContentfulPaint(
+    content::WebContents* web_contents,
+    base::TimeTicks first_contentful_paint,
+    bool was_hidden) {
+  for (auto& observer : observers_) {
+    observer->OnFirstContentfulPaint();
+  }
+
+  PrerenderTabHelper* tab_helper =
+      PrerenderTabHelper::FromWebContents(web_contents);
+  DCHECK(tab_helper);
+
+  base::TimeTicks last_swap = tab_helper->last_swap();
+  if (!last_swap.is_null() && !first_contentful_paint.is_null()) {
+    histograms_->RecordPerceivedFirstContentfulPaintTime(
+        tab_helper->origin(), first_contentful_paint - last_swap, was_hidden);
+    histograms_->RecordPerceivedFirstContentfulPaintStatus(tab_helper->origin(),
+                                                           true, was_hidden);
+  } else {
+    histograms_->RecordPerceivedFirstContentfulPaintStatus(tab_helper->origin(),
+                                                           false, was_hidden);
+  }
+}
+
 // static
 PrerenderManager::PrerenderManagerMode PrerenderManager::GetMode() {
   return mode_;
 }
 
 // static
 void PrerenderManager::SetMode(PrerenderManagerMode mode) {
   mode_ = mode;
 }
 
@@ skipping 496 matching lines @@
 void PrerenderManager::SetClockForTesting(
     std::unique_ptr<base::SimpleTestClock> clock) {
   clock_ = std::move(clock);
 }
 
 void PrerenderManager::SetTickClockForTesting(
     std::unique_ptr<base::SimpleTestTickClock> tick_clock) {
   tick_clock_ = std::move(tick_clock);
 }
 
+void PrerenderManager::AddObserver(
+    std::unique_ptr<PrerenderManagerObserver> observer) {
+  observers_.push_back(std::move(observer));
+}
+
 std::unique_ptr<PrerenderContents> PrerenderManager::CreatePrerenderContents(
     const GURL& url,
     const content::Referrer& referrer,
     Origin origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return base::WrapUnique(prerender_contents_factory_->CreatePrerenderContents(
       this, profile_, url, referrer, origin));
 }
 
 void PrerenderManager::SortActivePrerenders() {
@@ skipping 252 matching lines @@
   DCHECK_EQ(1u, erased);
 }
 
 void PrerenderManager::SetPrerenderContentsFactoryForTest(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 }  // namespace prerender