Topsites become keyedService based.

chrome/browser/history/top_sites_impl_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/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/history_db_task.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/history_unittest_base.h"
-#include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/history/top_sites_cache.h"
-#include "chrome/browser/history/top_sites_impl.h"
+#include "chrome/browser/history/top_sites_provider.h"
+#include "chrome/browser/history/top_sites_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/history/core/browser/history_types.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 class TestTopSitesObserver : public history::TopSitesObserver {
  public:
-  explicit TestTopSitesObserver(Profile* profile, history::TopSites* top_sites);
+  explicit TestTopSitesObserver(Profile* profile,
+                                history::TopSitesProvider* top_sites);
   virtual ~TestTopSitesObserver();
   // TopSitesObserver:
-  void TopSitesLoaded(history::TopSites* top_sites) override;
-  void TopSitesChanged(history::TopSites* top_sites) override;
+  void TopSitesLoaded(history::TopSitesProvider* top_sites) override;
+  void TopSitesChanged(history::TopSitesProvider* top_sites) override;
 
  private:
   Profile* profile_;
-  history::TopSites* top_sites_;
+  history::TopSitesProvider* top_sites_;
 };
 
 TestTopSitesObserver::~TestTopSitesObserver() {
   top_sites_->RemoveObserver(this);
 }
 
 TestTopSitesObserver::TestTopSitesObserver(Profile* profile,
-                                           history::TopSites* top_sites)
+                                           history::TopSitesProvider* top_sites)
     : profile_(profile), top_sites_(top_sites) {
   DCHECK(top_sites_);
   top_sites_->AddObserver(this);
 }
 
-void TestTopSitesObserver::TopSitesLoaded(history::TopSites* top_sites) {
+void TestTopSitesObserver::TopSitesLoaded(
+    history::TopSitesProvider* top_sites) {
   content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_TOP_SITES_LOADED,
-      content::Source<Profile>(profile_),
-      content::Details<history::TopSites>(top_sites));
+      chrome::NOTIFICATION_TOP_SITES_LOADED, content::Source<Profile>(profile_),
+      content::Details<history::TopSitesProvider>(top_sites));
 }
 
