Add Observer in FaviconTabHelper

chrome/browser/favicon/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 "chrome/browser/favicon/favicon_handler.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/favicon/chrome_favicon_client.h"
 #include "chrome/browser/favicon/chrome_favicon_client_factory.h"
 #include "chrome/browser/favicon/favicon_service.h"
@@ skipping 171 matching lines @@
   FaviconService* GetFaviconService() override {
     // Just give none NULL value, so overridden methods can be hit.
     return (FaviconService*)(1);
   }
 
   bool IsBookmarked(const GURL& url) override { return false; }
 };
 
 class TestFaviconDriver : public FaviconDriver {
  public:
-  TestFaviconDriver() : favicon_validity_(false) {}
+  TestFaviconDriver()
+      : favicon_validity_(false),
+        num_favicon_available_(0),
+        update_active_favicon_(false) {}
 
   virtual ~TestFaviconDriver() {
   }
 
   bool IsOffTheRecord() override { return false; }
 
   const gfx::Image GetActiveFaviconImage() override { return image_; }
 
   const GURL GetActiveFaviconURL() override { return favicon_url_; }
 
   bool GetActiveFaviconValidity() override { return favicon_validity_; }
 
   const GURL GetActiveURL() override { return url_; }
 
-  void SetActiveFaviconImage(gfx::Image image) override { image_ = image; }
+  void SetActiveFaviconImage(gfx::Image image) { image_ = image; }
 
-  void SetActiveFaviconURL(GURL favicon_url) override {
-    favicon_url_ = favicon_url;
-  }
+  void SetActiveFaviconURL(GURL favicon_url) { favicon_url_ = favicon_url; }
 
-  void SetActiveFaviconValidity(bool favicon_validity) override {
+  void SetActiveFaviconValidity(bool favicon_validity) {
     favicon_validity_ = favicon_validity;
   }
 
   int StartDownload(const GURL& url, int max_bitmap_size) override {
     ADD_FAILURE() << "TestFaviconDriver::StartDownload() "
                   << "should never be called in tests.";
     return -1;
   }
 
-  void NotifyFaviconUpdated(bool icon_url_changed) override {
-    ADD_FAILURE() << "TestFaviconDriver::NotifyFaviconUpdated() "
-                  << "should never be called in tests.";
+  void OnFaviconAvailable(const gfx::Image& image,
+                          const GURL& icon_url,
+                          bool update_active_favicon) override {
+    available_image_ = image;
+    available_icon_url_ = icon_url;
+    update_active_favicon_ = update_active_favicon;
+    if (!update_active_favicon)
+      return;
+
+    ++num_favicon_available_;
+    SetActiveFaviconURL(icon_url);
+    SetActiveFaviconValidity(true);
+    SetActiveFaviconImage(image);
   }
 
+  size_t num_favicon_available() const { return num_favicon_available_; }
+
+  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_; }
+
  private:
   GURL favicon_url_;
   GURL url_;
   gfx::Image image_;
   bool favicon_validity_;
+
+  // 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_;
+
   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,
                      FaviconClient* client,
                      TestFaviconDriver* driver,
                      Type type,
                      bool download_largest_icon)
       : FaviconHandler(client, driver, type, download_largest_icon),
-        download_id_(0),
-        num_favicon_updates_(0) {
+        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.
   void set_history_handler(HistoryRequestHandler* handler) {
     history_handler_.reset(handler);
   }
 
   DownloadHandler* download_handler() {
     return download_handler_.get();
   }
 
-  size_t num_favicon_update_notifications() const {
-    return num_favicon_updates_;
-  }
-
-  void ResetNumFaviconUpdateNotifications() {
-    num_favicon_updates_ = 0;
-  }
-
   // Methods to access favicon internals.
   const std::vector<FaviconURL>& urls() {
     return image_urls_;
   }
 
   FaviconURL* current_candidate() {
     return FaviconHandler::current_candidate();
   }
 
   const FaviconCandidate& best_favicon_candidate() {
@@ skipping 44 matching lines @@
                           const gfx::Image& image) override {
     scoped_refptr<base::RefCountedMemory> bytes = image.As1xPNGBytes();
     std::vector<unsigned char> bitmap_data(bytes->front(),
                                            bytes->front() + bytes->size());
     history_handler_.reset(new HistoryRequestHandler(
         page_url, icon_url, icon_type, bitmap_data, image.Size()));
   }
 
   bool ShouldSaveFavicon(const GURL& url) override { return true; }
 
-  void NotifyFaviconUpdated(bool icon_url_changed) override {
-    ++num_favicon_updates_;
-  }
-
   GURL page_url_;
 
  private:
 
   // The unique id of a download request. It will be returned to a
   // FaviconHandler.
   int download_id_;
 
   scoped_ptr<DownloadHandler> download_handler_;
   scoped_ptr<HistoryRequestHandler> history_handler_;
 
-  // The number of times that NotifyFaviconUpdated() has been called.
-  size_t num_favicon_updates_;
-
   DISALLOW_COPY_AND_ASSIGN(TestFaviconHandler);
 };
 
 namespace {
 
 void HistoryRequestHandler::InvokeCallback() {
   if (!callback_.is_null()) {
     callback_.Run(history_results_);
   }
 }
@@ skipping 30 matching lines @@
   virtual ~FaviconHandlerTest() {
   }
 
   // Simulates requesting a favicon for |page_url| given:
   // - We have not previously cached anything in history for |page_url| or for
   //   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) {
-    UpdateFaviconURL(favicon_handler, page_url, candidate_icons);
+    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();
 
-      if (favicon_handler->num_favicon_update_notifications())
+      if (favicon_driver->num_favicon_available())
         return;
     }
   }
 
