Fix prerender histograms for multiple prerender case.

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 <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
@@ skipping 147 matching lines @@
 bool PrerenderManager::is_prefetch_enabled_ = false;
 
 // static
 int PrerenderManager::prerenders_per_session_count_ = 0;
 
 // static
 PrerenderManager::PrerenderManagerMode PrerenderManager::mode_ =
     PRERENDER_MODE_ENABLED;
 
 struct PrerenderManager::NavigationRecord {
-  GURL url_;
-  base::TimeTicks time_;
   NavigationRecord(const GURL& url, base::TimeTicks time)
-      : url_(url),
-        time_(time) {
+      : url(url),
+        time(time) {
   }
+
+  GURL url;
+  base::TimeTicks time;
 };
 
+PrerenderManager::PrerenderedWebContentsData::
+PrerenderedWebContentsData(Origin origin) : origin(origin) {
+}
+
+PrerenderManager::WouldBePrerenderedWebContentsData::
+WouldBePrerenderedWebContentsData(Origin origin)
+  : origin(origin),

[mmenke, 2012/10/15 18:46:22]

nit:  4 space indent.

[gavinp, 2012/10/16 13:52:01]

Done.

+    state(WAITING_FOR_PROVISIONAL_LOAD) {
+}
+
 PrerenderManager::PrerenderManager(Profile* profile,
                                    PrerenderTracker* prerender_tracker)
     : enabled_(true),
       profile_(profile),
       prerender_tracker_(prerender_tracker),
       prerender_contents_factory_(PrerenderContents::CreateFactory()),
       last_prerender_start_time_(GetCurrentTimeTicks() -
           base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)),
       weak_factory_(this),
       prerender_history_(new PrerenderHistory(kHistoryLength)),
@@ skipping 39 matching lines @@
           FindPrerenderDataForChildAndRoute(process_id, route_id)) {
     // Instead of prerendering from inside of a running prerender, we will defer
     // this request until its launcher is made visible.
     if (PrerenderContents* contents = parent_prerender_data->contents_) {
       pending_prerender_list_.push_back(
           linked_ptr<PrerenderData>(new PrerenderData(this)));
       PrerenderHandle* prerender_handle =
           new PrerenderHandle(pending_prerender_list_.back().get());
       contents->AddPendingPrerender(
           prerender_handle->weak_ptr_factory_.GetWeakPtr(),
-          url, referrer, size);
+          ORIGIN_LINK_REL_PRERENDER, url, referrer, size);
       return prerender_handle;
     }
   }
 
   // Unit tests pass in a process_id == -1.
   SessionStorageNamespace* session_storage_namespace = NULL;
   if (process_id != -1) {
     RenderViewHost* source_render_view_host =
         RenderViewHost::FromID(process_id, route_id);
     if (!source_render_view_host)
@@ skipping 38 matching lines @@
   while (!active_prerender_list_.empty()) {
     PrerenderContents* prerender_contents =
         active_prerender_list_.front()->contents();
     prerender_contents->Destroy(FINAL_STATUS_CANCELLED);
   }
 }
 
 bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
                                                const GURL& url) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!IsWebContentsPrerendering(web_contents));
+  DCHECK(!IsWebContentsPrerendering(web_contents, NULL));
 
   DeleteOldEntries();
   DeletePendingDeleteEntries();
   // 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_);
