Add field trial to extend prerender expiration to 5 minutes.

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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 397 matching lines @@
 
   // 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;
 
   if (!prerender_contents->load_start_time().is_null()) {
     histograms_->RecordTimeUntilUsed(GetCurrentTimeTicks() -
                                      prerender_contents->load_start_time(),
-                                     config_.max_age);
+                                     GetMaxAge());
   }
 
   histograms_->RecordPerSessionCount(++prerenders_per_session_count_);
   histograms_->RecordUsedPrerender(prerender_contents->origin());
   prerender_contents->set_final_status(FINAL_STATUS_USED);
 
   new_render_view_host->Send(
       new ChromeViewMsg_SetIsPrerendering(new_render_view_host->routing_id(),
                                           false));
 
@@ skipping 155 matching lines @@
   return mode_;
 }
 
 // static
 void PrerenderManager::SetMode(PrerenderManagerMode mode) {
   mode_ = mode;
 }
 
 // static
 bool PrerenderManager::IsPrerenderingPossible() {
-  return GetMode() == PRERENDER_MODE_ENABLED ||
-         GetMode() == PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP ||
-         GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP ||
-         GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
+  return GetMode() != PRERENDER_MODE_DISABLED;
 }
 
 // static
 bool PrerenderManager::ActuallyPrerendering() {
   return IsPrerenderingPossible() && !IsControlGroup();
 }
 
 // static
 bool PrerenderManager::IsControlGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
@@ skipping 109 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())
-    dict_value->SetString("disabled_reason", "(Disabled for testing)");
+    enabled_note += "(Control group: Not actually prerendering) ";
   if (IsNoUseGroup())
-    dict_value->SetString("disabled_reason", "(Not using prerendered pages)");
+    enabled_note += "(No-use group: Not swapping in prerendered pages) ";
+  if (GetMode() == PRERENDER_MODE_EXPERIMENT_5MIN_TTL_GROUP)
+    enabled_note += "(5 min TTL group: Extended prerender eviction to 5 mins) ";
+  dict_value->SetString("enabled_note", enabled_note);
   return dict_value;
 }
 
 void PrerenderManager::ClearData(int clear_flags) {
   DCHECK_GE(clear_flags, 0);
   DCHECK_LT(clear_flags, CLEAR_MAX);
   if (clear_flags & CLEAR_PRERENDER_CONTENTS)
     DestroyAllContents(FINAL_STATUS_CACHE_OR_HISTORY_CLEARED);
   // This has to be second, since destroying prerenders can add to the history.
   if (clear_flags & CLEAR_PRERENDER_HISTORY)
@@ skipping 236 matching lines @@
 }
 
 void PrerenderManager::PostCleanupTask() {
   DCHECK(CalledOnValidThread());
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PrerenderManager::PeriodicCleanup,
                  weak_factory_.GetWeakPtr()));
 }
 
+base::TimeDelta PrerenderManager::GetMaxAge() const {
+  return (GetMode() == PRERENDER_MODE_EXPERIMENT_5MIN_TTL_GROUP ?
+      base::TimeDelta::FromSeconds(300) : config_.max_age);
+}
+
 bool PrerenderManager::IsPrerenderElementFresh(const base::Time start) const {
   DCHECK(CalledOnValidThread());
   base::Time now = GetCurrentTime();
-  return (now - start < config_.max_age);
+  return (now - start < GetMaxAge());
 }
 
 void PrerenderManager::DeleteOldEntries() {
   DCHECK(CalledOnValidThread());
   while (!prerender_list_.empty()) {
     PrerenderContentsData data = prerender_list_.front();
     if (IsPrerenderElementFresh(data.start_time_))
       return;
     data.contents_->Destroy(FINAL_STATUS_TIMED_OUT);
   }
@@ skipping 193 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