Delete obsolete prerender experiment code

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 164 matching lines @@
       last_recorded_profile_network_bytes_(0),
       clock_(new base::DefaultClock()),
       tick_clock_(new base::DefaultTickClock()),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   last_prerender_start_time_ =
       GetCurrentTimeTicks() -
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 
-  // Certain experiments override our default config_ values.
-  switch (PrerenderManager::GetMode()) {
-    case PrerenderManager::PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP:
-      config_.max_link_concurrency = 4;
-      config_.max_link_concurrency_per_launcher = 2;
-      break;
-    case PrerenderManager::PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP:
-      config_.time_to_live = base::TimeDelta::FromMinutes(15);
-      break;
-    default:
-      break;
-  }
-
   notification_registrar_.Add(
       this, chrome::NOTIFICATION_PROFILE_DESTROYED,
       content::Source<Profile>(profile_));
 
   MediaCaptureDevicesDispatcher::GetInstance()->AddObserver(this);
 }
 
 PrerenderManager::~PrerenderManager() {
   MediaCaptureDevicesDispatcher::GetInstance()->RemoveObserver(this);
 
@@ skipping 232 matching lines @@
   // 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_data->contents()->IsCrossSiteNavigationPending()) {
     histograms_->RecordFinalStatus(prerender_data->contents()->origin(),
                                    FINAL_STATUS_CROSS_SITE_NAVIGATION_PENDING);
     prerender_data->contents()->Destroy(
         FINAL_STATUS_CROSS_SITE_NAVIGATION_PENDING);
     return nullptr;
   }
 
-  // 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) {
-    target_tab_helper->WouldHavePrerenderedNextLoad(
-        prerender_data->contents()->origin());
-    prerender_data->contents()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
-    return nullptr;
-  }
-
   // At this point, we've determined that we will use the prerender.
   content::RenderProcessHost* process_host =
       prerender_data->contents()->GetRenderViewHost()->GetProcess();
   process_host->RemoveObserver(this);
   prerender_process_hosts_.erase(process_host);
   if (!prerender_data->contents()->load_start_time().is_null()) {
     histograms_->RecordTimeUntilUsed(
         prerender_data->contents()->origin(),
         GetCurrentTimeTicks() - prerender_data->contents()->load_start_time());
   }
@@ skipping 155 matching lines @@
 void PrerenderManager::SetMode(PrerenderManagerMode mode) {
   mode_ = mode;
 }
 
 // static
 bool PrerenderManager::IsPrerenderingPossible() {
   return GetMode() != PRERENDER_MODE_DISABLED;
 }
 
 // static
-bool PrerenderManager::ActuallyPrerendering() {
-  return IsPrerenderingPossible() && !IsControlGroup();
-}
-
-// static
-bool PrerenderManager::IsControlGroup() {
-  return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
-}
-
-// static
-bool PrerenderManager::IsNoUseGroup() {
-  return GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
-}
-
-// static
 bool PrerenderManager::IsNoStatePrefetch() {
   return GetMode() == PRERENDER_MODE_NOSTATE_PREFETCH;
 }
 
 bool PrerenderManager::IsWebContentsPrerendering(
     const WebContents* web_contents,
     Origin* origin) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrerenderContents* prerender_contents = GetPrerenderContents(web_contents);
   if (!prerender_contents)
@@ skipping 130 matching lines @@
       GetPredictionStatus() == NetworkPredictionStatus::ENABLED);
   std::string disabled_note;
   if (GetPredictionStatus() == NetworkPredictionStatus::DISABLED_ALWAYS)
     disabled_note = "Disabled by user setting";
   if (GetPredictionStatus() == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK)
     disabled_note = "Disabled on cellular connection by default";
   dict_value->SetString("disabled_note", disabled_note);
   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())
-    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;
 }
 
 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.
@@ skipping 104 matching lines @@
        origin == ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN) &&
       IsGoogleSearchResultURL(referrer.url)) {
     origin = ORIGIN_GWS_PRERENDER;
   }
 
   if (IsPrerenderSilenceExperiment(origin))
     return nullptr;
 
   GURL url = url_arg;
   GURL alias_url;
-  if (IsControlGroup() && 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 (profile_->GetPrefs()->GetBoolean(prefs::kBlockThirdPartyCookies) &&
       origin != ORIGIN_OFFLINE) {
     RecordFinalStatusWithoutCreatingPrerenderContents(
         url, origin, FINAL_STATUS_BLOCK_THIRD_PARTY_COOKIES);
     return nullptr;
@@ skipping 73 matching lines @@
   SortActivePrerenders();
 
   last_prerender_start_time_ = GetCurrentTimeTicks();
 
   gfx::Rect contents_bounds =
       bounds.IsEmpty() ? config_.default_tab_bounds : bounds;
 
   prerender_contents_ptr->StartPrerendering(contents_bounds,
                                             session_storage_namespace);
 
-  DCHECK(IsControlGroup() ||
-         prerender_contents_ptr->prerendering_has_started());
-
-  if (GetMode() == PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP)
-    histograms_->RecordConcurrency(active_prerenders_.size());
+  DCHECK(prerender_contents_ptr->prerendering_has_started());
 
   StartSchedulingPeriodicCleanups();
   return prerender_handle;
 }
 
 void PrerenderManager::StartSchedulingPeriodicCleanups() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (repeating_timer_.IsRunning())
     return;
   repeating_timer_.Start(FROM_HERE,
@@ skipping 241 matching lines @@
   PrerenderContents* prerender_contents = GetPrerenderContents(tab);
   if (!prerender_contents)
     return;
 
   prerender_contents->Destroy(FINAL_STATUS_CREATING_AUDIO_STREAM);
 }
 
 void PrerenderManager::RecordNetworkBytes(Origin origin,
                                           bool used,
                                           int64_t prerender_bytes) {
-  if (!ActuallyPrerendering())
+  if (!IsPrerenderingPossible())
     return;
   int64_t recent_profile_bytes =
       profile_network_bytes_ - last_recorded_profile_network_bytes_;
   last_recorded_profile_network_bytes_ = profile_network_bytes_;
   DCHECK_GE(recent_profile_bytes, 0);
   histograms_->RecordNetworkBytes(
       origin, used, prerender_bytes, recent_profile_bytes);
 }
 
 bool PrerenderManager::IsPrerenderSilenceExperiment(Origin origin) const {
@@ skipping 57 matching lines @@
   if (origin == ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR &&
       prediction_status == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK) {
     return NetworkPredictionStatus::ENABLED;
   }
   return prediction_status;
 }
 
 void PrerenderManager::AddProfileNetworkBytesIfEnabled(int64_t bytes) {
   DCHECK_GE(bytes, 0);
   if (GetPredictionStatus() == NetworkPredictionStatus::ENABLED &&
-      ActuallyPrerendering())
+      IsPrerenderingPossible())
     profile_network_bytes_ += bytes;
 }
 
 void PrerenderManager::AddPrerenderProcessHost(
     content::RenderProcessHost* process_host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(prerender_process_hosts_.find(process_host) ==
          prerender_process_hosts_.end());
   prerender_process_hosts_.insert(process_host);
   process_host->AddObserver(this);
@@ skipping 19 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