-  void UpdateFaviconURL(
-      TestFaviconHandler* favicon_handler,
-      const GURL& page_url,
-      const std::vector<FaviconURL>& candidate_icons) {
-    favicon_handler->ResetNumFaviconUpdateNotifications();
+  void UpdateFaviconURL(TestFaviconDriver* favicon_driver,
+                        TestFaviconHandler* favicon_handler,
+                        const GURL& page_url,
+                        const std::vector<FaviconURL>& candidate_icons) {
+    favicon_driver->ResetNumFaviconAvailable();
 
     favicon_handler->FetchFavicon(page_url);
     favicon_handler->history_handler()->InvokeCallback();
 
     favicon_handler->OnUpdateFaviconURL(candidate_icons);
   }
 
   virtual void SetUp() {
     // The score computed by SelectFaviconFrames() is dependent on the supported
     // scale factors of the platform. It is used for determining the goodness of
@@ skipping 611 matching lines @@
   // 1) Test that if there are several single resolution favicons to choose from
   // that the largest exact match is chosen.
   TestFaviconDriver driver1;
   TestFaviconClient client;
   TestFaviconHandler handler1(
       kPageURL, &client, &driver1, FaviconHandler::FAVICON, false);
 
   const int kSizes1[] = { 16, 24, 32, 48, 256 };
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes1));
-  DownloadTillDoneIgnoringHistory(&handler1, kPageURL, urls1, kSizes1);
+  DownloadTillDoneIgnoringHistory(
+      &driver1, &handler1, kPageURL, urls1, kSizes1);
 
   EXPECT_EQ(0u, handler1.image_urls().size());
   EXPECT_TRUE(driver1.GetActiveFaviconValidity());
   EXPECT_FALSE(driver1.GetActiveFaviconImage().IsEmpty());
   EXPECT_EQ(gfx::kFaviconSize, driver1.GetActiveFaviconImage().Width());
 
   size_t expected_index = 2u;
   EXPECT_EQ(32, kSizes1[expected_index]);
   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
             driver1.GetActiveFaviconURL());
 
   // 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, &client, &driver2, FaviconHandler::FAVICON, false);
 
   const int kSizes2[] = { 16, 24, 48, 256 };
   std::vector<FaviconURL> urls2(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes2));
-  DownloadTillDoneIgnoringHistory(&handler2, kPageURL, urls2, kSizes2);
+  DownloadTillDoneIgnoringHistory(
+      &driver2, &handler2, kPageURL, urls2, kSizes2);
   EXPECT_TRUE(driver2.GetActiveFaviconValidity());
   expected_index = 0u;
   EXPECT_EQ(16, kSizes2[expected_index]);
   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
             driver2.GetActiveFaviconURL());
 
   // 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, &client, &driver3, FaviconHandler::FAVICON, false);
 
   const int kSizes3[] = { 256, 48 };
   std::vector<FaviconURL> urls3(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes3));
-  DownloadTillDoneIgnoringHistory(&handler3, kPageURL, urls3, kSizes3);
+  DownloadTillDoneIgnoringHistory(
+      &driver3, &handler3, kPageURL, urls3, kSizes3);
   EXPECT_TRUE(driver3.GetActiveFaviconValidity());
   expected_index = 1u;
   EXPECT_EQ(48, kSizes3[expected_index]);
   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
             driver3.GetActiveFaviconURL());
 
   TestFaviconDriver driver4;
   TestFaviconHandler handler4(
       kPageURL, &client, &driver4, FaviconHandler::FAVICON, false);
 
   const int kSizes4[] = { 17, 256 };
   std::vector<FaviconURL> urls4(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSizes4));
