[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 132 matching lines @@
     // |this| is deleted at this point.
   }
 
   PrerenderManager* const manager_;
   std::unique_ptr<WebContents> tab_;
   bool suppressed_dialog_;
 
   DISALLOW_COPY_AND_ASSIGN(OnCloseWebContentsDeleter);
 };
 
+PrerenderManagerObserver::~PrerenderManagerObserver() {}
+
 // static
 int PrerenderManager::prerenders_per_session_count_ = 0;
 
 // static
 PrerenderManager::PrerenderManagerMode PrerenderManager::mode_ =
     PRERENDER_MODE_ENABLED;
 
 struct PrerenderManager::NavigationRecord {
   NavigationRecord(const GURL& url, base::TimeTicks time, Origin origin)
       : url(url), time(time), origin(origin) {}
 
   GURL url;
   base::TimeTicks time;
   Origin origin;
 };
 
 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);
 
   notification_registrar_.Add(
       this, chrome::NOTIFICATION_PROFILE_DESTROYED,
       content::Source<Profile>(profile_));
@@ skipping 371 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) {
-  CleanUpOldNavigations(&prefetches_, base::TimeDelta::FromMinutes(30));
+void PrerenderManager::RecordNoStateFirstContentfulPaint(const GURL& url,
+                                                         bool is_no_store,
+                                                         bool was_hidden,
+                                                         base::TimeDelta time) {
+  base::TimeDelta prefetch_age;
+  Origin origin;
+  GetPrefetchInformation(url, &prefetch_age, &origin);
 
-  // Compute the prefetch age.
+  histograms_->RecordPrefetchFirstContentfulPaintTime(
+      origin, is_no_store, was_hidden, time, prefetch_age);
+
+  for (auto& observer : observers_) {
+    observer->OnFirstContentfulPaint();
+  }
+}
+
+void PrerenderManager::RecordPrerenderFirstContentfulPaint(
+    const GURL& url,
+    content::WebContents* web_contents,
+    bool is_no_store,
+    bool was_hidden,
+    base::TimeTicks first_contentful_paint) {
+  PrerenderTabHelper* tab_helper =
+      PrerenderTabHelper::FromWebContents(web_contents);
+  DCHECK(tab_helper);
+
   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;
-    }
+  // The prefetch origin may not be relevant to the prerender.

[pasko, 2016/12/21 18:39:09]

s/may not be/is not/

[mattcary, 2016/12/22 10:49:07]

No, may not be. Sometimes it is the same.

[pasko, 2016/12/22 18:22:00]

Then extracting this bit of information from the code and the comment makes the
comment not worth it IMO. It could be that I asked to put a clarifying comment
to explain a little about |unused_origin|. Apologies in this case, it did not
work well.

[mattcary, 2016/12/23 09:58:15]

Oh, I see. Done.

+  Origin unused_origin;
+  GetPrefetchInformation(url, &prefetch_age, &unused_origin);
+
+  base::TimeTicks last_swap = tab_helper->last_swap();
+  if (!last_swap.is_null() && !first_contentful_paint.is_null()) {
+    histograms_->RecordPrefetchFirstContentfulPaintTime(
+        tab_helper->origin(), is_no_store, was_hidden,
+        first_contentful_paint - last_swap, prefetch_age);
+    histograms_->RecordPerceivedFirstContentfulPaintStatus(tab_helper->origin(),
+                                                           true, was_hidden);
+  } else {
+    histograms_->RecordPerceivedFirstContentfulPaintStatus(tab_helper->origin(),
+                                                           false, was_hidden);

[pasko, 2016/12/21 18:39:09]

this repetition with changing one magic boolean can be explained better like
this:

  base::TimeTicks last_swap = tab_helper->last_swap();
  bool perceived_fcp_recorded = false;
  if (!last_swap.is_null() && !first_contentful_paint.is_null()) {
    perceived_fcp_recorded = true;
    histograms_->RecordPrefetchFirstContentfulPaintTime(
        tab_helper->origin(), is_no_store, was_hidden,
        first_contentful_paint - last_swap, prefetch_age);
  }
  histograms_->RecordPerceivedFirstContentfulPaintStatus(
      tab_helper->origin(), perceived_fcp_recorded, was_hidden);

[mattcary, 2016/12/22 10:49:07]

Done.

   }
 
-  histograms_->RecordFirstContentfulPaint(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());
+  for (auto& observer : observers_) {
+    observer->OnFirstContentfulPaint();
+  }
 }
 
 // static
 PrerenderManager::PrerenderManagerMode PrerenderManager::GetMode() {
   return mode_;
 }
 
 // static
 void PrerenderManager::SetMode(PrerenderManagerMode mode) {
   mode_ = mode;
@@ skipping 428 matching lines @@
   base::ElapsedTimer cleanup_timer;
 
   // Perform deferred cleanup work.
   DeleteOldWebContents();
   DeleteOldEntries();
   if (active_prerenders_.empty())
     StopSchedulingPeriodicCleanups();
 
   to_delete_prerenders_.clear();
 
+  CleanUpOldNavigations(&prefetches_, base::TimeDelta::FromMinutes(30));
+
   // Measure how long a the various cleanup tasks took. http://crbug.com/305419.
   UMA_HISTOGRAM_TIMES("Prerender.PeriodicCleanupDeleteContentsTime",
                       cleanup_timer.Elapsed());
 }
 
 void PrerenderManager::PostCleanupTask() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrerenderManager::PeriodicCleanup,
                             weak_factory_.GetWeakPtr()));
@@ skipping 33 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 42 matching lines @@
 
 void PrerenderManager::DeleteOldWebContents() {
   for (WebContents* web_contents : old_web_contents_list_) {
     // TODO(dominich): should we use Instant Unload Handler here?
     // Or should |old_web_contents_list_| contain unique_ptrs?
     delete web_contents;
   }
   old_web_contents_list_.clear();
 }
 
+void PrerenderManager::GetPrefetchInformation(const GURL& url,
+                                              base::TimeDelta* prefetch_age,
+                                              Origin* origin) {
+  DCHECK(prefetch_age);
+  DCHECK(origin);
+  CleanUpOldNavigations(&prefetches_, base::TimeDelta::FromMinutes(30));
+
+  *prefetch_age = base::TimeDelta();
+  *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;
+    }
+  }
+
+  // Loading a prefetched URL resets the revalidation bypass. Remove all
+  // matching urls 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::CleanUpOldNavigations(
     std::vector<NavigationRecord>* navigations,
     base::TimeDelta max_age) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Cutoff. Navigations before this cutoff can be discarded.
   base::TimeTicks cutoff = GetCurrentTimeTicks() - max_age;
   auto it = navigations->begin();
   for (; it != navigations->end(); ++it) {
     if (it->time > cutoff)
@@ skipping 194 matching lines @@
   return weak_factory_.GetWeakPtr();
 }
 
 void PrerenderManager::SetPrerenderContentsFactoryForTest(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 }  // namespace prerender