-void TestTopSitesObserver::TopSitesChanged(history::TopSites* top_sites) {
+void TestTopSitesObserver::TopSitesChanged(
+    history::TopSitesProvider* top_sites) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOP_SITES_CHANGED,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }
 
 namespace history {
 
 namespace {
 
@@ skipping 19 matching lines @@
 // TopSites is queried before it finishes loading.
 class TopSitesQuerier {
  public:
   TopSitesQuerier()
       : number_of_callbacks_(0),
         waiting_(false),
         weak_ptr_factory_(this) {}
 
   // Queries top sites. If |wait| is true a nested message loop is run until the
   // callback is notified.
-  void QueryTopSites(TopSitesImpl* top_sites, bool wait) {
+  void QueryTopSites(TopSitesService* top_sites, bool wait) {
     QueryAllTopSites(top_sites, wait, false);
   }
 
   // Queries top sites, including potentially forced URLs if
   // |include_forced_urls| is true.
-  void QueryAllTopSites(TopSitesImpl* top_sites,
+  void QueryAllTopSites(TopSitesService* top_sites,
                         bool wait,
                         bool include_forced_urls) {
     int start_number_of_callbacks = number_of_callbacks_;
     top_sites->GetMostVisitedURLs(
         base::Bind(&TopSitesQuerier::OnTopSitesAvailable,
                    weak_ptr_factory_.GetWeakPtr()),
         include_forced_urls);
     if (wait && start_number_of_callbacks == number_of_callbacks_) {
       waiting_ = true;
       base::MessageLoop::current()->Run();
@@ skipping 109 matching lines @@
 
   // Waits for top sites to finish processing a task. This is useful if you need
   // to wait until top sites finishes processing a task.
   void WaitForTopSites() {
     top_sites()->backend_->DoEmptyRequest(
         base::Bind(&TopSitesImplTest::QuitCallback, base::Unretained(this)),
         &top_sites_tracker_);
     base::MessageLoop::current()->Run();
   }
 
-  TopSitesImpl* top_sites() {
-    return static_cast<TopSitesImpl*>(profile_->GetTopSites());
+  TopSitesService* top_sites() {
+    return static_cast<TopSitesService*>(profile_->GetTopSites());
   }
   TestingProfile* profile() {return profile_.get();}
   HistoryService* history_service() {
     return HistoryServiceFactory::GetForProfile(profile_.get(),
                                                 Profile::EXPLICIT_ACCESS);
   }
 
   MostVisitedURLList GetPrepopulatePages() {
     return top_sites()->GetPrepopulatePages();
   }
@@ skipping 56 matching lines @@
 
   // Delets a url.
   void DeleteURL(const GURL& url) {
     history_service()->DeleteURL(url);
   }
 
   // Returns true if the thumbnail equals the specified bytes.
   bool ThumbnailEqualsBytes(const gfx::Image& image,
                             base::RefCountedMemory* bytes) {
     scoped_refptr<base::RefCountedBytes> encoded_image;
-    TopSitesImpl::EncodeBitmap(image, &encoded_image);
+    TopSitesService::EncodeBitmap(image, &encoded_image);
     return ThumbnailsAreEqual(encoded_image.get(), bytes);
   }
 
   // Recreates top sites. This forces top sites to reread from the db.
   void RecreateTopSitesAndBlock() {
     // Recreate TopSites and wait for it to load.
     CreateTopSitesAndObserver();
     // As history already loaded we have to fake this call.
     profile()->BlockUntilTopSitesLoaded();
   }
@@ skipping 140 matching lines @@
   AppendMostVisitedURL(&old_list, gets_deleted_1);  // 1  (deleted)
   AppendMostVisitedURL(&old_list, gets_moved_1);    // 2  (moved to 3)
 
   std::vector<MostVisitedURL> new_list;
   AppendMostVisitedURL(&new_list, stays_the_same);  // 0  (unchanged)
   AppendMostVisitedURL(&new_list, gets_added_1);    // 1  (added)
   AppendMostVisitedURL(&new_list, gets_added_2);    // 2  (added)
   AppendMostVisitedURL(&new_list, gets_moved_1);    // 3  (moved from 2)
 
   history::TopSitesDelta delta;
-  history::TopSitesImpl::DiffMostVisited(old_list, new_list, &delta);
+  history::TopSitesService::DiffMostVisited(old_list, new_list, &delta);
 
   ASSERT_EQ(2u, delta.added.size());
   EXPECT_TRUE(gets_added_1 == delta.added[0].url.url);
   EXPECT_EQ(1, delta.added[0].rank);
   EXPECT_TRUE(gets_added_2 == delta.added[1].url.url);
   EXPECT_EQ(2, delta.added[1].rank);
 
   ASSERT_EQ(1u, delta.deleted.size());
   EXPECT_TRUE(gets_deleted_1 == delta.deleted[0].url);
 
@@ skipping 34 matching lines @@
   AppendForcedMostVisitedURL(&new_list, stays_the_same_2, 3000);
   AppendForcedMostVisitedURL(&new_list, new_last_forced_time, 4000);
   AppendForcedMostVisitedURL(&new_list, gets_added_1, 5000);
   AppendForcedMostVisitedURL(&new_list, move_to_forced, 6000);
   AppendMostVisitedURL(&new_list, move_to_nonforced);
   AppendMostVisitedURL(&new_list, stays_the_same_3);
   AppendMostVisitedURL(&new_list, gets_added_2);
   AppendMostVisitedURL(&new_list, gets_moved_1);
 
   history::TopSitesDelta delta;
-  history::TopSitesImpl::DiffMostVisited(old_list, new_list, &delta);
+  history::TopSitesService::DiffMostVisited(old_list, new_list, &delta);
 
   ASSERT_EQ(2u, delta.added.size());
   EXPECT_TRUE(gets_added_1 == delta.added[0].url.url);
   EXPECT_EQ(-1, delta.added[0].rank);
   EXPECT_TRUE(gets_added_2 == delta.added[1].url.url);
   EXPECT_EQ(2, delta.added[1].rank);
 
   ASSERT_EQ(2u, delta.deleted.size());
   EXPECT_TRUE(gets_deleted_1 == delta.deleted[0].url);
   EXPECT_TRUE(gets_deleted_2 == delta.deleted[1].url);
@@ skipping 1139 matching lines @@
   ASSERT_EQ(orig_thumbnail.getSize(), thumbnail.getSize());
   orig_thumbnail.lockPixels();
   thumbnail.lockPixels();
   EXPECT_EQ(0, memcmp(orig_thumbnail.getPixels(), thumbnail.getPixels(),
                       orig_thumbnail.getSize()));
   thumbnail.unlockPixels();
   orig_thumbnail.unlockPixels();
 }
 
 }  // namespace history