Refactor FaviconDriver::OnFaviconAvailable()

components/favicon/core/favicon_handler_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 "components/favicon/core/favicon_handler.h"
 
 #include<set>
 #include<vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 168 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryRequestHandler);
 };
 
 }  // namespace
 
 class TestFaviconDriver : public FaviconDriver {
  public:
   TestFaviconDriver()
-      : favicon_validity_(false),
-        num_active_favicon_(0),
-        num_favicon_available_(0),
-        update_active_favicon_(false) {}
+      : num_notifications_(0u) {}
 
   ~TestFaviconDriver() override {}
 
   // FaviconDriver implementation.
   void FetchFavicon(const GURL& url) override {
     ADD_FAILURE() << "TestFaviconDriver::FetchFavicon() "
                   << "should never be called in tests.";
   }
 
   gfx::Image GetFavicon() const override {
     ADD_FAILURE() << "TestFaviconDriver::GetFavicon() "
                   << "should never be called in tests.";
     return gfx::Image();
   }
 
+  GURL GetFaviconURL() const override {
+    ADD_FAILURE() << "TestFaviconDriver::GetFaviconURL() "
+                  << "should never be called in tests.";
+    return GURL();
+  }
+
   bool FaviconIsValid() const override {
     ADD_FAILURE() << "TestFaviconDriver::FaviconIsValid() "
                   << "should never be called in tests.";
     return false;
   }
 
   bool HasPendingTasksForTest() override {
     ADD_FAILURE() << "TestFaviconDriver::HasPendingTasksForTest() "
                   << "should never be called in tests.";
     return false;
   }
 
   int StartDownload(const GURL& url, int max_bitmap_size) override {
     ADD_FAILURE() << "TestFaviconDriver::StartDownload() "
                   << "should never be called in tests.";
     return -1;
   }
 
   bool IsOffTheRecord() override { return false; }
 
   bool IsBookmarked(const GURL& url) override { return false; }
 
-  GURL GetActiveURL() override { return url_; }
-
-  bool GetActiveFaviconValidity() { return favicon_validity_; }
-
-  void SetActiveFaviconValidity(bool favicon_validity) override {
-    favicon_validity_ = favicon_validity;
+  GURL GetActiveURL() override {
+    ADD_FAILURE() << "TestFaviconDriver::GetActiveURL() "
+                  << "should never be called in tests.";
+    return GURL();
   }
 
-  GURL GetActiveFaviconURL() override { return favicon_url_; }
-
-  void SetActiveFaviconURL(const GURL& favicon_url) override {
-    favicon_url_ = favicon_url;
-  }
-
-  gfx::Image GetActiveFaviconImage() { return image_; }
-
-  void SetActiveFaviconImage(const gfx::Image& image) override {
+  void OnFaviconUpdated(
+      const GURL& page_url,
+      FaviconDriverObserver::NotificationIconType notification_icon_type,
+      const GURL& icon_url,
+      bool icon_url_changed,
+      const gfx::Image& image) override {
+    ++num_notifications_;
+    icon_url_ = icon_url;
     image_ = image;
   }
 
-  void OnFaviconAvailable(const GURL& page_url,
-                          const GURL& icon_url,
-                          const gfx::Image& image,
-                          bool update_active_favicon) override {
-    ++num_favicon_available_;
-    available_image_ = image;
-    available_icon_url_ = icon_url;
-    update_active_favicon_ = update_active_favicon;
-    if (!update_active_favicon)
-      return;
+  const GURL& icon_url() const { return icon_url_; }
 
-    ++num_active_favicon_;
-    SetActiveFaviconURL(icon_url);
-    SetActiveFaviconValidity(true);
-    SetActiveFaviconImage(image);
-  }
+  const gfx::Image& image() const { return image_; }
 
-  size_t num_active_favicon() const { return num_active_favicon_; }
-  size_t num_favicon_available() const { return num_favicon_available_; }
-  void ResetNumActiveFavicon() { num_active_favicon_ = 0; }
-  void ResetNumFaviconAvailable() { num_favicon_available_ = 0; }
-
-  void SetActiveURL(GURL url) { url_ = url; }
-
-  const gfx::Image& available_favicon() { return available_image_; }
-
-  const GURL& available_icon_url() { return available_icon_url_; }
-
-  bool update_active_favicon() { return update_active_favicon_; }
+  size_t num_notifications() const { return num_notifications_; }
+  void ResetNumNotifications() { num_notifications_ = 0; }
 
  private:
-  GURL favicon_url_;
-  GURL url_;
+  GURL icon_url_;
   gfx::Image image_;
-  bool favicon_validity_;
-
-  // The number of times that NotifyFaviconAvailable() has been called with
-  // |is_active_favicon| is true.
-  size_t num_active_favicon_;
-  // The number of times that NotifyFaviconAvailable() has been called.
-  size_t num_favicon_available_;
-  gfx::Image available_image_;
-  GURL available_icon_url_;
-  bool update_active_favicon_;
+  size_t num_notifications_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFaviconDriver);
 };
 
 // This class is used to catch the FaviconHandler's download and history
 // request, and also provide the methods to access the FaviconHandler
 // internals.
 class TestFaviconHandler : public FaviconHandler {
  public:
   static int GetMaximalIconSize(favicon_base::IconType icon_type) {
     return FaviconHandler::GetMaximalIconSize(icon_type);
   }
 
-  TestFaviconHandler(const GURL& page_url,
-                     TestFaviconDriver* driver,
-                     Type type)
-      : FaviconHandler(nullptr, driver, type),
+  TestFaviconHandler(TestFaviconDriver* driver,
+                     FaviconDriverObserver::NotificationIconType handler_type)
+      : FaviconHandler(nullptr, driver, handler_type),
         download_id_(0) {
-    driver->SetActiveURL(page_url);
     download_handler_.reset(new DownloadHandler(this));
   }
 
   ~TestFaviconHandler() override {}
 
   HistoryRequestHandler* history_handler() {
     return history_handler_.get();
   }
 
   // This method will take the ownership of the given handler.
@@ skipping 139 matching lines @@
   //   any of |candidates|.
   // - The page provides favicons at |candidate_icons|.
   // - The favicons at |candidate_icons| have edge pixel sizes of
   //   |candidate_icon_sizes|.
   void DownloadTillDoneIgnoringHistory(
       TestFaviconDriver* favicon_driver,
       TestFaviconHandler* favicon_handler,
       const GURL& page_url,
       const std::vector<FaviconURL>& candidate_icons,
       const int* candidate_icon_sizes) {
+    size_t old_num_notifications = favicon_driver->num_notifications();
+
     UpdateFaviconURL(
         favicon_driver, favicon_handler, page_url, candidate_icons);
     EXPECT_EQ(candidate_icons.size(), favicon_handler->image_urls().size());
 
     DownloadHandler* download_handler = favicon_handler->download_handler();
     for (size_t i = 0; i < candidate_icons.size(); ++i) {
       favicon_handler->history_handler()->history_results_.clear();
       favicon_handler->history_handler()->InvokeCallback();
       ASSERT_TRUE(download_handler->HasDownload());
       EXPECT_EQ(download_handler->GetImageUrl(),
                 candidate_icons[i].icon_url);
       std::vector<int> sizes;
       sizes.push_back(candidate_icon_sizes[i]);
       download_handler->SetImageSizes(sizes);
       download_handler->InvokeCallback();
 
       download_handler->Reset();
 
-      if (favicon_driver->num_active_favicon())
+      if (favicon_driver->num_notifications() > old_num_notifications)
         return;
     }
   }
 
   void UpdateFaviconURL(TestFaviconDriver* favicon_driver,
                         TestFaviconHandler* favicon_handler,
                         const GURL& page_url,
                         const std::vector<FaviconURL>& candidate_icons) {
-    favicon_driver->ResetNumActiveFavicon();
+    favicon_driver->ResetNumNotifications();
 
     favicon_handler->FetchFavicon(page_url);
     favicon_handler->history_handler()->InvokeCallback();
 
     favicon_handler->OnUpdateFaviconURL(page_url, candidate_icons);
   }
 
   void SetUp() override {
     // The score computed by SelectFaviconFrames() is dependent on the supported
     // scale factors of the platform. It is used for determining the goodness of
@@ skipping 11 matching lines @@
   scoped_ptr<ui::test::ScopedSetSupportedScaleFactors>
       scoped_set_supported_scale_factors_;
   DISALLOW_COPY_AND_ASSIGN(FaviconHandlerTest);
 };
 
 TEST_F(FaviconHandlerTest, GetFaviconFromHistory) {
   const GURL page_url("http://www.google.com");
   const GURL icon_url("http://www.google.com/favicon");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   helper.FetchFavicon(page_url);
   HistoryRequestHandler* history_handler = helper.history_handler();
   // Ensure the data given to history is correct.
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(page_url, history_handler->page_url_);
   EXPECT_EQ(GURL(), history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 
   SetFaviconRawBitmapResult(icon_url, &history_handler->history_results_);
 
   // Send history response.
   history_handler->InvokeCallback();
   // Verify FaviconHandler status
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
+  EXPECT_EQ(1u, driver.num_notifications());
+  EXPECT_EQ(icon_url, driver.icon_url());
 
   // Simulates update favicon url.
   std::vector<FaviconURL> urls;
   urls.push_back(
       FaviconURL(icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
   helper.OnUpdateFaviconURL(page_url, urls);
 
   // Verify FaviconHandler status
   EXPECT_EQ(1u, helper.image_urls().size());
   ASSERT_TRUE(helper.current_candidate());
   ASSERT_EQ(icon_url, helper.current_candidate()->icon_url);
   ASSERT_EQ(favicon_base::FAVICON, helper.current_candidate()->icon_type);
 
   // Favicon shouldn't request to download icon.
   EXPECT_FALSE(helper.download_handler()->HasDownload());
 }
 
 TEST_F(FaviconHandlerTest, DownloadFavicon) {
   const GURL page_url("http://www.google.com");
   const GURL icon_url("http://www.google.com/favicon");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   helper.FetchFavicon(page_url);
   HistoryRequestHandler* history_handler = helper.history_handler();
   // Ensure the data given to history is correct.
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(page_url, history_handler->page_url_);
   EXPECT_EQ(GURL(), history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 
   // Set icon data expired
   SetFaviconRawBitmapResult(icon_url,
                             favicon_base::FAVICON,
                             true /* expired */,
                             &history_handler->history_results_);
   // Send history response.
   history_handler->InvokeCallback();
   // Verify FaviconHandler status
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
+  EXPECT_EQ(1u, driver.num_notifications());
+  EXPECT_EQ(icon_url, driver.icon_url());
 
   // Simulates update favicon url.
   std::vector<FaviconURL> urls;
   urls.push_back(
       FaviconURL(icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
   helper.OnUpdateFaviconURL(page_url, urls);
 
   // Verify FaviconHandler status
   EXPECT_EQ(1u, helper.image_urls().size());
   ASSERT_TRUE(helper.current_candidate());
@@ skipping 15 matching lines @@
 
   // New icon should be saved to history backend and navigation entry.
   history_handler = helper.history_handler();
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(icon_url, history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
   EXPECT_LT(0U, history_handler->bitmap_data_.size());
   EXPECT_EQ(page_url, history_handler->page_url_);
 
   // Verify NavigationEntry.
-  EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
-  EXPECT_EQ(gfx::kFaviconSize, driver.GetActiveFaviconImage().Width());
+  EXPECT_EQ(2u, driver.num_notifications());
+  EXPECT_EQ(icon_url, driver.icon_url());
+  EXPECT_FALSE(driver.image().IsEmpty());
+  EXPECT_EQ(gfx::kFaviconSize, driver.image().Width());
 }
 
 TEST_F(FaviconHandlerTest, UpdateAndDownloadFavicon) {
   const GURL page_url("http://www.google.com");
   const GURL icon_url("http://www.google.com/favicon");
   const GURL new_icon_url("http://www.google.com/new_favicon");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   helper.FetchFavicon(page_url);
   HistoryRequestHandler* history_handler = helper.history_handler();
   // Ensure the data given to history is correct.
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(page_url, history_handler->page_url_);
   EXPECT_EQ(GURL(), history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 
   // Set valid icon data.
   SetFaviconRawBitmapResult(icon_url, &history_handler->history_results_);
 
   // Send history response.
   history_handler->InvokeCallback();
   // Verify FaviconHandler status.
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
+  EXPECT_EQ(1u, driver.num_notifications());
+  EXPECT_EQ(icon_url, driver.icon_url());
 
   // Reset the history_handler to verify whether new icon is requested from
   // history.
   helper.set_history_handler(nullptr);
 
   // Simulates update with the different favicon url.
   std::vector<FaviconURL> urls;
   urls.push_back(FaviconURL(
       new_icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
   helper.OnUpdateFaviconURL(page_url, urls);
@@ skipping 30 matching lines @@
 
   // New icon should be saved to history backend and navigation entry.
   history_handler = helper.history_handler();
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(new_icon_url, history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
   EXPECT_LT(0U, history_handler->bitmap_data_.size());
   EXPECT_EQ(page_url, history_handler->page_url_);
 
   // Verify NavigationEntry.
-  EXPECT_EQ(new_icon_url, driver.GetActiveFaviconURL());
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
-  EXPECT_EQ(gfx::kFaviconSize, driver.GetActiveFaviconImage().Width());
+  EXPECT_EQ(2u, driver.num_notifications());
+  EXPECT_EQ(new_icon_url, driver.icon_url());
+  EXPECT_FALSE(driver.image().IsEmpty());
+  EXPECT_EQ(gfx::kFaviconSize, driver.image().Width());
 }
 
 TEST_F(FaviconHandlerTest, FaviconInHistoryInvalid) {
   const GURL page_url("http://www.google.com");
   const GURL icon_url("http://www.google.com/favicon");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   helper.FetchFavicon(page_url);
   HistoryRequestHandler* history_handler = helper.history_handler();
   // Ensure the data given to history is correct.
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(page_url, history_handler->page_url_);
   EXPECT_EQ(GURL(), history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 
   // Set non empty but invalid data.
   favicon_base::FaviconRawBitmapResult bitmap_result;
   bitmap_result.expired = false;
   // Empty bitmap data is invalid.
   bitmap_result.bitmap_data = new base::RefCountedBytes();
   bitmap_result.pixel_size = gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize);
   bitmap_result.icon_type = favicon_base::FAVICON;
   bitmap_result.icon_url = icon_url;
   history_handler->history_results_.clear();
   history_handler->history_results_.push_back(bitmap_result);
 
   // Send history response.
   history_handler->InvokeCallback();
   // The NavigationEntry should not be set yet as the history data is invalid.
-  EXPECT_FALSE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(GURL(), driver.GetActiveFaviconURL());
+  EXPECT_EQ(0u, driver.num_notifications());
+  EXPECT_EQ(GURL(), driver.icon_url());
 
   // Reset the history_handler to verify whether new icon is requested from
   // history.
   helper.set_history_handler(nullptr);
 
   // Simulates update with matching favicon URL.
   std::vector<FaviconURL> urls;
   urls.push_back(
       FaviconURL(icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
   helper.OnUpdateFaviconURL(page_url, urls);
@@ skipping 12 matching lines @@
 
   // New icon should be saved to history backend and navigation entry.
   history_handler = helper.history_handler();
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(icon_url, history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
   EXPECT_LT(0U, history_handler->bitmap_data_.size());
   EXPECT_EQ(page_url, history_handler->page_url_);
 
   // Verify NavigationEntry.
-  EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
-  EXPECT_EQ(gfx::kFaviconSize, driver.GetActiveFaviconImage().Width());
+  EXPECT_EQ(1u, driver.num_notifications());
+  EXPECT_EQ(icon_url, driver.icon_url());
+  EXPECT_FALSE(driver.image().IsEmpty());
+  EXPECT_EQ(gfx::kFaviconSize, driver.image().Width());
 }
 
 TEST_F(FaviconHandlerTest, UpdateFavicon) {
   const GURL page_url("http://www.google.com");
   const GURL icon_url("http://www.google.com/favicon");
   const GURL new_icon_url("http://www.google.com/new_favicon");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   helper.FetchFavicon(page_url);
   HistoryRequestHandler* history_handler = helper.history_handler();
   // Ensure the data given to history is correct.
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(page_url, history_handler->page_url_);
   EXPECT_EQ(GURL(), history_handler->icon_url_);
   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 
   SetFaviconRawBitmapResult(icon_url, &history_handler->history_results_);
 
   // Send history response.
   history_handler->InvokeCallback();
   // Verify FaviconHandler status.
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
+  EXPECT_EQ(1u, driver.num_notifications());
+  EXPECT_EQ(icon_url, driver.icon_url());
 
   // Reset the history_handler to verify whether new icon is requested from
   // history.
   helper.set_history_handler(nullptr);
 
   // Simulates update with the different favicon url.
   std::vector<FaviconURL> urls;
   urls.push_back(FaviconURL(
       new_icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
   helper.OnUpdateFaviconURL(page_url, urls);
@@ skipping 12 matching lines @@
   EXPECT_EQ(page_url, history_handler->page_url_);
 
   // Simulate find icon.
   SetFaviconRawBitmapResult(new_icon_url, &history_handler->history_results_);
   history_handler->InvokeCallback();
 
   // Shouldn't request download favicon
   EXPECT_FALSE(helper.download_handler()->HasDownload());
 
   // Verify the favicon status.
-  EXPECT_EQ(new_icon_url, driver.GetActiveFaviconURL());
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
+  EXPECT_EQ(2u, driver.num_notifications());
+  EXPECT_EQ(new_icon_url, driver.icon_url());
+  EXPECT_FALSE(driver.image().IsEmpty());
 }
 
 TEST_F(FaviconHandlerTest, Download2ndFaviconURLCandidate) {
   const GURL page_url("http://www.google.com");
   const GURL icon_url("http://www.google.com/favicon");
   const GURL new_icon_url("http://www.google.com/new_favicon");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::LARGEST_TOUCH);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::TOUCH_LARGEST);
   std::set<GURL> fail_downloads;
   fail_downloads.insert(icon_url);
   helper.download_handler()->FailDownloadForIconURLs(fail_downloads);
 
   helper.FetchFavicon(page_url);
   HistoryRequestHandler* history_handler = helper.history_handler();
   // Ensure the data given to history is correct.
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(page_url, history_handler->page_url_);
   EXPECT_EQ(GURL(), history_handler->icon_url_);
   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON | favicon_base::TOUCH_ICON,
             history_handler->icon_type_);
 
   // Icon not found.
   history_handler->history_results_.clear();
   // Send history response.
   history_handler->InvokeCallback();
   // Verify FaviconHandler status.
-  EXPECT_FALSE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(GURL(), driver.GetActiveFaviconURL());
+  EXPECT_EQ(0u, driver.num_notifications());
+  EXPECT_EQ(GURL(), driver.icon_url());
 
   // Reset the history_handler to verify whether new icon is requested from
   // history.
   helper.set_history_handler(nullptr);
 
   // Simulates update with the different favicon url.
   std::vector<FaviconURL> urls;
   urls.push_back(FaviconURL(icon_url,
                             favicon_base::TOUCH_PRECOMPOSED_ICON,
                             std::vector<gfx::Size>()));
@@ skipping 74 matching lines @@
   EXPECT_LT(0U, history_handler->bitmap_data_.size());
   EXPECT_EQ(page_url, history_handler->page_url_);
 }
 
 TEST_F(FaviconHandlerTest, UpdateDuringDownloading) {
   const GURL page_url("http://www.google.com");
   const GURL icon_url("http://www.google.com/favicon");
   const GURL new_icon_url("http://www.google.com/new_favicon");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::LARGEST_TOUCH);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::TOUCH_LARGEST);
 
   helper.FetchFavicon(page_url);
   HistoryRequestHandler* history_handler = helper.history_handler();
   // Ensure the data given to history is correct.
   ASSERT_TRUE(history_handler);
   EXPECT_EQ(page_url, history_handler->page_url_);
   EXPECT_EQ(GURL(), history_handler->icon_url_);
   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON | favicon_base::TOUCH_ICON,
             history_handler->icon_type_);
 
   // Icon not found.
   history_handler->history_results_.clear();
   // Send history response.
   history_handler->InvokeCallback();
   // Verify FaviconHandler status.
-  EXPECT_FALSE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(GURL(), driver.GetActiveFaviconURL());
+  EXPECT_EQ(0u, driver.num_notifications());
+  EXPECT_EQ(GURL(), driver.icon_url());
 
   // Reset the history_handler to verify whether new icon is requested from
   // history.
   helper.set_history_handler(nullptr);
 
   // Simulates update with the different favicon url.
   std::vector<FaviconURL> urls;
   urls.push_back(FaviconURL(icon_url,
                             favicon_base::TOUCH_PRECOMPOSED_ICON,
                             std::vector<gfx::Size>()));
@@ skipping 84 matching lines @@
   const GURL icon_url2("http://www.google.com/favicon2");
   std::vector<FaviconURL> favicon_urls;
   favicon_urls.push_back(FaviconURL(GURL("http://www.google.com/favicon1"),
                                     favicon_base::FAVICON,
                                     std::vector<gfx::Size>()));
   favicon_urls.push_back(FaviconURL(GURL("http://www.google.com/favicon2"),
                                     favicon_base::FAVICON,
                                     std::vector<gfx::Size>()));
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(page_url, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   // Initiate a request for favicon data for |page_url|. History does not know
   // about the page URL or the icon URLs.
   helper.FetchFavicon(page_url);
   helper.history_handler()->InvokeCallback();
   helper.set_history_handler(nullptr);
 
   // Got icon URLs.
   helper.OnUpdateFaviconURL(page_url, favicon_urls);
 
@@ skipping 25 matching lines @@
 }
 
 // Fixes crbug.com/544560
 TEST_F(FaviconHandlerTest,
        OnFaviconAvailableNotificationSentAfterIconURLChange) {
   const GURL kPageURL("http://www.page_which_animates_favicon.com");
   const GURL kIconURL1("http://wwww.page_which_animates_favicon.com/frame1.png");
   const GURL kIconURL2("http://wwww.page_which_animates_favicon.com/frame2.png");
 
   TestFaviconDriver driver;
-  TestFaviconHandler helper(kPageURL, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler helper(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   // Initial state:
   // - The database does not know about |kPageURL|.
   // - The page uses |kIconURL1| and |kIconURL2|.
   // - The database knows about both |kIconURL1| and |kIconURl2|. Both icons
   //   are expired in the database.
   helper.FetchFavicon(kPageURL);
   ASSERT_TRUE(helper.history_handler());
   helper.history_handler()->InvokeCallback();
   {
     std::vector<FaviconURL> icon_urls;
     icon_urls.push_back(
         FaviconURL(kIconURL1, favicon_base::FAVICON, std::vector<gfx::Size>()));
     icon_urls.push_back(
         FaviconURL(kIconURL2, favicon_base::FAVICON, std::vector<gfx::Size>()));
     helper.OnUpdateFaviconURL(kPageURL, icon_urls);
   }
 
   // FaviconHandler should request from history and download |kIconURL1| and
   // |kIconURL2|. |kIconURL1| is the better match. A
-  // FaviconDriver::OnFaviconAvailable() notification should be sent for
+  // FaviconDriver::OnFaviconUpdated() notification should be sent for
   // |kIconURL1|.
-
-  // Clear the favicon validity so that we can use it to detect whether
-  // OnFaviconAvailable() is invoked.
-  driver.SetActiveFaviconValidity(false);
-
+  ASSERT_EQ(0u, driver.num_notifications());
   ASSERT_TRUE(helper.history_handler());
   SetFaviconRawBitmapResult(kIconURL1,
                             favicon_base::FAVICON,
                             true /* expired */,
                             &helper.history_handler()->history_results_);
   helper.history_handler()->InvokeCallback();
   helper.set_history_handler(nullptr);
   ASSERT_TRUE(helper.download_handler()->HasDownload());
   helper.download_handler()->SetImageSizes(std::vector<int>(1u, 15));
   helper.download_handler()->InvokeCallback();
   helper.download_handler()->Reset();
 
   ASSERT_TRUE(helper.history_handler());
   helper.history_handler()->InvokeCallback();
   SetFaviconRawBitmapResult(kIconURL2,
                             favicon_base::FAVICON,
                             true /* expired */,
                             &helper.history_handler()->history_results_);
   helper.history_handler()->InvokeCallback();
   helper.set_history_handler(nullptr);
   ASSERT_TRUE(helper.download_handler()->HasDownload());
   helper.download_handler()->SetImageSizes(std::vector<int>(1u, 10));
   helper.download_handler()->InvokeCallback();
   helper.download_handler()->Reset();
 
-  ASSERT_TRUE(driver.GetActiveFaviconValidity());
-  ASSERT_EQ(kIconURL1, driver.GetActiveFaviconURL());
+  ASSERT_LT(0u, driver.num_notifications());
+  ASSERT_EQ(kIconURL1, driver.icon_url());
 
   // Clear the history handler because SetHistoryFavicons() sets it.
   helper.set_history_handler(nullptr);
 
   // Simulate the page changing it's icon URL to just |kIconURL2| via
   // Javascript.
   helper.OnUpdateFaviconURL(
       kPageURL,
       std::vector<FaviconURL>(1u, FaviconURL(kIconURL2, favicon_base::FAVICON,
                                              std::vector<gfx::Size>())));
 
   // FaviconHandler should request from history and download |kIconURL2|. A
-  // FaviconDriver::OnFaviconAvailable() notification should be sent for
+  // FaviconDriver::OnFaviconUpdated() notification should be sent for
   // |kIconURL2|.
-  driver.SetActiveFaviconValidity(false);
-
+  driver.ResetNumNotifications();
   ASSERT_TRUE(helper.history_handler());
   SetFaviconRawBitmapResult(kIconURL2,
                             favicon_base::FAVICON,
                             true /* expired */,
                             &helper.history_handler()->history_results_);
   helper.history_handler()->InvokeCallback();
   helper.set_history_handler(nullptr);
   ASSERT_TRUE(helper.download_handler()->HasDownload());
   helper.download_handler()->InvokeCallback();
   helper.download_handler()->Reset();
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_EQ(kIconURL2, driver.GetActiveFaviconURL());
+  ASSERT_LT(0u, driver.num_notifications());
+  EXPECT_EQ(kIconURL2, driver.icon_url());
 }
 
 // Test the favicon which is selected when the web page provides several
 // favicons and none of the favicons are cached in history.
 // The goal of this test is to be more of an integration test than
 // SelectFaviconFramesTest.*.
 TEST_F(FaviconHandlerTest, MultipleFavicons) {
   const GURL kPageURL("http://www.google.com");
   const FaviconURL kSourceIconURLs[] = {
       FaviconURL(GURL("http://www.google.com/a"),
@@ skipping 15 matching lines @@
   // Set the supported scale factors to 1x and 2x. This affects the behavior of
   // SelectFaviconFrames().
   std::vector<ui::ScaleFactor> scale_factors;
   scale_factors.push_back(ui::SCALE_FACTOR_100P);
   scale_factors.push_back(ui::SCALE_FACTOR_200P);
   ui::test::ScopedSetSupportedScaleFactors scoped_supported(scale_factors);
 
   // 1) Test that if there are several single resolution favicons to choose from
   // that the largest exact match is chosen.
   TestFaviconDriver driver1;
-  TestFaviconHandler handler1(kPageURL, &driver1, FaviconHandler::FAVICON);
+  TestFaviconHandler handler1(&driver1,
+                              FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   const int kSizes1[] = { 16, 24, 32, 48, 256 };
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes1));
   DownloadTillDoneIgnoringHistory(
       &driver1, &handler1, kPageURL, urls1, kSizes1);
 
   EXPECT_EQ(nullptr, handler1.current_candidate());
-  EXPECT_TRUE(driver1.GetActiveFaviconValidity());
-  EXPECT_FALSE(driver1.GetActiveFaviconImage().IsEmpty());
-  EXPECT_EQ(gfx::kFaviconSize, driver1.GetActiveFaviconImage().Width());
+  EXPECT_EQ(1u, driver1.num_notifications());
+  EXPECT_FALSE(driver1.image().IsEmpty());
+  EXPECT_EQ(gfx::kFaviconSize, driver1.image().Width());
 
   size_t expected_index = 2u;
   EXPECT_EQ(32, kSizes1[expected_index]);
-  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
-            driver1.GetActiveFaviconURL());
+  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url, driver1.icon_url());
 
   // 2) Test that if there are several single resolution favicons to choose
   // from, the exact match is preferred even if it results in upsampling.
   TestFaviconDriver driver2;
-  TestFaviconHandler handler2(kPageURL, &driver2, FaviconHandler::FAVICON);
+  TestFaviconHandler handler2(&driver2,
+                              FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   const int kSizes2[] = { 16, 24, 48, 256 };
   std::vector<FaviconURL> urls2(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes2));
   DownloadTillDoneIgnoringHistory(
       &driver2, &handler2, kPageURL, urls2, kSizes2);
-  EXPECT_TRUE(driver2.GetActiveFaviconValidity());
+  EXPECT_EQ(1u, driver2.num_notifications());
   expected_index = 0u;
   EXPECT_EQ(16, kSizes2[expected_index]);
-  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
-            driver2.GetActiveFaviconURL());
+  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url, driver2.icon_url());
 
   // 3) Test that favicons which need to be upsampled a little or downsampled
   // a little are preferred over huge favicons.
   TestFaviconDriver driver3;
-  TestFaviconHandler handler3(kPageURL, &driver3, FaviconHandler::FAVICON);
+  TestFaviconHandler handler3(&driver3,
+                              FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   const int kSizes3[] = { 256, 48 };
   std::vector<FaviconURL> urls3(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes3));
   DownloadTillDoneIgnoringHistory(
       &driver3, &handler3, kPageURL, urls3, kSizes3);
-  EXPECT_TRUE(driver3.GetActiveFaviconValidity());
+  EXPECT_EQ(1u, driver3.num_notifications());
   expected_index = 1u;
   EXPECT_EQ(48, kSizes3[expected_index]);
-  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
-            driver3.GetActiveFaviconURL());
+  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url, driver3.icon_url());
 
   TestFaviconDriver driver4;
-  TestFaviconHandler handler4(kPageURL, &driver4, FaviconHandler::FAVICON);
+  TestFaviconHandler handler4(&driver4,
+                              FaviconDriverObserver::NON_TOUCH_16_DIP);
 
   const int kSizes4[] = { 17, 256 };
   std::vector<FaviconURL> urls4(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes4));
   DownloadTillDoneIgnoringHistory(
       &driver4, &handler4, kPageURL, urls4, kSizes4);
-  EXPECT_TRUE(driver4.GetActiveFaviconValidity());
+  EXPECT_EQ(1u, driver4.num_notifications());
   expected_index = 0u;
   EXPECT_EQ(17, kSizes4[expected_index]);
-  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
-            driver4.GetActiveFaviconURL());
+  EXPECT_EQ(kSourceIconURLs[expected_index].icon_url, driver4.icon_url());
 }
 
 // Test that the best favicon is selected when:
 // - The page provides several favicons.
 // - Downloading one of the page's icon URLs previously returned a 404.
 // - None of the favicons are cached in the Favicons database.
 TEST_F(FaviconHandlerTest, MultipleFavicons404) {
   const GURL kPageURL("http://www.google.com");
   const GURL k404IconURL("http://www.google.com/404.png");
   const FaviconURL k404FaviconURL(
       k404IconURL, favicon_base::FAVICON, std::vector<gfx::Size>());
   const FaviconURL kFaviconURLs[] = {
       FaviconURL(GURL("http://www.google.com/a"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>()),
       k404FaviconURL,
       FaviconURL(GURL("http://www.google.com/c"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>()),
   };
 
   TestFaviconDriver driver;
-  TestFaviconHandler handler(kPageURL, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler handler(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
   DownloadHandler* download_handler = handler.download_handler();
 
   std::set<GURL> k404URLs;
   k404URLs.insert(k404IconURL);
   download_handler->FailDownloadForIconURLs(k404URLs);
 
   // Make the initial download for |k404IconURL| fail.
   const int kSizes1[] = { 0 };
   std::vector<FaviconURL> urls1(1u, k404FaviconURL);
   DownloadTillDoneIgnoringHistory(
       &driver, &handler, kPageURL, urls1, kSizes1);
   EXPECT_TRUE(download_handler->DidFailDownloadForIconURL(k404IconURL));
 
   // Do a fetch now that the initial download for |k404IconURL| has failed. The
   // behavior is different because OnDidDownloadFavicon() is invoked
   // synchronously from DownloadFavicon().
   const int kSizes2[] = { 10, 0, 16 };
   std::vector<FaviconURL> urls2(kFaviconURLs,
                                 kFaviconURLs + arraysize(kFaviconURLs));
   DownloadTillDoneIgnoringHistory(
       &driver, &handler, kPageURL, urls2, kSizes2);
 
   EXPECT_EQ(nullptr, handler.current_candidate());
-  EXPECT_TRUE(driver.GetActiveFaviconValidity());
-  EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
+  EXPECT_EQ(1u, driver.num_notifications());
+  EXPECT_FALSE(driver.image().IsEmpty());
   int expected_index = 2u;
   EXPECT_EQ(16, kSizes2[expected_index]);
-  EXPECT_EQ(kFaviconURLs[expected_index].icon_url,
-            driver.GetActiveFaviconURL());
+  EXPECT_EQ(kFaviconURLs[expected_index].icon_url, driver.icon_url());
 }
 
 // Test that no favicon is selected when:
 // - The page provides several favicons.
 // - Downloading the page's icons has previously returned a 404.
 // - None of the favicons are cached in the Favicons database.
 TEST_F(FaviconHandlerTest, MultipleFaviconsAll404) {
   const GURL kPageURL("http://www.google.com");
   const GURL k404IconURL1("http://www.google.com/4041.png");
   const GURL k404IconURL2("http://www.google.com/4042.png");
   const FaviconURL kFaviconURLs[] = {
       FaviconURL(k404IconURL1,
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>()),
       FaviconURL(k404IconURL2,
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>()),
   };
 
   TestFaviconDriver driver;
-  TestFaviconHandler handler(kPageURL, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler handler(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
   DownloadHandler* download_handler = handler.download_handler();
 
   std::set<GURL> k404URLs;
   k404URLs.insert(k404IconURL1);
   k404URLs.insert(k404IconURL2);
   download_handler->FailDownloadForIconURLs(k404URLs);
 
   // Make the initial downloads for |kFaviconURLs| fail.
   for (const FaviconURL& favicon_url : kFaviconURLs) {
     const int kSizes[] = { 0 };
     std::vector<FaviconURL> urls(1u, favicon_url);
     DownloadTillDoneIgnoringHistory(&driver, &handler, kPageURL, urls, kSizes);
   }
   EXPECT_TRUE(download_handler->DidFailDownloadForIconURL(k404IconURL1));
   EXPECT_TRUE(download_handler->DidFailDownloadForIconURL(k404IconURL2));
 
   // Do a fetch now that the initial downloads for |kFaviconURLs| have failed.
   // The behavior is different because OnDidDownloadFavicon() is invoked
   // synchronously from DownloadFavicon().
   const int kSizes[] = { 0, 0 };
   std::vector<FaviconURL> urls(kFaviconURLs,
                                kFaviconURLs + arraysize(kFaviconURLs));
   DownloadTillDoneIgnoringHistory(&driver, &handler, kPageURL, urls, kSizes);
 
   EXPECT_EQ(nullptr, handler.current_candidate());
-  EXPECT_FALSE(driver.GetActiveFaviconValidity());
-  EXPECT_TRUE(driver.GetActiveFaviconImage().IsEmpty());
+  EXPECT_EQ(0u, driver.num_notifications());
+  EXPECT_TRUE(driver.image().IsEmpty());
 }
 
 // Test that no favicon is selected when the page's only icon uses an invalid
 // URL syntax.
 TEST_F(FaviconHandlerTest, FaviconInvalidURL) {
   const GURL kPageURL("http://www.google.com");
   const GURL kInvalidFormatURL("invalid");
   ASSERT_TRUE(kInvalidFormatURL.is_empty());
 
   FaviconURL favicon_url(kInvalidFormatURL, favicon_base::FAVICON,
                          std::vector<gfx::Size>());
 
   TestFaviconDriver driver;
-  TestFaviconHandler handler(kPageURL, &driver, FaviconHandler::FAVICON);
+  TestFaviconHandler handler(&driver, FaviconDriverObserver::NON_TOUCH_16_DIP);
   UpdateFaviconURL(&driver, &handler, kPageURL,
                    std::vector<FaviconURL>(1u, favicon_url));
   EXPECT_EQ(0u, handler.image_urls().size());
 }
 
 TEST_F(FaviconHandlerTest, TestSortFavicon) {
   const GURL kPageURL("http://www.google.com");
   std::vector<gfx::Size> icon1;
   icon1.push_back(gfx::Size(1024, 1024));
   icon1.push_back(gfx::Size(512, 512));
@@ skipping 11 matching lines @@
       FaviconURL(GURL("http://www.google.com/b"), favicon_base::FAVICON, icon2),
       FaviconURL(GURL("http://www.google.com/c"), favicon_base::FAVICON, icon3),
       FaviconURL(GURL("http://www.google.com/d"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>()),
       FaviconURL(GURL("http://www.google.com/e"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>())};
 
   TestFaviconDriver driver1;
-  TestFaviconHandler handler1(kPageURL, &driver1,
-                              FaviconHandler::LARGEST_FAVICON);
+  TestFaviconHandler handler1(&driver1,
+                              FaviconDriverObserver::NON_TOUCH_LARGEST);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
 
   struct ExpectedResult {
     // The favicon's index in kSourceIconURLs.
     size_t favicon_index;
     // Width of largest bitmap.
     int width;
   } results[] = {
@@ skipping 41 matching lines @@
       FaviconURL(
           GURL("http://www.google.com/c"), favicon_base::FAVICON, icon3),
       FaviconURL(GURL("http://www.google.com/d"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>()),
       FaviconURL(GURL("http://www.google.com/e"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>())};
 
   TestFaviconDriver driver1;
-  TestFaviconHandler handler1(kPageURL, &driver1,
-                              FaviconHandler::LARGEST_FAVICON);
+  TestFaviconHandler handler1(&driver1,
+                              FaviconDriverObserver::NON_TOUCH_LARGEST);
 
   std::set<GURL> fail_icon_urls;
   for (size_t i = 0; i < arraysize(kSourceIconURLs); ++i) {
     fail_icon_urls.insert(kSourceIconURLs[i].icon_url);
   }
   handler1.download_handler()->FailDownloadForIconURLs(fail_icon_urls);
 
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
@@ skipping 46 matching lines @@
   two_icons.push_back(gfx::Size(14, 14));
   two_icons.push_back(gfx::Size(16, 16));
 
   const FaviconURL kSourceIconURLs[] = {
       FaviconURL(
           GURL("http://www.google.com/b"), favicon_base::FAVICON, one_icon),
       FaviconURL(
           GURL("http://www.google.com/c"), favicon_base::FAVICON, two_icons)};
 
   TestFaviconDriver driver1;
-  TestFaviconHandler handler1(kPageURL, &driver1,
-                              FaviconHandler::LARGEST_FAVICON);
+  TestFaviconHandler handler1(&driver1,
+                              FaviconDriverObserver::NON_TOUCH_LARGEST);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
 
   ASSERT_EQ(2u, handler1.image_urls().size());
 
   // Index of largest favicon in kSourceIconURLs.
   size_t i = 1;
   // The largest bitmap's index in Favicon .
   int b = 1;
@@ skipping 21 matching lines @@
     sizes.push_back(j->width());
 
   handler1.download_handler()->SetImageSizes(sizes);
   handler1.download_handler()->InvokeCallback();
 
   // Verify the largest bitmap has been saved into history.
   EXPECT_EQ(kSourceIconURLs[i].icon_url, handler1.history_handler()->icon_url_);
   EXPECT_EQ(kSourceIconURLs[i].icon_sizes[b],
             handler1.history_handler()->size_);
   // Verify NotifyFaviconAvailable().
-  EXPECT_FALSE(driver1.update_active_favicon());
-  EXPECT_EQ(kSourceIconURLs[i].icon_url, driver1.available_icon_url());
-  EXPECT_EQ(kSourceIconURLs[i].icon_sizes[b],
-            driver1.available_favicon().Size());
+  EXPECT_EQ(1u, driver1.num_notifications());
+  EXPECT_EQ(kSourceIconURLs[i].icon_url, driver1.icon_url());
+  EXPECT_EQ(kSourceIconURLs[i].icon_sizes[b], driver1.image().Size());
 }
 
 TEST_F(FaviconHandlerTest, TestFaviconWasScaledAfterDownload) {
   const GURL kPageURL("http://www.google.com");
   const int kMaximalSize =
     TestFaviconHandler::GetMaximalIconSize(favicon_base::FAVICON);
 
   std::vector<gfx::Size> icon1;
   icon1.push_back(gfx::Size(kMaximalSize + 1, kMaximalSize + 1));
 
   std::vector<gfx::Size> icon2;
   icon2.push_back(gfx::Size(kMaximalSize + 2, kMaximalSize + 2));
 
   const FaviconURL kSourceIconURLs[] = {
       FaviconURL(
           GURL("http://www.google.com/b"), favicon_base::FAVICON, icon1),
       FaviconURL(
           GURL("http://www.google.com/c"), favicon_base::FAVICON, icon2)};
 
   TestFaviconDriver driver1;
-  TestFaviconHandler handler1(kPageURL, &driver1,
-                              FaviconHandler::LARGEST_FAVICON);
+  TestFaviconHandler handler1(&driver1,
+                              FaviconDriverObserver::NON_TOUCH_LARGEST);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
 
   ASSERT_EQ(2u, handler1.image_urls().size());
 
   // Index of largest favicon in kSourceIconURLs.
   size_t i = 1;
   // The largest bitmap's index in Favicon .
   int b = 0;
@@ skipping 39 matching lines @@
   const int actual_size2 = 12;
 
   const FaviconURL kSourceIconURLs[] = {
       FaviconURL(GURL("http://www.google.com/b"), favicon_base::FAVICON, icon1),
       FaviconURL(GURL("http://www.google.com/c"), favicon_base::FAVICON, icon2),
       FaviconURL(GURL("http://www.google.com/d"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>())};
 
   TestFaviconDriver driver1;
-  TestFaviconHandler handler1(kPageURL, &driver1,
-                              FaviconHandler::LARGEST_FAVICON);
+  TestFaviconHandler handler1(&driver1,
+                              FaviconDriverObserver::NON_TOUCH_LARGEST);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
   ASSERT_EQ(3u, handler1.image_urls().size());
 
   // Simulate no favicon from history.
   handler1.history_handler()->history_results_.clear();
   handler1.history_handler()->InvokeCallback();
 
   // Verify the first icon was request to download
@@ skipping 29 matching lines @@
   handler1.download_handler()->SetImageSizes(sizes);
   handler1.download_handler()->InvokeCallback();
   handler1.download_handler()->Reset();
 
   // Verify icon2 has been saved into history.
   EXPECT_EQ(kSourceIconURLs[1].icon_url, handler1.history_handler()->icon_url_);
   EXPECT_EQ(gfx::Size(actual_size2, actual_size2),
             handler1.history_handler()->size_);
 }
 
-class FaviconHandlerActiveFaviconValidityParamTest :
-      public FaviconHandlerTest,
-      public ::testing::WithParamInterface<bool> {
- public:
-  FaviconHandlerActiveFaviconValidityParamTest() {}
-
-  ~FaviconHandlerActiveFaviconValidityParamTest() override {}
-
-  bool GetActiveFaviconValiditySetting() {
-    return GetParam();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(FaviconHandlerActiveFaviconValidityParamTest);
-};
-
-TEST_P(FaviconHandlerActiveFaviconValidityParamTest,
-       TestDownloadLargestIconDoesNotImpactActiveFaviconValidity) {
-  const GURL page_url("http://www.google.com");
-
-  std::vector<gfx::Size> one_icon;
-  one_icon.push_back(gfx::Size(15, 15));
-
-  const GURL old_favicon_url("http://www.google.com/old");
-  const GURL new_favicon_url("http://www.google.com/b");
-  const FaviconURL source_icon_urls[] = {
-      FaviconURL(new_favicon_url, favicon_base::FAVICON, one_icon)};
-  TestFaviconDriver driver1;
-  TestFaviconHandler handler1(page_url, &driver1,
-                              FaviconHandler::LARGEST_FAVICON);
-  std::vector<FaviconURL> urls1(source_icon_urls,
-                                source_icon_urls + arraysize(source_icon_urls));
-  UpdateFaviconURL(&driver1, &handler1, page_url, urls1);
-
-  HistoryRequestHandler* history_handler = handler1.history_handler();
-
-  // Simulate the active favicon is updated, this shouldn't happen in real
-  // use case, but we want to verify the behavior below is not impacted by
-  // accident.
-  driver1.SetActiveFaviconValidity(GetActiveFaviconValiditySetting());
-  // Simulate the get favicon from history, but favicon URL didn't match.
-  SetFaviconRawBitmapResult(old_favicon_url,
-                            &history_handler->history_results_);
-  history_handler->InvokeCallback();
-  // Since we downloaded largest icon, and don't want to set active favicon
-  // NotifyFaviconAvaliable() should be called with is_active_favicon as false.
-  EXPECT_EQ(old_favicon_url, driver1.available_icon_url());
-  EXPECT_FALSE(driver1.update_active_favicon());
-  EXPECT_EQ(1u, driver1.num_favicon_available());
-
-  // We are trying to get favicon from history again.
-  history_handler = handler1.history_handler();
-  EXPECT_EQ(new_favicon_url, history_handler->icon_url_);
-  // Simulate the get expired favicon from history.
-  history_handler->history_results_.clear();
-  SetFaviconRawBitmapResult(new_favicon_url, favicon_base::FAVICON, true,
-                            &history_handler->history_results_);
-  history_handler->InvokeCallback();
-  // Since we downloaded largest icon, and don't want to set active favicon
-  // NotifyFaviconAvaliable() should be called with is_active_favicon as false.
-  EXPECT_EQ(new_favicon_url, driver1.available_icon_url());
-  EXPECT_FALSE(driver1.update_active_favicon());
-  EXPECT_EQ(2u, driver1.num_favicon_available());
-
-  // We are trying to download favicon.
-  DownloadHandler* download_handler = handler1.download_handler();
-  EXPECT_TRUE(download_handler->HasDownload());
-  EXPECT_EQ(new_favicon_url, download_handler->GetImageUrl());
-  // Simulate the download succeed.
-  download_handler->InvokeCallback();
-  // Since we downloaded largest icon, and don't want to set active favicon
-  // NotifyFaviconAvaliable() should be called with is_active_favicon as false.
-  EXPECT_EQ(new_favicon_url, driver1.available_icon_url());
-  EXPECT_FALSE(driver1.update_active_favicon());
-  EXPECT_EQ(3u, driver1.num_favicon_available());
-}
-
-INSTANTIATE_TEST_CASE_P(FaviconHandlerTestActiveFaviconValidityTrueOrFalse,
-                        FaviconHandlerActiveFaviconValidityParamTest,
-                        ::testing::Bool());
-
 }  // namespace
 }  // namespace favicon