Move some prerender configuration settings out of PrerenderManager.

BUG=None
TEST=Existing Tests.


Review URL: http://codereview.chromium.org/7248062

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@91159 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/chrome/browser/prerender/prerender_browsertest.cc b/chrome/browser/prerender/prerender_browsertest.cc
index 1967e53..461af28 100644
--- a/chrome/browser/prerender/prerender_browsertest.cc
+++ b/chrome/browser/prerender/prerender_browsertest.cc
@@ -537,7 +537,7 @@
     // This is needed to exit the event loop once the prerendered page has
     // stopped loading or was cancelled.
     ASSERT_TRUE(prerender_manager());
-    prerender_manager()->rate_limit_enabled_ = false;
+    prerender_manager()->mutable_config().rate_limit_enabled = false;
     ASSERT_TRUE(prerender_contents_factory_ == NULL);
     prerender_contents_factory_ =
         new WaitForLoadPrerenderContentsFactory(total_navigations,
@@ -893,7 +893,7 @@
 // Checks that renderers using excessive memory will be terminated.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
   ASSERT_TRUE(prerender_manager());
-  prerender_manager()->set_max_prerender_memory_mb(30);
+  prerender_manager()->mutable_config().max_bytes = 30 * 1024 * 1024;
   PrerenderTestURL("files/prerender/prerender_excessive_memory.html",
                    FINAL_STATUS_MEMORY_LIMIT_EXCEEDED,
                    1);
diff --git a/chrome/browser/prerender/prerender_config.cc b/chrome/browser/prerender/prerender_config.cc
new file mode 100644
index 0000000..e0a15a59
--- /dev/null
+++ b/chrome/browser/prerender/prerender_config.cc
@@ -0,0 +1,15 @@
+// Copyright (c) 2011 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_config.h"
+
+namespace prerender {
+
+Config::Config() : max_bytes(100 * 1024 * 1024),
+                   max_elements(1),
+                   rate_limit_enabled(true),
+                   max_age(base::TimeDelta::FromSeconds(30)) {
+}
+
+}  // namespace prerender
diff --git a/chrome/browser/prerender/prerender_config.h b/chrome/browser/prerender/prerender_config.h
new file mode 100644
index 0000000..d3ea812
--- /dev/null
+++ b/chrome/browser/prerender/prerender_config.h
@@ -0,0 +1,31 @@
+// Copyright (c) 2011 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.
+
+#ifndef CHROME_BROWSER_PRERENDER_PRERENDER_CONFIG_H_
+#define CHROME_BROWSER_PRERENDER_PRERENDER_CONFIG_H_
+#pragma once
+
+#include "base/time.h"
+
+namespace prerender {
+
+struct Config {
+  Config();
+
+  // Maximum memory use for a prerendered page until it is killed.
+  size_t max_bytes;
+
+  // Number of simultaneous prendered pages allowed.
+  unsigned int max_elements;
+
+  // Is rate limiting enabled?
+  bool rate_limit_enabled;
+
+  // Maximum age for a prerendered page until it is removed.
+  base::TimeDelta max_age;
+};
+
+}  // namespace prerender
+
+#endif  // CHROME_BROWSER_PRERENDER_PRERENDER_CONFIG_H_
diff --git a/chrome/browser/prerender/prerender_contents.cc b/chrome/browser/prerender/prerender_contents.cc
index 23c8149a..19df577 100644
--- a/chrome/browser/prerender/prerender_contents.cc
+++ b/chrome/browser/prerender/prerender_contents.cc
@@ -569,11 +569,9 @@
     return;
 
   size_t private_bytes, shared_bytes;
-  if (metrics->GetMemoryBytes(&private_bytes, &shared_bytes)) {
-    if (private_bytes >
-        prerender_manager_->max_prerender_memory_mb() * 1024 * 1024) {
+  if (metrics->GetMemoryBytes(&private_bytes, &shared_bytes) &&
+      private_bytes > prerender_manager_->config().max_bytes) {
       Destroy(FINAL_STATUS_MEMORY_LIMIT_EXCEEDED);
-    }
   }
 }
 
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index 4ddc3da..e3a93e6 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -41,16 +41,6 @@
 
 namespace {
 
-// Default maximum permitted elements to prerender.
-const unsigned int kDefaultMaxPrerenderElements = 1;
-
-// Default maximum amount of private memory that may be used per
-// PrerenderContents, in MB.
-const unsigned int kDefaultMaxPrerenderMemoryMB = 100;
-
-// Default maximum age a prerendered element may have, in seconds.
-const int kDefaultMaxPrerenderAgeSeconds = 30;
-
 // Time window for which we will record windowed PLT's from the last
 // observed link rel=prefetch tag.
 const int kWindowDurationSeconds = 30;
@@ -217,17 +207,11 @@
   Origin origin_;
 };
 
-
 PrerenderManager::PrerenderManager(Profile* profile,
                                    PrerenderTracker* prerender_tracker)
-    : rate_limit_enabled_(true),
-      enabled_(true),
+    : enabled_(true),
       profile_(profile),
       prerender_tracker_(prerender_tracker),
-      max_prerender_age_(base::TimeDelta::FromSeconds(
-          kDefaultMaxPrerenderAgeSeconds)),
-      max_prerender_memory_mb_(kDefaultMaxPrerenderMemoryMB),
-      max_elements_(kDefaultMaxPrerenderElements),
       prerender_contents_factory_(PrerenderContents::CreateFactory()),
       last_prerender_start_time_(GetCurrentTimeTicks() -
           base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)),