@@ skipping 16 matching lines @@
   // Do not use the prerendered version if there is an opener object.
   if (web_contents->HasOpener()) {
     prerender_contents.release()->Destroy(FINAL_STATUS_WINDOW_OPENER);
     return false;
   }
 
   // If we are just in the control group (which can be detected by noticing
   // that prerendering hasn't even started yet), record that |web_contents| now
   // would be showing a prerendered contents, but otherwise, don't do anything.
   if (!prerender_contents->prerendering_has_started()) {
-    MarkWebContentsAsWouldBePrerendered(web_contents);
+    MarkWebContentsAsWouldBePrerendered(web_contents,
+                                        prerender_contents->origin());
     prerender_contents.release()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
     return false;
   }
 
   // Don't use prerendered pages if debugger is attached to the tab.
   // See http://crbug.com/98541
   if (content::DevToolsAgentHostRegistry::IsDebuggerAttached(web_contents)) {
     DestroyAndMarkMatchCompleteAsUsed(prerender_contents.release(),
                                       FINAL_STATUS_DEVTOOLS_ATTACHED);
     return false;
   }
 
   // If the prerendered page is in the middle of a cross-site navigation,
   // don't swap it in because there isn't a good way to merge histories.
   if (prerender_contents->IsCrossSiteNavigationPending()) {
     DestroyAndMarkMatchCompleteAsUsed(
         prerender_contents.release(),
         FINAL_STATUS_CROSS_SITE_NAVIGATION_PENDING);
     return false;
   }
 
   // For bookkeeping purposes, we need to mark this WebContents to
   // reflect that it would have been prerendered.
   if (GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP) {
-    MarkWebContentsAsWouldBePrerendered(web_contents);
+    MarkWebContentsAsWouldBePrerendered(web_contents,
+                                        prerender_contents->origin());
     prerender_contents.release()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
     return false;
   }
 
   int child_id, route_id;
   CHECK(prerender_contents->GetChildId(&child_id));
   CHECK(prerender_contents->GetRouteId(&route_id));
 
   // Try to set the prerendered page as used, so any subsequent attempts to
   // cancel on other threads will fail.  If this fails because the prerender
   // was already cancelled, possibly on another thread, fail.
   if (!prerender_tracker_->TryUse(child_id, route_id))
     return false;
 
   // At this point, we've determined that we will use the prerender.
 
   if (!prerender_contents->load_start_time().is_null()) {
     histograms_->RecordTimeUntilUsed(
+        prerender_contents->origin(),
         GetCurrentTimeTicks() - prerender_contents->load_start_time(),
         config_.time_to_live);
   }
 
-  histograms_->RecordPerSessionCount(++prerenders_per_session_count_);
+  histograms_->RecordPerSessionCount(prerender_contents->origin(),
+                                     ++prerenders_per_session_count_);
   histograms_->RecordUsedPrerender(prerender_contents->origin());
   prerender_contents->set_final_status(FINAL_STATUS_USED);
 
   RenderViewHost* new_render_view_host =
       prerender_contents->prerender_contents()->web_contents()->
           GetRenderViewHost();
   new_render_view_host->Send(
       new PrerenderMsg_SetIsPrerendering(new_render_view_host->GetRoutingID(),
                                          false));
 
   // Start pending prerender requests from the PrerenderContents, if there are
   // any.
   prerender_contents->StartPendingPrerenders();
 
   TabContents* new_tab_contents =
       prerender_contents->ReleasePrerenderContents();
   TabContents* old_tab_contents = TabContents::FromWebContents(web_contents);
   DCHECK(new_tab_contents);
   DCHECK(old_tab_contents);
 
-  MarkWebContentsAsPrerendered(new_tab_contents->web_contents());
+  MarkWebContentsAsPrerendered(new_tab_contents->web_contents(),
+                               prerender_contents->origin());
 
   // Merge the browsing history.
   new_tab_contents->web_contents()->GetController().CopyStateFromAndPrune(
       &old_tab_contents->web_contents()->GetController());
   CoreTabHelper::FromWebContents(old_tab_contents->web_contents())->delegate()->
       SwapTabContents(old_tab_contents->web_contents(),
                       new_tab_contents->web_contents());
   prerender_contents->CommitHistory(new_tab_contents);
 
   GURL icon_url = prerender_contents->icon_url();
@@ skipping 93 matching lines @@
     WebContents* web_contents,
     const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager =
       PrerenderManagerFactory::GetForProfile(
           Profile::FromBrowserContext(web_contents->GetBrowserContext()));
   if (!prerender_manager)
     return;
   if (!prerender_manager->IsEnabled())
     return;