-  DownloadTillDoneIgnoringHistory(&handler4, kPageURL, urls4, kSizes4);
+  DownloadTillDoneIgnoringHistory(
+      &driver4, &handler4, kPageURL, urls4, kSizes4);
   EXPECT_TRUE(driver4.GetActiveFaviconValidity());
   expected_index = 0u;
   EXPECT_EQ(17, kSizes4[expected_index]);
   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
             driver4.GetActiveFaviconURL());
 }
 
 #endif
 
 TEST_F(FaviconHandlerTest, TestSortFavicon) {
@@ skipping 20 matching lines @@
       FaviconURL(GURL("http://www.google.com/e"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>())};
 
   TestFaviconClient client;
   TestFaviconDriver driver1;
   TestFaviconHandler handler1(
       kPageURL, &client, &driver1, FaviconHandler::FAVICON, true);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
-  UpdateFaviconURL(&handler1, kPageURL, urls1);
+  UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
 
   struct ExpectedResult {
     // The favicon's index in kSourceIconURLs.
     size_t favicon_index;
     // Width of largest bitmap.
     int width;
   } results[] = {
     // First is icon1, though its size larger than maximal.
     {0, 1024},
     // Second is icon2
@@ skipping 43 matching lines @@
       FaviconURL(GURL("http://www.google.com/e"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>())};
 
   TestFaviconClient client;
   TestFaviconDriver driver1;
   TestFaviconHandler handler1(
       kPageURL, &client, &driver1, FaviconHandler::FAVICON, true);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
-  UpdateFaviconURL(&handler1, kPageURL, urls1);
+  UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
 
   // Simulate the download failed, to check whether the icons were requested
   // to download according their size.
   struct ExpectedResult {
     // The size of image_urls_.
     size_t image_urls_size;
     // The favicon's index in kSourceIconURLs.
     size_t favicon_index;
     // Width of largest bitmap.
     int width;
@@ skipping 45 matching lines @@
           GURL("http://www.google.com/b"), favicon_base::FAVICON, one_icon),
       FaviconURL(
           GURL("http://www.google.com/c"), favicon_base::FAVICON, two_icons)};
 
   TestFaviconClient client;
   TestFaviconDriver driver1;
   TestFaviconHandler handler1(
       kPageURL, &client, &driver1, FaviconHandler::FAVICON, true);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
-  UpdateFaviconURL(&handler1, kPageURL, urls1);
+  UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
 
   ASSERT_EQ(2u, handler1.urls().size());
 
   // Index of largest favicon in kSourceIconURLs.
   size_t i = 1;
   // The largest bitmap's index in Favicon .
   int b = 1;
 
   // Verify the icon_bitmaps_ was initialized correctly.
   EXPECT_EQ(kSourceIconURLs[i].icon_url,
@@ skipping 17 matching lines @@
        j != kSourceIconURLs[i].icon_sizes.end(); ++j)
     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());
 }
 
 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)};
 
   TestFaviconClient client;
   TestFaviconDriver driver1;
   TestFaviconHandler handler1(
       kPageURL, &client, &driver1, FaviconHandler::FAVICON, true);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
-  UpdateFaviconURL(&handler1, kPageURL, urls1);
+  UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
 
   ASSERT_EQ(2u, handler1.urls().size());
 
   // Index of largest favicon in kSourceIconURLs.
   size_t i = 1;
   // The largest bitmap's index in Favicon .
   int b = 0;
 
   // Verify the icon_bitmaps_ was initialized correctly.
   EXPECT_EQ(kSourceIconURLs[i].icon_url,
@@ skipping 41 matching lines @@
       FaviconURL(GURL("http://www.google.com/d"),
                  favicon_base::FAVICON,
                  std::vector<gfx::Size>())};
 
   TestFaviconClient client;
   TestFaviconDriver driver1;
   TestFaviconHandler handler1(
       kPageURL, &client, &driver1, FaviconHandler::FAVICON, true);
   std::vector<FaviconURL> urls1(kSourceIconURLs,
                                 kSourceIconURLs + arraysize(kSourceIconURLs));
-  UpdateFaviconURL(&handler1, kPageURL, urls1);
+  UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
   ASSERT_EQ(3u, handler1.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
   ASSERT_TRUE(handler1.download_handler()->HasDownload());
   EXPECT_EQ(kSourceIconURLs[0].icon_url,
             handler1.download_handler()->GetImageUrl());
@@ skipping 110 matching lines @@
   download_id = favicon_tab_helper->StartDownload(missing_icon_url, 0);
   EXPECT_NE(0, download_id);
   // Report download success with HTTP 200 status.
   favicon_tab_helper->DidDownloadFavicon(download_id, 200, missing_icon_url,
       empty_icons, empty_icon_sizes);
   // Icon is not marked as UnableToDownload as HTTP status is not 404.
   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
 }
 
 }  // namespace.