@@ -354,7 +338,7 @@
     last_prerender_start_time_ = GetCurrentTimeTicks();
     data.contents_->StartPrerendering(source_render_view_host);
   }
-  while (prerender_list_.size() > max_elements_) {
+  while (prerender_list_.size() > config_.max_elements) {
     data = prerender_list_.front();
     prerender_list_.pop_front();
     data.contents_->Destroy(FINAL_STATUS_EVICTED);
@@ -614,7 +598,7 @@
 bool PrerenderManager::IsPrerenderElementFresh(const base::Time start) const {
   DCHECK(CalledOnValidThread());
   base::Time now = GetCurrentTime();
-  return (now - start < max_prerender_age_);
+  return (now - start < config_.max_age);
 }
 
 PrerenderContents* PrerenderManager::CreatePrerenderContents(
@@ -686,36 +670,6 @@
   }
 }
 
-base::TimeDelta PrerenderManager::max_prerender_age() const {
-  DCHECK(CalledOnValidThread());
-  return max_prerender_age_;
-}
-
-void PrerenderManager::set_max_prerender_age(base::TimeDelta max_age) {
-  DCHECK(CalledOnValidThread());
-  max_prerender_age_ = max_age;
-}
-
-size_t PrerenderManager::max_prerender_memory_mb() const {
-  DCHECK(CalledOnValidThread());
-  return max_prerender_memory_mb_;
-}
-
-void PrerenderManager::set_max_prerender_memory_mb(size_t max_memory_mb) {
-  DCHECK(CalledOnValidThread());
-  max_prerender_memory_mb_ = max_memory_mb;
-}
-
-unsigned int PrerenderManager::max_elements() const {
-  DCHECK(CalledOnValidThread());
-  return max_elements_;
-}
-
-void PrerenderManager::set_max_elements(unsigned int max_elements) {
-  DCHECK(CalledOnValidThread());
-  max_elements_ = max_elements;
-}
-
 bool PrerenderManager::is_enabled() const {
   DCHECK(CalledOnValidThread());
   return enabled_;
@@ -787,7 +741,7 @@
       GetCurrentTimeTicks() - last_prerender_start_time_;
   UMA_HISTOGRAM_TIMES("Prerender.TimeBetweenPrerenderRequests",
                       elapsed_time);
-  if (!rate_limit_enabled_)
+  if (!config_.rate_limit_enabled)
     return true;
   return elapsed_time >
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
@@ -1030,7 +984,7 @@
       "Prerender.TimeUntilUsed",
       time_until_used,
       base::TimeDelta::FromMilliseconds(10),
-      base::TimeDelta::FromSeconds(kDefaultMaxPrerenderAgeSeconds),
+      config_.max_age,
       50);
 }
 
diff --git a/chrome/browser/prerender/prerender_manager.h b/chrome/browser/prerender/prerender_manager.h
index 189d9cba..941b5c7 100644
--- a/chrome/browser/prerender/prerender_manager.h
+++ b/chrome/browser/prerender/prerender_manager.h
@@ -18,6 +18,7 @@
 #include "base/threading/non_thread_safe.h"
 #include "base/time.h"
 #include "base/timer.h"
+#include "chrome/browser/prerender/prerender_config.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_origin.h"
 #include "googleurl/src/gurl.h"
@@ -127,11 +128,6 @@
       base::TimeDelta perceived_page_load_time,
       TabContents* tab_contents);
 
-  void set_max_prerender_age(base::TimeDelta max_age);
-  size_t max_prerender_memory_mb() const;
-  void set_max_prerender_memory_mb(size_t prerender_memory_mb);
-  void set_max_elements(unsigned int num);
-
   // Returns whether prerendering is currently enabled for this manager.
   // Must be called on the UI thread.
   bool is_enabled() const;
@@ -185,6 +181,9 @@
   // Intended to be used when clearing the cache or history.
   void ClearData(int clear_flags);
 