-  bool was_prerender =
-      prerender_manager->IsWebContentsPrerendered(web_contents);
+
+  Origin prerender_origin = ORIGIN_NONE;
+  if (prerender_manager->IsWebContentsPrerendering(web_contents,
+                                                   &prerender_origin)) {
+    prerender_manager->histograms_->RecordPageLoadTimeNotSwappedIn(
+        prerender_origin, perceived_page_load_time, url);
+    return;
+  }
+
+  bool was_prerender = prerender_manager->IsWebContentsPrerendered(
+      web_contents, &prerender_origin);
   bool was_complete_prerender = was_prerender ||
-      prerender_manager->WouldWebContentsBePrerendered(web_contents);
-  if (prerender_manager->IsWebContentsPrerendering(web_contents)) {
-    prerender_manager->histograms_->RecordPageLoadTimeNotSwappedIn(
-        perceived_page_load_time, url);
-  } else {
-    prerender_manager->histograms_->RecordPerceivedPageLoadTime(
-        perceived_page_load_time, was_prerender, was_complete_prerender, url);
+      prerender_manager->WouldWebContentsBePrerendered(web_contents,
+                                                       &prerender_origin);
+  prerender_manager->histograms_->RecordPerceivedPageLoadTime(
+      prerender_origin, perceived_page_load_time, was_prerender,
+      was_complete_prerender, url);
+
+  if (was_prerender) {
     prerender_manager->histograms_->RecordPercentLoadDoneAtSwapin(
-        fraction_plt_elapsed_at_swap_in);
-    if (prerender_manager->local_predictor_.get()) {
-      prerender_manager->local_predictor_->
-          OnPLTEventForURL(url, perceived_page_load_time);
-    }
+        prerender_origin, fraction_plt_elapsed_at_swap_in);
   }
+  if (prerender_manager->local_predictor_.get()) {
+    prerender_manager->local_predictor_->
+        OnPLTEventForURL(url, perceived_page_load_time);
+  }
+}
+
+void PrerenderManager::RecordFractionPixelsFinalAtSwapin(
+    content::WebContents* web_contents,
+    double fraction) {
+  Origin origin = ORIGIN_NONE;
+  bool is_prerendered = IsWebContentsPrerendered(web_contents, &origin);
+  DCHECK(is_prerendered);
+  histograms_->RecordFractionPixelsFinalAtSwapin(origin, fraction);
 }
 
 void PrerenderManager::set_enabled(bool enabled) {
   DCHECK(CalledOnValidThread());
   enabled_ = enabled;
 }
 
 // static
 bool PrerenderManager::IsPrefetchEnabled() {
   return is_prefetch_enabled_;
@@ skipping 52 matching lines @@
 bool PrerenderManager::IsControlGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
 }
 
 // static
 bool PrerenderManager::IsNoUseGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
 }
 
 bool PrerenderManager::IsWebContentsPrerendering(
-    WebContents* web_contents) const {
+    WebContents* web_contents,
+    Origin* origin) const {
   DCHECK(CalledOnValidThread());
-  if (GetPrerenderContents(web_contents))
+  if (PrerenderContents* prerender_contents =
+          GetPrerenderContents(web_contents)) {
+    if (origin)
+      *origin = prerender_contents->origin();
     return true;
+  }
 
   // Also look through the pending-deletion list.
   for (std::list<PrerenderContents*>::const_iterator it =
            pending_delete_list_.begin();
        it != pending_delete_list_.end();
        ++it) {
     TabContents* prerender_tab_contents = (*it)->prerender_contents();
     if (prerender_tab_contents &&
-        prerender_tab_contents->web_contents() == web_contents)
+        prerender_tab_contents->web_contents() == web_contents) {
+      if (origin)
+        *origin = (*it)->origin();
       return true;
+    }
   }
 
   return false;
 }
 
 PrerenderContents* PrerenderManager::GetPrerenderContents(
     content::WebContents* web_contents) const {
   DCHECK(CalledOnValidThread());
   for (std::list<linked_ptr<PrerenderData> >::const_iterator it =
            active_prerender_list_.begin();
        it != active_prerender_list_.end();
        ++it) {
     TabContents* prerender_tab_contents =
         it->get()->contents_->prerender_contents();
     if (prerender_tab_contents &&
         prerender_tab_contents->web_contents() == web_contents) {
       return it->get()->contents_;
     }
   }
   return NULL;
 }
 
