[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/12 17:32:06]

does this sentence refer to some actions being done by the code below to
mitigate the situation? If so, which is it?

[mattcary, 2016/12/12 21:14:54]

It explains the following line, where the origin retreived from
GetPrefetchInformation is not used (because it is not relevant to the
prerender).

[pasko, 2016/12/15 19:37:51]

Makes sense now, not sure why it was not clear before. Thanks.

+  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);
   }
 
-  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) {

[pasko, 2016/12/12 17:32:06]

This matches only the start URL, while Prerender swap-in also takes care of
matching session_storage_namespace (roughly for multi-profile), and alias_urls_.
The effect of the former is probably small, but the latter may introduce bias,
since it may record metrics only for a subset of prerendered+used pages.

[mattcary, 2016/12/12 21:14:54]

Hmm. For prefetch (which is the context this was originally written), wouldn't
that also be an issue, because the cache is per-profile?

alias_urls_ seem to be only tracked in the PrerenderContents?  So it will not be
possible to deal with alias_urls_ for nostate prefetches?

If that's true, since the point of these histograms is to compare for the
experiment, we will want the prerender and nostate prefetch bias to be the same.
WDYT?

[pasko, 2016/12/15 19:37:51]

Oh, all prefetches_ are biased indeed. Well, one way is to say that
multi-profile is small (pointing at some metric I did not find yet). If that's
easier than proper prefetches_ (I think it is), then let's go for it.

+      *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