+  const Config& config() const { return config_; }
+  Config& mutable_config() { return config_; }
+
  protected:
   // Test that needs needs access to internal functions.
   FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, ExpireTest);
@@ -195,8 +194,6 @@
   void SetPrerenderContentsFactory(
       PrerenderContents::Factory* prerender_contents_factory);
 
-  bool rate_limit_enabled_;
-
   PendingContentsData* FindPendingEntry(const GURL& url);
 
   // Extracts a urlencoded URL stored in a url= query parameter from a URL
@@ -205,9 +202,6 @@
   static bool MaybeGetQueryStringBasedAliasURL(const GURL& url,
                                                GURL* alias_url);
 
-  base::TimeDelta max_prerender_age() const;
-  unsigned int max_elements() const;
-
  private:
   // Test that needs needs access to internal functions.
   friend class PrerenderBrowserTest;
@@ -322,21 +316,19 @@
   // navigates to it. This must be called on the UI thread.
   void RecordTimeUntilUsed(base::TimeDelta time_until_used);
 
+  // The configuration.
+  Config config_;
+
   // Specifies whether prerendering is currently enabled for this
   // manager. The value can change dynamically during the lifetime
   // of the PrerenderManager.
   bool enabled_;
 
+  // The profile that owns this PrerenderManager.
   Profile* profile_;
 
   PrerenderTracker* prerender_tracker_;
 
-  base::TimeDelta max_prerender_age_;
-  // Maximum amount of memory, in megabytes, that a single PrerenderContents
-  // can use before it's cancelled.
-  size_t max_prerender_memory_mb_;
-  unsigned int max_elements_;
-
   // List of prerendered elements.
   std::list<PrerenderContentsData> prerender_list_;
 
diff --git a/chrome/browser/prerender/prerender_manager_unittest.cc b/chrome/browser/prerender/prerender_manager_unittest.cc
index e275eb5..7da1493 100644
--- a/chrome/browser/prerender/prerender_manager_unittest.cc
+++ b/chrome/browser/prerender/prerender_manager_unittest.cc
@@ -66,7 +66,7 @@
         time_ticks_(base::TimeTicks::Now()),
         next_prerender_contents_(NULL),
         prerender_tracker_(prerender_tracker) {
-    rate_limit_enabled_ = false;
+    set_rate_limit_enabled(false);
   }
 
   virtual ~TestPrerenderManager() {
@@ -130,7 +130,9 @@
     return (PrerenderManager::FindPendingEntry(url) != NULL);
   }
 
-  void set_rate_limit_enabled(bool enabled) { rate_limit_enabled_ = true; }
+  void set_rate_limit_enabled(bool enabled) {
+    mutable_config().rate_limit_enabled = enabled;
+  }
 
   PrerenderContents* next_prerender_contents() {
     return next_prerender_contents_.get();
@@ -257,8 +259,8 @@
   EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->has_started());
-  prerender_manager()->AdvanceTime(prerender_manager()->max_prerender_age()
-                                  + base::TimeDelta::FromSeconds(1));
+  prerender_manager()->AdvanceTime(prerender_manager()->config().max_age
+                                   + base::TimeDelta::FromSeconds(1));
   ASSERT_EQ(null, prerender_manager()->GetEntry(url));
 }
 
@@ -291,7 +293,7 @@
 // Two element prerender test.  Ensure that the LRU operates correctly if we
 // permit 2 elements to be kept prerendered.
 TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) {
-  prerender_manager()->set_max_elements(2);
+  prerender_manager()->mutable_config().max_elements = 2;
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
diff --git a/chrome/browser/prerender/prerender_tracker_unittest.cc b/chrome/browser/prerender/prerender_tracker_unittest.cc
index a9cef60..17988c7 100644
--- a/chrome/browser/prerender/prerender_tracker_unittest.cc
+++ b/chrome/browser/prerender/prerender_tracker_unittest.cc
@@ -19,7 +19,7 @@
  public:
   explicit TestPrerenderManager(PrerenderTracker* prerender_tracker) :
       PrerenderManager(NULL, prerender_tracker) {
-    rate_limit_enabled_ = false;
+    mutable_config().rate_limit_enabled = false;
   }
 
   virtual void DestroyPrerenderForRenderView(
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 324a074d..e9a9c2e 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -1680,6 +1680,8 @@
         'browser/prefs/session_startup_pref.h',
         'browser/prefs/value_map_pref_store.cc',
         'browser/prefs/value_map_pref_store.h',
+        'browser/prerender/prerender_config.cc',
+        'browser/prerender/prerender_config.h',
         'browser/prerender/prerender_contents.cc',
         'browser/prerender/prerender_contents.h',
         'browser/prerender/prerender_field_trial.cc',