Add observer interface to PrerenderContents.

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 402 matching lines @@
 
   if (!prerender_contents->load_start_time().is_null()) {
     histograms_->RecordTimeUntilUsed(
         prerender_contents->origin(),
         GetCurrentTimeTicks() - prerender_contents->load_start_time());
   }
 
   histograms_->RecordPerSessionCount(prerender_contents->origin(),
                                      ++prerenders_per_session_count_);
   histograms_->RecordUsedPrerender(prerender_contents->origin());
-  prerender_contents->set_final_status(FINAL_STATUS_USED);
+  prerender_contents->SetFinalStatus(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.
@@ skipping 185 matching lines @@
   return "";
 }
 
 // static
 bool PrerenderManager::IsPrerenderingPossible() {
   return GetMode() != PRERENDER_MODE_DISABLED;
 }
 
 // static
 bool PrerenderManager::ActuallyPrerendering() {
-  return IsPrerenderingPossible() && !IsControlGroup();
+  return IsPrerenderingPossible() && !IsControlGroup(kNoExperiment);
 }
 
 // static
-bool PrerenderManager::IsControlGroup() {
-  return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
+bool PrerenderManager::IsControlGroup(uint8 experiment_id) {
+  return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP ||
+      IsControlGroupExperiment(experiment_id);
 }
 
 // static
 bool PrerenderManager::IsNoUseGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
 }
 
 bool PrerenderManager::IsWebContentsPrerendering(
     WebContents* web_contents,
     Origin* origin) const {
@@ skipping 154 matching lines @@
 
 DictionaryValue* PrerenderManager::GetAsValue() const {
   DCHECK(CalledOnValidThread());
   DictionaryValue* dict_value = new DictionaryValue();
   dict_value->Set("history", prerender_history_->GetEntriesAsValue());
   dict_value->Set("active", GetActivePrerendersAsValue());
   dict_value->SetBoolean("enabled", enabled_);
   dict_value->SetBoolean("omnibox_enabled", IsOmniboxEnabled(profile_));
   // If prerender is disabled via a flag this method is not even called.
   std::string enabled_note;
-  if (IsControlGroup())
+  if (IsControlGroup(kNoExperiment))
     enabled_note += "(Control group: Not actually prerendering) ";
   if (IsNoUseGroup())
     enabled_note += "(No-use group: Not swapping in prerendered pages) ";
   if (GetMode() == PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP)
     enabled_note +=
         "(15 min TTL group: Extended prerender eviction to 15 mins) ";
   dict_value->SetString("enabled_note", enabled_note);
   return dict_value;
 }
 
@@ skipping 189 matching lines @@
       IsGoogleSearchResultURL(referrer.url)) {
     origin = ORIGIN_GWS_PRERENDER;
   }
 
   DeleteOldEntries();
   to_delete_prerenders_.clear();
 
   GURL url = url_arg;
   GURL alias_url;
   uint8 experiment = GetQueryStringBasedExperiment(url_arg);
-  bool control_group_behavior =
-      IsControlGroup() || IsControlGroupExperiment(experiment);
-  if (control_group_behavior &&
+  if (IsControlGroup(experiment) &&
       MaybeGetQueryStringBasedAliasURL(url, &alias_url)) {
     url = alias_url;
   }
 
   // From here on, we will record a FinalStatus so we need to register with the
   // histogram tracking.
   histograms_->RecordPrerender(origin, url_arg);
 
   if (PrerenderData* preexisting_prerender_data =
           FindPrerenderData(url, session_storage_namespace)) {
@@ skipping 44 matching lines @@
   PrerenderHandle* prerender_handle =
       new PrerenderHandle(active_prerenders_.back());
   SortActivePrerenders();
 
   last_prerender_start_time_ = GetCurrentTimeTicks();
 
   gfx::Size contents_size =
       size.IsEmpty() ? config_.default_tab_bounds.size() : size;
 
   prerender_contents->StartPrerendering(process_id, contents_size,
-                                        session_storage_namespace,
-                                        control_group_behavior);
-  DCHECK(control_group_behavior ||
+                                        session_storage_namespace);
+
+  DCHECK(IsControlGroup(experiment) ||
          prerender_contents->prerendering_has_started());
 
   while (active_prerenders_.size() > config_.max_concurrency) {
     prerender_contents = active_prerenders_.front()->contents();
     DCHECK(prerender_contents);
     prerender_contents->Destroy(FINAL_STATUS_EVICTED);
   }
 
   histograms_->RecordConcurrency(active_prerenders_.size(),
                                  config_.max_concurrency);
@@ skipping 78 matching lines @@
   return base::TimeTicks::Now();
 }
 
 PrerenderContents* PrerenderManager::CreatePrerenderContents(
     const GURL& url,
     const content::Referrer& referrer,
     Origin origin,
     uint8 experiment_id) {
   DCHECK(CalledOnValidThread());
   return prerender_contents_factory_->CreatePrerenderContents(
-      this, prerender_tracker_, profile_, url, referrer, origin, experiment_id);
+      this, profile_, url, referrer, origin, experiment_id);
 }
 
 void PrerenderManager::SortActivePrerenders() {
   std::sort(active_prerenders_.begin(), active_prerenders_.end(),
             PrerenderData::OrderByExpiryTime());
 }
 
 PrerenderManager::PrerenderData* PrerenderManager::FindPrerenderData(
     const GURL& url,
     const SessionStorageNamespace* session_storage_namespace) {
@@ skipping 160 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