-void PrerenderManager::MarkWebContentsAsPrerendered(WebContents* web_contents) {
+void PrerenderManager::MarkWebContentsAsPrerendered(WebContents* web_contents,
+                                                    Origin origin) {
   DCHECK(CalledOnValidThread());
-  prerendered_tab_contents_set_.insert(web_contents);
+  prerendered_web_contents_data_.insert(
+      base::hash_map<content::WebContents*,
+                     PrerenderedWebContentsData>::value_type(
+                         web_contents, PrerenderedWebContentsData(origin)));
 }
 
 void PrerenderManager::MarkWebContentsAsWouldBePrerendered(
-    WebContents* web_contents) {
+    WebContents* web_contents,
+    Origin origin) {
   DCHECK(CalledOnValidThread());
-  would_be_prerendered_map_[web_contents] = true;
+  would_be_prerendered_map_.insert(
+      base::hash_map<content::WebContents*,
+                     WouldBePrerenderedWebContentsData>::value_type(
+                         web_contents,
+                         WouldBePrerenderedWebContentsData(origin)));
 }
 
 void PrerenderManager::MarkWebContentsAsNotPrerendered(
     WebContents* web_contents) {
   DCHECK(CalledOnValidThread());
-  prerendered_tab_contents_set_.erase(web_contents);
-  WouldBePrerenderedMap::iterator it =
-      would_be_prerendered_map_.find(web_contents);
+  prerendered_web_contents_data_.erase(web_contents);
+  base::hash_map<content::WebContents*, WouldBePrerenderedWebContentsData>::
+      iterator it = would_be_prerendered_map_.find(web_contents);
   if (it != would_be_prerendered_map_.end()) {
-    bool first_time = it->second;
-    if (first_time) {
-      it->second = false;
+    if (it->second.state ==
+            WouldBePrerenderedWebContentsData::WAITING_FOR_PROVISIONAL_LOAD) {
+      it->second.state =
+          WouldBePrerenderedWebContentsData::SEEN_PROVISIONAL_LOAD;
     } else {
       would_be_prerendered_map_.erase(it);
     }
   }
 }
 
 bool PrerenderManager::IsWebContentsPrerendered(
-    content::WebContents* web_contents) const {
+    content::WebContents* web_contents,
+    Origin* origin) const {
   DCHECK(CalledOnValidThread());
-  return prerendered_tab_contents_set_.count(web_contents) > 0;
+  base::hash_map<content::WebContents*, PrerenderedWebContentsData>::
+      const_iterator it = prerendered_web_contents_data_.find(web_contents);
+  if (it == prerendered_web_contents_data_.end())
+    return false;
+  if (origin)
+    *origin = it->second.origin;
+  return true;
 }
 
 bool PrerenderManager::WouldWebContentsBePrerendered(
-    WebContents* web_contents) const {
+    WebContents* web_contents,
+    Origin* origin) const {
   DCHECK(CalledOnValidThread());
-  return would_be_prerendered_map_.count(web_contents) > 0;
+  base::hash_map<content::WebContents*, WouldBePrerenderedWebContentsData>::
+      const_iterator it = would_be_prerendered_map_.find(web_contents);
+  if (it == would_be_prerendered_map_.end())
+    return false;
+  if (origin)
+    *origin = it->second.origin;
+  return true;
 }
 
-bool PrerenderManager::HasRecentlyBeenNavigatedTo(const GURL& url) {
+bool PrerenderManager::HasRecentlyBeenNavigatedTo(Origin origin,
+                                                  const GURL& url) {
   DCHECK(CalledOnValidThread());
 
   CleanUpOldNavigations();
   std::list<NavigationRecord>::const_reverse_iterator end = navigations_.rend();
   for (std::list<NavigationRecord>::const_reverse_iterator it =
            navigations_.rbegin();
        it != end;
        ++it) {
-    if (it->url_ == url) {
-      base::TimeDelta delta = GetCurrentTimeTicks() - it->time_;
-      histograms_->RecordTimeSinceLastRecentVisit(delta);
+    if (it->url == url) {
+      base::TimeDelta delta = GetCurrentTimeTicks() - it->time;
+      histograms_->RecordTimeSinceLastRecentVisit(origin, delta);
       return true;
     }
   }
 
   return false;
 }
 
 // static
 bool PrerenderManager::IsValidHttpMethod(const std::string& method) {
   // method has been canonicalized to upper case at this point so we can just
@@ skipping 261 matching lines @@
 #if !defined(OS_ANDROID)
   if (content::RenderProcessHost::ShouldTryToUseExistingProcessHost(
           profile_, url) &&
       !content::RenderProcessHost::run_renderer_in_process()) {
     RecordFinalStatus(origin, experiment, FINAL_STATUS_TOO_MANY_PROCESSES);
     return NULL;
   }
 #endif
 
   // Check if enough time has passed since the last prerender.
-  if (!DoesRateLimitAllowPrerender()) {
+  if (!DoesRateLimitAllowPrerender(origin)) {
     // Cancel the prerender. We could add it to the pending prerender list but
     // this doesn't make sense as the next prerender request will be triggered
     // by a navigation and is unlikely to be the same site.
     RecordFinalStatus(origin, experiment, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return NULL;
   }
 
   PrerenderContents* prerender_contents = CreatePrerenderContents(
       url, referrer, origin, experiment);
   if (!prerender_contents || !prerender_contents->Init())
@@ skipping 182 matching lines @@
   for (std::list<linked_ptr<PrerenderData> >::iterator
            it = active_prerender_list_.begin();
        it != active_prerender_list_.end();
        ++it) {
     if (prerender_contents == it->get()->contents_)
       return it;
   }
   return active_prerender_list_.end();
 }
 
-bool PrerenderManager::DoesRateLimitAllowPrerender() const {
+bool PrerenderManager::DoesRateLimitAllowPrerender(Origin origin) const {
   DCHECK(CalledOnValidThread());
   base::TimeDelta elapsed_time =
       GetCurrentTimeTicks() - last_prerender_start_time_;
-  histograms_->RecordTimeBetweenPrerenderRequests(elapsed_time);
+  histograms_->RecordTimeBetweenPrerenderRequests(origin, elapsed_time);
   if (!config_.rate_limit_enabled)
     return true;
   return elapsed_time >
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 }
 
 void PrerenderManager::DeleteOldTabContents() {
   while (!old_tab_contents_list_.empty()) {
     TabContents* tab_contents = old_tab_contents_list_.front();
     old_tab_contents_list_.pop_front();
     // TODO(dominich): should we use Instant Unload Handler here?
     delete tab_contents;
   }
 }
 
 void PrerenderManager::CleanUpOldNavigations() {
   DCHECK(CalledOnValidThread());
 
   // Cutoff.  Navigations before this cutoff can be discarded.
   base::TimeTicks cutoff = GetCurrentTimeTicks() -
       base::TimeDelta::FromMilliseconds(kNavigationRecordWindowMs);
   while (!navigations_.empty()) {
-    if (navigations_.front().time_ > cutoff)
+    if (navigations_.front().time > cutoff)
       break;
     navigations_.pop_front();
   }
 }
 
 void PrerenderManager::ScheduleDeleteOldTabContents(
     TabContents* tab,
     OnCloseTabContentsDeleter* deleter) {
   old_tab_contents_list_.push_back(tab);
   PostCleanupTask();
@@ skipping 84 matching lines @@
   if (!render_process_host || !render_process_host->GetBrowserContext())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->GetBrowserContext());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender