Renaming poorly named classes and adding missing unit tests.

chrome/browser/prerender/prerender_unittest.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 "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_link_manager.h"
@@ skipping 10 matching lines @@
 
 using content::BrowserThread;
 using content::Referrer;
 
 namespace prerender {
 
 namespace {
 
 class DummyPrerenderContents : public PrerenderContents {
  public:
-  DummyPrerenderContents(PrerenderManager* prerender_manager,
-                         PrerenderTracker* prerender_tracker,
-                         const GURL& url,
-                         Origin origin,
-                         FinalStatus expected_final_status)
-      : PrerenderContents(prerender_manager, prerender_tracker,
+  DummyPrerenderContents(
+      PrerenderManager* prerender_manager,
+      PrerenderRenderViewTracker* prerender_render_view_tracker,
+      const GURL& url, Origin origin, FinalStatus expected_final_status)
+      : PrerenderContents(prerender_manager, prerender_render_view_tracker,
                           NULL, url, Referrer(), origin,
                           PrerenderManager::kNoExperiment),
         expected_final_status_(expected_final_status) {
   }
 
   virtual ~DummyPrerenderContents() {
     EXPECT_EQ(expected_final_status_, final_status());
   }
 
   virtual void StartPrerendering(
@@ skipping 19 matching lines @@
   bool prerendering_has_been_cancelled() const {
     return PrerenderContents::prerendering_has_been_cancelled();
   }
 
  private:
   FinalStatus expected_final_status_;
 };
 
 class TestPrerenderManager : public PrerenderManager {
  public:
-  explicit TestPrerenderManager(PrerenderTracker* prerender_tracker)
-      : PrerenderManager(&profile_, prerender_tracker),
+  explicit TestPrerenderManager(
+      PrerenderRenderViewTracker* prerender_render_view_tracker)
+      : PrerenderManager(&profile_, prerender_render_view_tracker),
         time_(base::Time::Now()),
         time_ticks_(base::TimeTicks::Now()),
         next_prerender_contents_(NULL),
-        prerender_tracker_(prerender_tracker) {
+        prerender_render_view_tracker_(prerender_render_view_tracker) {
     set_rate_limit_enabled(false);
   }
 
   virtual ~TestPrerenderManager() {
     if (next_prerender_contents()) {
       next_prerender_contents_.release()->Destroy(
           FINAL_STATUS_MANAGER_SHUTDOWN);
     }
     // Set the final status for all PrerenderContents with an expected final
     // status of FINAL_STATUS_USED.  These values are normally set when the
@@ skipping 12 matching lines @@
   }
 
   void AdvanceTimeTicks(base::TimeDelta delta) {
     time_ticks_ += delta;
   }
 
   DummyPrerenderContents* CreateNextPrerenderContents(
       const GURL& url,
       FinalStatus expected_final_status) {
     DummyPrerenderContents* prerender_contents =
-        new DummyPrerenderContents(this, prerender_tracker_, url,
+        new DummyPrerenderContents(this, prerender_render_view_tracker_, url,
                                    ORIGIN_LINK_REL_PRERENDER,
                                    expected_final_status);
     SetNextPrerenderContents(prerender_contents);
     return prerender_contents;
   }
 
   DummyPrerenderContents* CreateNextPrerenderContents(
       const GURL& url,
       Origin origin,
       FinalStatus expected_final_status) {
     DummyPrerenderContents* prerender_contents =
-        new DummyPrerenderContents(this, prerender_tracker_, url,
+        new DummyPrerenderContents(this, prerender_render_view_tracker_, url,
                                    origin, expected_final_status);
     SetNextPrerenderContents(prerender_contents);
     return prerender_contents;
   }
 
   DummyPrerenderContents* CreateNextPrerenderContents(
       const GURL& url,
       const std::vector<GURL>& alias_urls,
       FinalStatus expected_final_status) {
     DummyPrerenderContents* prerender_contents =
-        new DummyPrerenderContents(this, prerender_tracker_, url,
+        new DummyPrerenderContents(this, prerender_render_view_tracker_, url,
                                    ORIGIN_LINK_REL_PRERENDER,
                                    expected_final_status);
     for (std::vector<GURL>::const_iterator it = alias_urls.begin();
          it != alias_urls.end();
          ++it) {
       EXPECT_TRUE(prerender_contents->AddAliasURL(*it));
     }
     SetNextPrerenderContents(prerender_contents);
     return prerender_contents;
   }
@@ skipping 33 matching lines @@
     return next_prerender_contents_.release();
   }
 
   base::Time time_;
   base::TimeTicks time_ticks_;
   scoped_ptr<PrerenderContents> next_prerender_contents_;
   // PrerenderContents with an |expected_final_status| of FINAL_STATUS_USED,
   // tracked so they will be automatically deleted.
   ScopedVector<PrerenderContents> used_prerender_contents_;
 
-  PrerenderTracker* prerender_tracker_;
+  PrerenderRenderViewTracker* prerender_render_view_tracker_;
 
   TestingProfile profile_;
 };
 
 class RestorePrerenderMode {
  public:
   RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
   }
 
   ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
  private:
   PrerenderManager::PrerenderManagerMode prev_mode_;
 };
 
 }  // namespace
 
 class PrerenderTest : public testing::Test {
  public:
   static const int kDefaultChildId = -1;
   static const int kDefaultRenderViewRouteId = -1;
 
-  PrerenderTest() : ui_thread_(BrowserThread::UI, &message_loop_),
-                    prerender_manager_(
-                        new TestPrerenderManager(prerender_tracker())),
-                    prerender_link_manager_(
-                        new PrerenderLinkManager(prerender_manager_.get())),
-                    last_prerender_id_(0) {
+  PrerenderTest()
+      : ui_thread_(BrowserThread::UI, &message_loop_),
+        prerender_manager_(
+            new TestPrerenderManager(prerender_render_view_tracker())),
+        prerender_link_manager_(
+            new PrerenderLinkManager(prerender_manager_.get())),
+        last_prerender_id_(0) {
     // Enable omnibox prerendering.
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kPrerenderFromOmnibox,
         switches::kPrerenderFromOmniboxSwitchValueEnabled);
   }
 
   TestPrerenderManager* prerender_manager() {
     return prerender_manager_.get();
   }
 
@@ skipping 15 matching lines @@
 
   // Shorthand to add a simple preload with a reasonable source.
   bool AddSimplePrerender(const GURL& url) {
     return prerender_link_manager()->OnAddPrerender(
         kDefaultChildId, GetNextPrerenderID(),
         url, content::Referrer(),
         gfx::Size(), kDefaultRenderViewRouteId);
   }
 
  private:
-  PrerenderTracker* prerender_tracker() {
-    return g_browser_process->prerender_tracker();
+  PrerenderRenderViewTracker* prerender_render_view_tracker() {
+    return g_browser_process->prerender_render_view_tracker();
   }
 
   // Needed to pass PrerenderManager's DCHECKs.
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   scoped_ptr<TestPrerenderManager> prerender_manager_;
   scoped_ptr<PrerenderLinkManager> prerender_link_manager_;
   int last_prerender_id_;
 };
 
@@ skipping 645 matching lines @@
   DummyPrerenderContents* second_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(second_prerender_contents->prerendering_has_started());
   ASSERT_EQ(second_prerender_contents, prerender_manager()->GetEntry(url));
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 }
 
 }  // namespace prerender