chrome/browser/favicon/favicon_handler_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/favicon/core/favicon_handler.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "chrome/browser/favicon/chrome_favicon_client_factory.h"
   9 #include "chrome/browser/favicon/favicon_service_factory.h"
  10 #include "chrome/browser/favicon/favicon_tab_helper.h"
  11 #include "chrome/browser/history/history_service_factory.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
  14 #include "components/favicon/core/favicon_service.h"
  15 #include "third_party/skia/include/core/SkBitmap.h"
  16 #include "ui/gfx/codec/png_codec.h"
  17 #include "ui/gfx/favicon_size.h"
  18 #include "ui/gfx/image/image.h"
  19
  20 class TestFaviconHandler;
  21
  22 using favicon::FaviconURL;
  23
  24 namespace {
  25
  26 // Fill the given bmp with valid png data.
  27 void FillDataToBitmap(int w, int h, SkBitmap* bmp) {
  28   bmp->allocN32Pixels(w, h);
  29
  30   unsigned char* src_data =
  31       reinterpret_cast<unsigned char*>(bmp->getAddr32(0, 0));
  32   for (int i = 0; i < w * h; i++) {
  33     src_data[i * 4 + 0] = static_cast<unsigned char>(i % 255);
  34     src_data[i * 4 + 1] = static_cast<unsigned char>(i % 255);
  35     src_data[i * 4 + 2] = static_cast<unsigned char>(i % 255);
  36     src_data[i * 4 + 3] = static_cast<unsigned char>(i % 255);
  37   }
  38 }
  39
  40 // Fill the given data buffer with valid png data.
  41 void FillBitmap(int w, int h, std::vector<unsigned char>* output) {
  42   SkBitmap bitmap;
  43   FillDataToBitmap(w, h, &bitmap);
  44   gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, output);
  45 }
  46
  47 void SetFaviconRawBitmapResult(
  48     const GURL& icon_url,
  49     favicon_base::IconType icon_type,
  50     bool expired,
  51     std::vector<favicon_base::FaviconRawBitmapResult>* favicon_bitmap_results) {
  52   scoped_refptr<base::RefCountedBytes> data(new base::RefCountedBytes());
  53   FillBitmap(gfx::kFaviconSize, gfx::kFaviconSize, &data->data());
  54   favicon_base::FaviconRawBitmapResult bitmap_result;
  55   bitmap_result.expired = expired;
  56   bitmap_result.bitmap_data = data;
  57   // Use a pixel size other than (0,0) as (0,0) has a special meaning.
  58   bitmap_result.pixel_size = gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize);
  59   bitmap_result.icon_type = icon_type;
  60   bitmap_result.icon_url = icon_url;
  61
  62   favicon_bitmap_results->push_back(bitmap_result);
  63 }
  64
  65 void SetFaviconRawBitmapResult(
  66     const GURL& icon_url,
  67     std::vector<favicon_base::FaviconRawBitmapResult>* favicon_bitmap_results) {
  68   SetFaviconRawBitmapResult(icon_url,
  69                             favicon_base::FAVICON,
  70                             false /* expired */,
  71                             favicon_bitmap_results);
  72 }
  73
  74 // This class is used to save the download request for verifying with test case.
  75 // It also will be used to invoke the onDidDownload callback.
  76 class DownloadHandler {
  77  public:
  78   explicit DownloadHandler(TestFaviconHandler* favicon_helper)
  79       : favicon_helper_(favicon_helper),
  80         failed_(false) {
  81   }
  82
  83   ~DownloadHandler() {}
  84
  85   void Reset() {
  86     download_.reset();
  87     failed_ = false;
  88   }
  89
  90   void AddDownload(
  91       int download_id,
  92       const GURL& image_url,
  93       const std::vector<int>& image_sizes,
  94       int max_image_size) {
  95     download_.reset(new Download(
  96         download_id, image_url, image_sizes, max_image_size, false));
  97   }
  98
  99   void InvokeCallback();
 100
 101   void set_failed(bool failed) { failed_ = failed; }
 102
 103   bool HasDownload() const { return download_.get(); }
 104   const GURL& GetImageUrl() const { return download_->image_url; }
 105   void SetImageSizes(const std::vector<int>& sizes) {
 106     download_->image_sizes = sizes; }
 107
 108  private:
 109   struct Download {
 110     Download(int id,
 111              GURL url,
 112              const std::vector<int>& sizes,
 113              int max_size,
 114              bool failed)
 115         : download_id(id),
 116           image_url(url),
 117           image_sizes(sizes),
 118           max_image_size(max_size) {}
 119     ~Download() {}
 120     int download_id;
 121     GURL image_url;
 122     std::vector<int> image_sizes;
 123     int max_image_size;
 124   };
 125
 126   TestFaviconHandler* favicon_helper_;
 127   scoped_ptr<Download> download_;
 128   bool failed_;
 129
 130   DISALLOW_COPY_AND_ASSIGN(DownloadHandler);
 131 };
 132
 133 // This class is used to save the history request for verifying with test case.
 134 // It also will be used to simulate the history response.
 135 class HistoryRequestHandler {
 136  public:
 137   HistoryRequestHandler(const GURL& page_url,
 138                         const GURL& icon_url,
 139                         int icon_type,
 140                         const favicon_base::FaviconResultsCallback& callback)
 141       : page_url_(page_url),
 142         icon_url_(icon_url),
 143         icon_type_(icon_type),
 144         callback_(callback) {
 145   }
 146
 147   HistoryRequestHandler(const GURL& page_url,
 148                         const GURL& icon_url,
 149                         int icon_type,
 150                         const std::vector<unsigned char>& bitmap_data,
 151                         const gfx::Size& size)
 152       : page_url_(page_url),
 153         icon_url_(icon_url),
 154         icon_type_(icon_type),
 155         bitmap_data_(bitmap_data),
 156         size_(size) {
 157   }
 158
 159   ~HistoryRequestHandler() {}
 160   void InvokeCallback();
 161
 162   const GURL page_url_;
 163   const GURL icon_url_;
 164   const int icon_type_;
 165   const std::vector<unsigned char> bitmap_data_;
 166   const gfx::Size size_;
 167   std::vector<favicon_base::FaviconRawBitmapResult> history_results_;
 168   favicon_base::FaviconResultsCallback callback_;
 169
 170  private:
 171   DISALLOW_COPY_AND_ASSIGN(HistoryRequestHandler);
 172 };
 173
 174 }  // namespace
 175
 176 class TestFaviconDriver : public favicon::FaviconDriver {
 177  public:
 178   TestFaviconDriver()
 179       : favicon_validity_(false),
 180         num_active_favicon_(0),
 181         num_favicon_available_(0),
 182         update_active_favicon_(false) {}
 183
 184   ~TestFaviconDriver() override {}
 185
 186   bool IsOffTheRecord() override { return false; }
 187
 188   bool IsBookmarked(const GURL& url) override { return false; }
 189
 190   const gfx::Image GetActiveFaviconImage() override { return image_; }
 191
 192   const GURL GetActiveFaviconURL() override { return favicon_url_; }
 193
 194   bool GetActiveFaviconValidity() override { return favicon_validity_; }
 195
 196   const GURL GetActiveURL() override { return url_; }
 197
 198   void SetActiveFaviconImage(gfx::Image image) { image_ = image; }
 199
 200   void SetActiveFaviconURL(GURL favicon_url) { favicon_url_ = favicon_url; }
 201
 202   void SetActiveFaviconValidity(bool favicon_validity) {
 203     favicon_validity_ = favicon_validity;
 204   }
 205
 206   int StartDownload(const GURL& url, int max_bitmap_size) override {
 207     ADD_FAILURE() << "TestFaviconDriver::StartDownload() "
 208                   << "should never be called in tests.";
 209     return -1;
 210   }
 211
 212   void OnFaviconAvailable(const gfx::Image& image,
 213                           const GURL& icon_url,
 214                           bool update_active_favicon) override {
 215     ++num_favicon_available_;
 216     available_image_ = image;
 217     available_icon_url_ = icon_url;
 218     update_active_favicon_ = update_active_favicon;
 219     if (!update_active_favicon)
 220       return;
 221
 222     ++num_active_favicon_;
 223     SetActiveFaviconURL(icon_url);
 224     SetActiveFaviconValidity(true);
 225     SetActiveFaviconImage(image);
 226   }
 227
 228   size_t num_active_favicon() const { return num_active_favicon_; }
 229   size_t num_favicon_available() const { return num_favicon_available_; }
 230   void ResetNumActiveFavicon() { num_active_favicon_ = 0; }
 231   void ResetNumFaviconAvailable() { num_favicon_available_ = 0; }
 232
 233   void SetActiveURL(GURL url) { url_ = url; }
 234
 235   const gfx::Image available_favicon() { return available_image_; }
 236
 237   const GURL available_icon_url() { return available_icon_url_; }
 238
 239   bool update_active_favicon() { return update_active_favicon_; }
 240
 241  private:
 242   GURL favicon_url_;
 243   GURL url_;
 244   gfx::Image image_;
 245   bool favicon_validity_;
 246
 247   // The number of times that NotifyFaviconAvailable() has been called with
 248   // |is_active_favicon| is true.
 249   size_t num_active_favicon_;
 250   // The number of times that NotifyFaviconAvailable() has been called.
 251   size_t num_favicon_available_;
 252   gfx::Image available_image_;
 253   GURL available_icon_url_;
 254   bool update_active_favicon_;
 255
 256   DISALLOW_COPY_AND_ASSIGN(TestFaviconDriver);
 257 };
 258
 259 // This class is used to catch the FaviconHandler's download and history
 260 // request, and also provide the methods to access the FaviconHandler
 261 // internals.
 262 class TestFaviconHandler : public favicon::FaviconHandler {
 263  public:
 264   static int GetMaximalIconSize(favicon_base::IconType icon_type) {
 265     return FaviconHandler::GetMaximalIconSize(icon_type);
 266   }
 267
 268   TestFaviconHandler(const GURL& page_url,
 269                      TestFaviconDriver* driver,
 270                      Type type,
 271                      bool download_largest_icon)
 272       : favicon::FaviconHandler(nullptr,
 273                                 driver,
 274                                 type,
 275                                 download_largest_icon),
 276         download_id_(0) {
 277     driver->SetActiveURL(page_url);
 278     download_handler_.reset(new DownloadHandler(this));
 279   }
 280
 281   ~TestFaviconHandler() override {}
 282
 283   HistoryRequestHandler* history_handler() {
 284     return history_handler_.get();
 285   }
 286
 287   // This method will take the ownership of the given handler.
 288   void set_history_handler(HistoryRequestHandler* handler) {
 289     history_handler_.reset(handler);
 290   }
 291
 292   DownloadHandler* download_handler() {
 293     return download_handler_.get();
 294   }
 295
 296   // Methods to access favicon internals.
 297   const std::vector<FaviconURL>& urls() {
 298     return image_urls_;
 299   }
 300
 301   FaviconURL* current_candidate() {
 302     return favicon::FaviconHandler::current_candidate();
 303   }
 304
 305   const FaviconCandidate& best_favicon_candidate() {
 306     return best_favicon_candidate_;
 307   }
 308
 309  protected:
 310   void UpdateFaviconMappingAndFetch(
 311       const GURL& page_url,
 312       const GURL& icon_url,
 313       favicon_base::IconType icon_type,
 314       const favicon_base::FaviconResultsCallback& callback,
 315       base::CancelableTaskTracker* tracker) override {
 316     history_handler_.reset(new HistoryRequestHandler(page_url, icon_url,
 317                                                      icon_type, callback));
 318   }
 319
 320   void GetFaviconFromFaviconService(
 321       const GURL& icon_url,
 322       favicon_base::IconType icon_type,
 323       const favicon_base::FaviconResultsCallback& callback,
 324       base::CancelableTaskTracker* tracker) override {
 325     history_handler_.reset(new HistoryRequestHandler(GURL(), icon_url,
 326                                                      icon_type, callback));
 327   }
 328
 329   void GetFaviconForURLFromFaviconService(
 330       const GURL& page_url,
 331       int icon_types,
 332       const favicon_base::FaviconResultsCallback& callback,
 333       base::CancelableTaskTracker* tracker) override {
 334     history_handler_.reset(new HistoryRequestHandler(page_url, GURL(),
 335                                                      icon_types, callback));
 336   }
 337
 338   int DownloadFavicon(const GURL& image_url, int max_bitmap_size) override {
 339     download_id_++;
 340     std::vector<int> sizes;
 341     sizes.push_back(0);
 342     download_handler_->AddDownload(
 343         download_id_, image_url, sizes, max_bitmap_size);
 344     return download_id_;
 345   }
 346
 347   void SetHistoryFavicons(const GURL& page_url,
 348                           const GURL& icon_url,
 349                           favicon_base::IconType icon_type,
 350                           const gfx::Image& image) override {
 351     scoped_refptr<base::RefCountedMemory> bytes = image.As1xPNGBytes();
 352     std::vector<unsigned char> bitmap_data(bytes->front(),
 353                                            bytes->front() + bytes->size());
 354     history_handler_.reset(new HistoryRequestHandler(
 355         page_url, icon_url, icon_type, bitmap_data, image.Size()));
 356   }
 357
 358   bool ShouldSaveFavicon(const GURL& url) override { return true; }
 359
 360   GURL page_url_;
 361
 362  private:
 363
 364   // The unique id of a download request. It will be returned to a
 365   // FaviconHandler.
 366   int download_id_;
 367
 368   scoped_ptr<DownloadHandler> download_handler_;
 369   scoped_ptr<HistoryRequestHandler> history_handler_;
 370
 371   DISALLOW_COPY_AND_ASSIGN(TestFaviconHandler);
 372 };
 373
 374 namespace {
 375
 376 void HistoryRequestHandler::InvokeCallback() {
 377   if (!callback_.is_null()) {
 378     callback_.Run(history_results_);
 379   }
 380 }
 381
 382 void DownloadHandler::InvokeCallback() {
 383   std::vector<gfx::Size> original_bitmap_sizes;
 384   std::vector<SkBitmap> bitmaps;
 385   if (!failed_) {
 386     for (std::vector<int>::const_iterator i = download_->image_sizes.begin();
 387          i != download_->image_sizes.end(); ++i) {
 388       int original_size = (*i > 0) ? *i : gfx::kFaviconSize;
 389       int downloaded_size = original_size;
 390       if (download_->max_image_size != 0 &&
 391           downloaded_size > download_->max_image_size) {
 392         downloaded_size = download_->max_image_size;
 393       }
 394       SkBitmap bitmap;
 395       FillDataToBitmap(downloaded_size, downloaded_size, &bitmap);
 396       bitmaps.push_back(bitmap);
 397       original_bitmap_sizes.push_back(gfx::Size(original_size, original_size));
 398     }
 399   }
 400   favicon_helper_->OnDidDownloadFavicon(download_->download_id,
 401                                         download_->image_url,
 402                                         bitmaps,
 403                                         original_bitmap_sizes);
 404 }
 405
 406 class FaviconHandlerTest : public ChromeRenderViewHostTestHarness {
 407  public:
 408   FaviconHandlerTest() {
 409   }
 410
 411   ~FaviconHandlerTest() override {}
 412
 413   // Simulates requesting a favicon for |page_url| given:
 414   // - We have not previously cached anything in history for |page_url| or for
 415   //   any of |candidates|.
 416   // - The page provides favicons at |candidate_icons|.
 417   // - The favicons at |candidate_icons| have edge pixel sizes of
 418   //   |candidate_icon_sizes|.
 419   void DownloadTillDoneIgnoringHistory(
 420       TestFaviconDriver* favicon_driver,
 421       TestFaviconHandler* favicon_handler,
 422       const GURL& page_url,
 423       const std::vector<FaviconURL>& candidate_icons,
 424       const int* candidate_icon_sizes) {
 425     UpdateFaviconURL(
 426         favicon_driver, favicon_handler, page_url, candidate_icons);
 427     EXPECT_EQ(candidate_icons.size(), favicon_handler->image_urls().size());
 428
 429     DownloadHandler* download_handler = favicon_handler->download_handler();
 430     for (size_t i = 0; i < candidate_icons.size(); ++i) {
 431       favicon_handler->history_handler()->history_results_.clear();
 432       favicon_handler->history_handler()->InvokeCallback();
 433       ASSERT_TRUE(download_handler->HasDownload());
 434       EXPECT_EQ(download_handler->GetImageUrl(),
 435                 candidate_icons[i].icon_url);
 436       std::vector<int> sizes;
 437       sizes.push_back(candidate_icon_sizes[i]);
 438       download_handler->SetImageSizes(sizes);
 439       download_handler->InvokeCallback();
 440
 441       if (favicon_driver->num_active_favicon())
 442         return;
 443     }
 444   }
 445
 446   void UpdateFaviconURL(TestFaviconDriver* favicon_driver,
 447                         TestFaviconHandler* favicon_handler,
 448                         const GURL& page_url,
 449                         const std::vector<FaviconURL>& candidate_icons) {
 450     favicon_driver->ResetNumActiveFavicon();
 451
 452     favicon_handler->FetchFavicon(page_url);
 453     favicon_handler->history_handler()->InvokeCallback();
 454
 455     favicon_handler->OnUpdateFaviconURL(candidate_icons);
 456   }
 457
 458   void SetUp() override {
 459     // The score computed by SelectFaviconFrames() is dependent on the supported
 460     // scale factors of the platform. It is used for determining the goodness of
 461     // a downloaded bitmap in favicon::FaviconHandler::OnDidDownloadFavicon().
 462     // Force the values of the scale factors so that the tests produce the same
 463     // results on all platforms.
 464     std::vector<ui::ScaleFactor> scale_factors;
 465     scale_factors.push_back(ui::SCALE_FACTOR_100P);
 466     scoped_set_supported_scale_factors_.reset(
 467         new ui::test::ScopedSetSupportedScaleFactors(scale_factors));
 468
 469     ChromeRenderViewHostTestHarness::SetUp();
 470   }
 471
 472   void TearDown() override {
 473     Profile* profile = Profile::FromBrowserContext(
 474         web_contents()->GetBrowserContext());
 475     FaviconServiceFactory::GetInstance()->SetTestingFactory(profile, nullptr);
 476     ChromeRenderViewHostTestHarness::TearDown();
 477   }
 478
 479  private:
 480   typedef scoped_ptr<ui::test::ScopedSetSupportedScaleFactors>
 481       ScopedSetSupportedScaleFactors;
 482   ScopedSetSupportedScaleFactors scoped_set_supported_scale_factors_;
 483   DISALLOW_COPY_AND_ASSIGN(FaviconHandlerTest);
 484 };
 485
 486 TEST_F(FaviconHandlerTest, GetFaviconFromHistory) {
 487   const GURL page_url("http://www.google.com");
 488   const GURL icon_url("http://www.google.com/favicon");
 489
 490   TestFaviconDriver driver;
 491   TestFaviconHandler helper(page_url, &driver, favicon::FaviconHandler::FAVICON,
 492                             false);
 493
 494   helper.FetchFavicon(page_url);
 495   HistoryRequestHandler* history_handler = helper.history_handler();
 496   // Ensure the data given to history is correct.
 497   ASSERT_TRUE(history_handler);
 498   EXPECT_EQ(page_url, history_handler->page_url_);
 499   EXPECT_EQ(GURL(), history_handler->icon_url_);
 500   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 501
 502   SetFaviconRawBitmapResult(icon_url, &history_handler->history_results_);
 503
 504   // Send history response.
 505   history_handler->InvokeCallback();
 506   // Verify FaviconHandler status
 507   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 508   EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
 509
 510   // Simulates update favicon url.
 511   std::vector<FaviconURL> urls;
 512   urls.push_back(
 513       FaviconURL(icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
 514   helper.OnUpdateFaviconURL(urls);
 515
 516   // Verify FaviconHandler status
 517   EXPECT_EQ(1U, helper.urls().size());
 518   ASSERT_TRUE(helper.current_candidate());
 519   ASSERT_EQ(icon_url, helper.current_candidate()->icon_url);
 520   ASSERT_EQ(favicon_base::FAVICON, helper.current_candidate()->icon_type);
 521
 522   // Favicon shouldn't request to download icon.
 523   EXPECT_FALSE(helper.download_handler()->HasDownload());
 524 }
 525
 526 TEST_F(FaviconHandlerTest, DownloadFavicon) {
 527   const GURL page_url("http://www.google.com");
 528   const GURL icon_url("http://www.google.com/favicon");
 529
 530   TestFaviconDriver driver;
 531   TestFaviconHandler helper(page_url, &driver, favicon::FaviconHandler::FAVICON,
 532                             false);
 533
 534   helper.FetchFavicon(page_url);
 535   HistoryRequestHandler* history_handler = helper.history_handler();
 536   // Ensure the data given to history is correct.
 537   ASSERT_TRUE(history_handler);
 538   EXPECT_EQ(page_url, history_handler->page_url_);
 539   EXPECT_EQ(GURL(), history_handler->icon_url_);
 540   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 541
 542   // Set icon data expired
 543   SetFaviconRawBitmapResult(icon_url,
 544                             favicon_base::FAVICON,
 545                             true /* expired */,
 546                             &history_handler->history_results_);
 547   // Send history response.
 548   history_handler->InvokeCallback();
 549   // Verify FaviconHandler status
 550   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 551   EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
 552
 553   // Simulates update favicon url.
 554   std::vector<FaviconURL> urls;
 555   urls.push_back(
 556       FaviconURL(icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
 557   helper.OnUpdateFaviconURL(urls);
 558
 559   // Verify FaviconHandler status
 560   EXPECT_EQ(1U, helper.urls().size());
 561   ASSERT_TRUE(helper.current_candidate());
 562   ASSERT_EQ(icon_url, helper.current_candidate()->icon_url);
 563   ASSERT_EQ(favicon_base::FAVICON, helper.current_candidate()->icon_type);
 564
 565   // Favicon should request to download icon now.
 566   DownloadHandler* download_handler = helper.download_handler();
 567   EXPECT_TRUE(helper.download_handler()->HasDownload());
 568
 569   // Verify the download request.
 570   EXPECT_EQ(icon_url, download_handler->GetImageUrl());
 571
 572   // Reset the history_handler to verify whether favicon is set.
 573   helper.set_history_handler(nullptr);
 574
 575   // Smulates download done.
 576   download_handler->InvokeCallback();
 577
 578   // New icon should be saved to history backend and navigation entry.
 579   history_handler = helper.history_handler();
 580   ASSERT_TRUE(history_handler);
 581   EXPECT_EQ(icon_url, history_handler->icon_url_);
 582   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 583   EXPECT_LT(0U, history_handler->bitmap_data_.size());
 584   EXPECT_EQ(page_url, history_handler->page_url_);
 585
 586   // Verify NavigationEntry.
 587   EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
 588   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 589   EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
 590   EXPECT_EQ(gfx::kFaviconSize, driver.GetActiveFaviconImage().Width());
 591 }
 592
 593 TEST_F(FaviconHandlerTest, UpdateAndDownloadFavicon) {
 594   const GURL page_url("http://www.google.com");
 595   const GURL icon_url("http://www.google.com/favicon");
 596   const GURL new_icon_url("http://www.google.com/new_favicon");
 597
 598   TestFaviconDriver driver;
 599   TestFaviconHandler helper(page_url, &driver, favicon::FaviconHandler::FAVICON,
 600                             false);
 601
 602   helper.FetchFavicon(page_url);
 603   HistoryRequestHandler* history_handler = helper.history_handler();
 604   // Ensure the data given to history is correct.
 605   ASSERT_TRUE(history_handler);
 606   EXPECT_EQ(page_url, history_handler->page_url_);
 607   EXPECT_EQ(GURL(), history_handler->icon_url_);
 608   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 609
 610   // Set valid icon data.
 611   SetFaviconRawBitmapResult(icon_url, &history_handler->history_results_);
 612
 613   // Send history response.
 614   history_handler->InvokeCallback();
 615   // Verify FaviconHandler status.
 616   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 617   EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
 618
 619   // Reset the history_handler to verify whether new icon is requested from
 620   // history.
 621   helper.set_history_handler(nullptr);
 622
 623   // Simulates update with the different favicon url.
 624   std::vector<FaviconURL> urls;
 625   urls.push_back(FaviconURL(
 626       new_icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
 627   helper.OnUpdateFaviconURL(urls);
 628
 629   // Verify FaviconHandler status.
 630   EXPECT_EQ(1U, helper.urls().size());
 631   ASSERT_TRUE(helper.current_candidate());
 632   ASSERT_EQ(new_icon_url, helper.current_candidate()->icon_url);
 633   ASSERT_EQ(favicon_base::FAVICON, helper.current_candidate()->icon_type);
 634
 635   // Favicon should be requested from history.
 636   history_handler = helper.history_handler();
 637   ASSERT_TRUE(history_handler);
 638   EXPECT_EQ(new_icon_url, history_handler->icon_url_);
 639   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 640   EXPECT_EQ(page_url, history_handler->page_url_);
 641
 642   // Simulate not find icon.
 643   history_handler->history_results_.clear();
 644   history_handler->InvokeCallback();
 645
 646   // Favicon should request to download icon now.
 647   DownloadHandler* download_handler = helper.download_handler();
 648   EXPECT_TRUE(helper.download_handler()->HasDownload());
 649
 650   // Verify the download request.
 651   EXPECT_EQ(new_icon_url, download_handler->GetImageUrl());
 652
 653   // Reset the history_handler to verify whether favicon is set.
 654   helper.set_history_handler(nullptr);
 655
 656   // Smulates download done.
 657   download_handler->InvokeCallback();
 658
 659   // New icon should be saved to history backend and navigation entry.
 660   history_handler = helper.history_handler();
 661   ASSERT_TRUE(history_handler);
 662   EXPECT_EQ(new_icon_url, history_handler->icon_url_);
 663   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 664   EXPECT_LT(0U, history_handler->bitmap_data_.size());
 665   EXPECT_EQ(page_url, history_handler->page_url_);
 666
 667   // Verify NavigationEntry.
 668   EXPECT_EQ(new_icon_url, driver.GetActiveFaviconURL());
 669   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 670   EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
 671   EXPECT_EQ(gfx::kFaviconSize, driver.GetActiveFaviconImage().Width());
 672 }
 673
 674 TEST_F(FaviconHandlerTest, FaviconInHistoryInvalid) {
 675   const GURL page_url("http://www.google.com");
 676   const GURL icon_url("http://www.google.com/favicon");
 677
 678   TestFaviconDriver driver;
 679   TestFaviconHandler helper(page_url, &driver, favicon::FaviconHandler::FAVICON,
 680                             false);
 681
 682   helper.FetchFavicon(page_url);
 683   HistoryRequestHandler* history_handler = helper.history_handler();
 684   // Ensure the data given to history is correct.
 685   ASSERT_TRUE(history_handler);
 686   EXPECT_EQ(page_url, history_handler->page_url_);
 687   EXPECT_EQ(GURL(), history_handler->icon_url_);
 688   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 689
 690   // Set non empty but invalid data.
 691   favicon_base::FaviconRawBitmapResult bitmap_result;
 692   bitmap_result.expired = false;
 693   // Empty bitmap data is invalid.
 694   bitmap_result.bitmap_data = new base::RefCountedBytes();
 695   bitmap_result.pixel_size = gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize);
 696   bitmap_result.icon_type = favicon_base::FAVICON;
 697   bitmap_result.icon_url = icon_url;
 698   history_handler->history_results_.clear();
 699   history_handler->history_results_.push_back(bitmap_result);
 700
 701   // Send history response.
 702   history_handler->InvokeCallback();
 703   // The NavigationEntry should not be set yet as the history data is invalid.
 704   EXPECT_FALSE(driver.GetActiveFaviconValidity());
 705   EXPECT_EQ(GURL(), driver.GetActiveFaviconURL());
 706
 707   // Reset the history_handler to verify whether new icon is requested from
 708   // history.
 709   helper.set_history_handler(nullptr);
 710
 711   // Simulates update with matching favicon URL.
 712   std::vector<FaviconURL> urls;
 713   urls.push_back(
 714       FaviconURL(icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
 715   helper.OnUpdateFaviconURL(urls);
 716
 717   // A download for the favicon should be requested, and we should not do
 718   // another history request.
 719   DownloadHandler* download_handler = helper.download_handler();
 720   EXPECT_TRUE(helper.download_handler()->HasDownload());
 721   EXPECT_EQ(nullptr, helper.history_handler());
 722
 723   // Verify the download request.
 724   EXPECT_EQ(icon_url, download_handler->GetImageUrl());
 725
 726   // Simulates download done.
 727   download_handler->InvokeCallback();
 728
 729   // New icon should be saved to history backend and navigation entry.
 730   history_handler = helper.history_handler();
 731   ASSERT_TRUE(history_handler);
 732   EXPECT_EQ(icon_url, history_handler->icon_url_);
 733   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 734   EXPECT_LT(0U, history_handler->bitmap_data_.size());
 735   EXPECT_EQ(page_url, history_handler->page_url_);
 736
 737   // Verify NavigationEntry.
 738   EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
 739   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 740   EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
 741   EXPECT_EQ(gfx::kFaviconSize, driver.GetActiveFaviconImage().Width());
 742 }
 743
 744 TEST_F(FaviconHandlerTest, UpdateFavicon) {
 745   const GURL page_url("http://www.google.com");
 746   const GURL icon_url("http://www.google.com/favicon");
 747   const GURL new_icon_url("http://www.google.com/new_favicon");
 748
 749   TestFaviconDriver driver;
 750   TestFaviconHandler helper(page_url, &driver, favicon::FaviconHandler::FAVICON,
 751                             false);
 752
 753   helper.FetchFavicon(page_url);
 754   HistoryRequestHandler* history_handler = helper.history_handler();
 755   // Ensure the data given to history is correct.
 756   ASSERT_TRUE(history_handler);
 757   EXPECT_EQ(page_url, history_handler->page_url_);
 758   EXPECT_EQ(GURL(), history_handler->icon_url_);
 759   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 760
 761   SetFaviconRawBitmapResult(icon_url, &history_handler->history_results_);
 762
 763   // Send history response.
 764   history_handler->InvokeCallback();
 765   // Verify FaviconHandler status.
 766   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 767   EXPECT_EQ(icon_url, driver.GetActiveFaviconURL());
 768
 769   // Reset the history_handler to verify whether new icon is requested from
 770   // history.
 771   helper.set_history_handler(nullptr);
 772
 773   // Simulates update with the different favicon url.
 774   std::vector<FaviconURL> urls;
 775   urls.push_back(FaviconURL(
 776       new_icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
 777   helper.OnUpdateFaviconURL(urls);
 778
 779   // Verify FaviconHandler status.
 780   EXPECT_EQ(1U, helper.urls().size());
 781   ASSERT_TRUE(helper.current_candidate());
 782   ASSERT_EQ(new_icon_url, helper.current_candidate()->icon_url);
 783   ASSERT_EQ(favicon_base::FAVICON, helper.current_candidate()->icon_type);
 784
 785   // Favicon should be requested from history.
 786   history_handler = helper.history_handler();
 787   ASSERT_TRUE(history_handler);
 788   EXPECT_EQ(new_icon_url, history_handler->icon_url_);
 789   EXPECT_EQ(favicon_base::FAVICON, history_handler->icon_type_);
 790   EXPECT_EQ(page_url, history_handler->page_url_);
 791
 792   // Simulate find icon.
 793   SetFaviconRawBitmapResult(new_icon_url, &history_handler->history_results_);
 794   history_handler->InvokeCallback();
 795
 796   // Shouldn't request download favicon
 797   EXPECT_FALSE(helper.download_handler()->HasDownload());
 798
 799   // Verify the favicon status.
 800   EXPECT_EQ(new_icon_url, driver.GetActiveFaviconURL());
 801   EXPECT_TRUE(driver.GetActiveFaviconValidity());
 802   EXPECT_FALSE(driver.GetActiveFaviconImage().IsEmpty());
 803 }
 804
 805 TEST_F(FaviconHandlerTest, Download2ndFaviconURLCandidate) {
 806   const GURL page_url("http://www.google.com");
 807   const GURL icon_url("http://www.google.com/favicon");
 808   const GURL new_icon_url("http://www.google.com/new_favicon");
 809
 810   TestFaviconDriver driver;
 811   TestFaviconHandler helper(page_url, &driver, favicon::FaviconHandler::TOUCH,
 812                             false);
 813
 814   helper.FetchFavicon(page_url);
 815   HistoryRequestHandler* history_handler = helper.history_handler();
 816   // Ensure the data given to history is correct.
 817   ASSERT_TRUE(history_handler);
 818   EXPECT_EQ(page_url, history_handler->page_url_);
 819   EXPECT_EQ(GURL(), history_handler->icon_url_);
 820   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON | favicon_base::TOUCH_ICON,
 821             history_handler->icon_type_);
 822
 823   // Icon not found.
 824   history_handler->history_results_.clear();
 825   // Send history response.
 826   history_handler->InvokeCallback();
 827   // Verify FaviconHandler status.
 828   EXPECT_FALSE(driver.GetActiveFaviconValidity());
 829   EXPECT_EQ(GURL(), driver.GetActiveFaviconURL());
 830
 831   // Reset the history_handler to verify whether new icon is requested from
 832   // history.
 833   helper.set_history_handler(nullptr);
 834
 835   // Simulates update with the different favicon url.
 836   std::vector<FaviconURL> urls;
 837   urls.push_back(FaviconURL(icon_url,
 838                             favicon_base::TOUCH_PRECOMPOSED_ICON,
 839                             std::vector<gfx::Size>()));
 840   urls.push_back(FaviconURL(
 841       new_icon_url, favicon_base::TOUCH_ICON, std::vector<gfx::Size>()));
 842   urls.push_back(FaviconURL(
 843       new_icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
 844   helper.OnUpdateFaviconURL(urls);
 845
 846   // Verify FaviconHandler status.
 847   EXPECT_EQ(2U, helper.urls().size());
 848   ASSERT_TRUE(helper.current_candidate());
 849   ASSERT_EQ(icon_url, helper.current_candidate()->icon_url);
 850   ASSERT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON,
 851             helper.current_candidate()->icon_type);
 852
 853   // Favicon should be requested from history.
 854   history_handler = helper.history_handler();
 855   ASSERT_TRUE(history_handler);
 856   EXPECT_EQ(icon_url, history_handler->icon_url_);
 857   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON, history_handler->icon_type_);
 858   EXPECT_EQ(page_url, history_handler->page_url_);
 859
 860   // Simulate not find icon.
 861   history_handler->history_results_.clear();
 862   history_handler->InvokeCallback();
 863
 864   // Should request download favicon.
 865   DownloadHandler* download_handler = helper.download_handler();
 866   EXPECT_TRUE(helper.download_handler()->HasDownload());
 867
 868   // Verify the download request.
 869   EXPECT_EQ(icon_url, download_handler->GetImageUrl());
 870
 871   // Reset the history_handler to verify whether favicon is request from
 872   // history.
 873   helper.set_history_handler(nullptr);
 874   // Smulates download failed.
 875   download_handler->set_failed(true);
 876   download_handler->InvokeCallback();
 877
 878   // Left 1 url.
 879   EXPECT_EQ(1U, helper.urls().size());
 880   ASSERT_TRUE(helper.current_candidate());
 881   EXPECT_EQ(new_icon_url, helper.current_candidate()->icon_url);
 882   EXPECT_EQ(favicon_base::TOUCH_ICON, helper.current_candidate()->icon_type);
 883
 884   // Favicon should be requested from history.
 885   history_handler = helper.history_handler();
 886   ASSERT_TRUE(history_handler);
 887   EXPECT_EQ(new_icon_url, history_handler->icon_url_);
 888   EXPECT_EQ(favicon_base::TOUCH_ICON, history_handler->icon_type_);
 889   EXPECT_EQ(page_url, history_handler->page_url_);
 890
 891   // Reset download handler
 892   download_handler->Reset();
 893
 894   // Simulates getting a expired icon from history.
 895   SetFaviconRawBitmapResult(new_icon_url,
 896                             favicon_base::TOUCH_ICON,
 897                             true /* expired */,
 898                             &history_handler->history_results_);
 899   history_handler->InvokeCallback();
 900
 901   // Verify the download request.
 902   EXPECT_TRUE(helper.download_handler()->HasDownload());
 903   EXPECT_EQ(new_icon_url, download_handler->GetImageUrl());
 904
 905   helper.set_history_handler(nullptr);
 906
 907   // Simulates icon being downloaded.
 908   download_handler->InvokeCallback();
 909
 910   // New icon should be saved to history backend.
 911   history_handler = helper.history_handler();
 912   ASSERT_TRUE(history_handler);
 913   EXPECT_EQ(new_icon_url, history_handler->icon_url_);
 914   EXPECT_EQ(favicon_base::TOUCH_ICON, history_handler->icon_type_);
 915   EXPECT_LT(0U, history_handler->bitmap_data_.size());
 916   EXPECT_EQ(page_url, history_handler->page_url_);
 917 }
 918
 919 TEST_F(FaviconHandlerTest, UpdateDuringDownloading) {
 920   const GURL page_url("http://www.google.com");
 921   const GURL icon_url("http://www.google.com/favicon");
 922   const GURL new_icon_url("http://www.google.com/new_favicon");
 923
 924   TestFaviconDriver driver;
 925   TestFaviconHandler helper(page_url, &driver, favicon::FaviconHandler::TOUCH,
 926                             false);
 927
 928   helper.FetchFavicon(page_url);
 929   HistoryRequestHandler* history_handler = helper.history_handler();
 930   // Ensure the data given to history is correct.
 931   ASSERT_TRUE(history_handler);
 932   EXPECT_EQ(page_url, history_handler->page_url_);
 933   EXPECT_EQ(GURL(), history_handler->icon_url_);
 934   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON | favicon_base::TOUCH_ICON,
 935             history_handler->icon_type_);
 936
 937   // Icon not found.
 938   history_handler->history_results_.clear();
 939   // Send history response.
 940   history_handler->InvokeCallback();
 941   // Verify FaviconHandler status.
 942   EXPECT_FALSE(driver.GetActiveFaviconValidity());
 943   EXPECT_EQ(GURL(), driver.GetActiveFaviconURL());
 944
 945   // Reset the history_handler to verify whether new icon is requested from
 946   // history.
 947   helper.set_history_handler(nullptr);
 948
 949   // Simulates update with the different favicon url.
 950   std::vector<FaviconURL> urls;
 951   urls.push_back(FaviconURL(icon_url,
 952                             favicon_base::TOUCH_PRECOMPOSED_ICON,
 953                             std::vector<gfx::Size>()));
 954   urls.push_back(FaviconURL(
 955       new_icon_url, favicon_base::TOUCH_ICON, std::vector<gfx::Size>()));
 956   urls.push_back(FaviconURL(
 957       new_icon_url, favicon_base::FAVICON, std::vector<gfx::Size>()));
 958   helper.OnUpdateFaviconURL(urls);
 959
 960   // Verify FaviconHandler status.
 961   EXPECT_EQ(2U, helper.urls().size());
 962   ASSERT_TRUE(helper.current_candidate());
 963   ASSERT_EQ(icon_url, helper.current_candidate()->icon_url);
 964   ASSERT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON,
 965             helper.current_candidate()->icon_type);
 966
 967   // Favicon should be requested from history.
 968   history_handler = helper.history_handler();
 969   ASSERT_TRUE(history_handler);
 970   EXPECT_EQ(icon_url, history_handler->icon_url_);
 971   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON, history_handler->icon_type_);
 972   EXPECT_EQ(page_url, history_handler->page_url_);
 973
 974   // Simulate not find icon.
 975   history_handler->history_results_.clear();
 976   history_handler->InvokeCallback();
 977
 978   // Should request download favicon.
 979   DownloadHandler* download_handler = helper.download_handler();
 980   EXPECT_TRUE(helper.download_handler()->HasDownload());
 981
 982   // Verify the download request.
 983   EXPECT_EQ(icon_url, download_handler->GetImageUrl());
 984
 985   // Reset the history_handler to verify whether favicon is request from
 986   // history.
 987   helper.set_history_handler(nullptr);
 988   const GURL latest_icon_url("http://www.google.com/latest_favicon");
 989   std::vector<FaviconURL> latest_urls;
 990   latest_urls.push_back(FaviconURL(
 991       latest_icon_url, favicon_base::TOUCH_ICON, std::vector<gfx::Size>()));
 992   helper.OnUpdateFaviconURL(latest_urls);
 993
 994   EXPECT_EQ(1U, helper.urls().size());
 995   EXPECT_EQ(latest_icon_url, helper.current_candidate()->icon_url);
 996   EXPECT_EQ(favicon_base::TOUCH_ICON, helper.current_candidate()->icon_type);
 997
 998   // Whether new icon is requested from history
 999   history_handler = helper.history_handler();
1000   ASSERT_TRUE(history_handler);
1001   EXPECT_EQ(latest_icon_url, history_handler->icon_url_);
1002   EXPECT_EQ(favicon_base::TOUCH_ICON, history_handler->icon_type_);
1003   EXPECT_EQ(page_url, history_handler->page_url_);
1004
1005   // Reset the history_handler to verify whether favicon is request from
1006   // history.
1007   // Save the callback for late use.
1008   favicon_base::FaviconResultsCallback callback = history_handler->callback_;
1009   helper.set_history_handler(nullptr);
1010
1011   // Simulates download succeed.
1012   download_handler->InvokeCallback();
1013   // The downloaded icon should be thrown away as there is favicon update.
1014   EXPECT_FALSE(helper.history_handler());
1015
1016   download_handler->Reset();
1017
1018   // Simulates getting the icon from history.
1019   scoped_ptr<HistoryRequestHandler> handler;
1020   handler.reset(new HistoryRequestHandler(
1021       page_url, latest_icon_url, favicon_base::TOUCH_ICON, callback));
1022   SetFaviconRawBitmapResult(latest_icon_url,
1023                             favicon_base::TOUCH_ICON,
1024                             false /* expired */,
1025                             &handler->history_results_);
1026   handler->InvokeCallback();
1027
1028   // No download request.
1029   EXPECT_FALSE(download_handler->HasDownload());
1030 }
1031
1032 #if !defined(OS_ANDROID)
1033
1034 // Test the favicon which is selected when the web page provides several
1035 // favicons and none of the favicons are cached in history.
1036 // The goal of this test is to be more of an integration test than
1037 // SelectFaviconFramesTest.*.
1038 TEST_F(FaviconHandlerTest, MultipleFavicons) {
1039   const GURL kPageURL("http://www.google.com");
1040   const FaviconURL kSourceIconURLs[] = {
1041       FaviconURL(GURL("http://www.google.com/a"),
1042                  favicon_base::FAVICON,
1043                  std::vector<gfx::Size>()),
1044       FaviconURL(GURL("http://www.google.com/b"),
1045                  favicon_base::FAVICON,
1046                  std::vector<gfx::Size>()),
1047       FaviconURL(GURL("http://www.google.com/c"),
1048                  favicon_base::FAVICON,
1049                  std::vector<gfx::Size>()),
1050       FaviconURL(GURL("http://www.google.com/d"),
1051                  favicon_base::FAVICON,
1052                  std::vector<gfx::Size>()),
1053       FaviconURL(GURL("http://www.google.com/e"),
1054                  favicon_base::FAVICON,
1055                  std::vector<gfx::Size>())};
1056
1057   // Set the supported scale factors to 1x and 2x. This affects the behavior of
1058   // SelectFaviconFrames().
1059   std::vector<ui::ScaleFactor> scale_factors;
1060   scale_factors.push_back(ui::SCALE_FACTOR_100P);
1061   scale_factors.push_back(ui::SCALE_FACTOR_200P);
1062   ui::test::ScopedSetSupportedScaleFactors scoped_supported(scale_factors);
1063
1064   // 1) Test that if there are several single resolution favicons to choose from
1065   // that the largest exact match is chosen.
1066   TestFaviconDriver driver1;
1067   TestFaviconHandler handler1(kPageURL, &driver1,
1068                               favicon::FaviconHandler::FAVICON, false);
1069
1070   const int kSizes1[] = { 16, 24, 32, 48, 256 };
1071   std::vector<FaviconURL> urls1(kSourceIconURLs,
1072                                 kSourceIconURLs + arraysize(kSizes1));
1073   DownloadTillDoneIgnoringHistory(
1074       &driver1, &handler1, kPageURL, urls1, kSizes1);
1075
1076   EXPECT_EQ(0u, handler1.image_urls().size());
1077   EXPECT_TRUE(driver1.GetActiveFaviconValidity());
1078   EXPECT_FALSE(driver1.GetActiveFaviconImage().IsEmpty());
1079   EXPECT_EQ(gfx::kFaviconSize, driver1.GetActiveFaviconImage().Width());
1080
1081   size_t expected_index = 2u;
1082   EXPECT_EQ(32, kSizes1[expected_index]);
1083   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
1084             driver1.GetActiveFaviconURL());
1085
1086   // 2) Test that if there are several single resolution favicons to choose
1087   // from, the exact match is preferred even if it results in upsampling.
1088   TestFaviconDriver driver2;
1089   TestFaviconHandler handler2(kPageURL, &driver2,
1090                               favicon::FaviconHandler::FAVICON, false);
1091
1092   const int kSizes2[] = { 16, 24, 48, 256 };
1093   std::vector<FaviconURL> urls2(kSourceIconURLs,
1094                                 kSourceIconURLs + arraysize(kSizes2));
1095   DownloadTillDoneIgnoringHistory(
1096       &driver2, &handler2, kPageURL, urls2, kSizes2);
1097   EXPECT_TRUE(driver2.GetActiveFaviconValidity());
1098   expected_index = 0u;
1099   EXPECT_EQ(16, kSizes2[expected_index]);
1100   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
1101             driver2.GetActiveFaviconURL());
1102
1103   // 3) Test that favicons which need to be upsampled a little or downsampled
1104   // a little are preferred over huge favicons.
1105   TestFaviconDriver driver3;
1106   TestFaviconHandler handler3(kPageURL, &driver3,
1107                               favicon::FaviconHandler::FAVICON, false);
1108
1109   const int kSizes3[] = { 256, 48 };
1110   std::vector<FaviconURL> urls3(kSourceIconURLs,
1111                                 kSourceIconURLs + arraysize(kSizes3));
1112   DownloadTillDoneIgnoringHistory(
1113       &driver3, &handler3, kPageURL, urls3, kSizes3);
1114   EXPECT_TRUE(driver3.GetActiveFaviconValidity());
1115   expected_index = 1u;
1116   EXPECT_EQ(48, kSizes3[expected_index]);
1117   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
1118             driver3.GetActiveFaviconURL());
1119
1120   TestFaviconDriver driver4;
1121   TestFaviconHandler handler4(kPageURL, &driver4,
1122                               favicon::FaviconHandler::FAVICON, false);
1123
1124   const int kSizes4[] = { 17, 256 };
1125   std::vector<FaviconURL> urls4(kSourceIconURLs,
1126                                 kSourceIconURLs + arraysize(kSizes4));
1127   DownloadTillDoneIgnoringHistory(
1128       &driver4, &handler4, kPageURL, urls4, kSizes4);
1129   EXPECT_TRUE(driver4.GetActiveFaviconValidity());
1130   expected_index = 0u;
1131   EXPECT_EQ(17, kSizes4[expected_index]);
1132   EXPECT_EQ(kSourceIconURLs[expected_index].icon_url,
1133             driver4.GetActiveFaviconURL());
1134 }
1135
1136 #endif
1137
1138 TEST_F(FaviconHandlerTest, TestSortFavicon) {
1139   const GURL kPageURL("http://www.google.com");
1140   std::vector<gfx::Size> icon1;
1141   icon1.push_back(gfx::Size(1024, 1024));
1142   icon1.push_back(gfx::Size(512, 512));
1143
1144   std::vector<gfx::Size> icon2;
1145   icon2.push_back(gfx::Size(15, 15));
1146   icon2.push_back(gfx::Size(16, 16));
1147
1148   std::vector<gfx::Size> icon3;
1149   icon3.push_back(gfx::Size(16, 16));
1150   icon3.push_back(gfx::Size(14, 14));
1151
1152   const FaviconURL kSourceIconURLs[] = {
1153       FaviconURL(GURL("http://www.google.com/a"), favicon_base::FAVICON, icon1),
1154       FaviconURL(GURL("http://www.google.com/b"), favicon_base::FAVICON, icon2),
1155       FaviconURL(GURL("http://www.google.com/c"), favicon_base::FAVICON, icon3),
1156       FaviconURL(GURL("http://www.google.com/d"),
1157                  favicon_base::FAVICON,
1158                  std::vector<gfx::Size>()),
1159       FaviconURL(GURL("http://www.google.com/e"),
1160                  favicon_base::FAVICON,
1161                  std::vector<gfx::Size>())};
1162
1163   TestFaviconDriver driver1;
1164   TestFaviconHandler handler1(kPageURL, &driver1,
1165                               favicon::FaviconHandler::FAVICON, true);
1166   std::vector<FaviconURL> urls1(kSourceIconURLs,
1167                                 kSourceIconURLs + arraysize(kSourceIconURLs));
1168   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
1169
1170   struct ExpectedResult {
1171     // The favicon's index in kSourceIconURLs.
1172     size_t favicon_index;
1173     // Width of largest bitmap.
1174     int width;
1175   } results[] = {
1176     // First is icon1, though its size larger than maximal.
1177     {0, 1024},
1178     // Second is icon2
1179     // The 16x16 is largest.
1180     {1, 16},
1181     // Third is icon3 though it has same size as icon2.
1182     // The 16x16 is largest.
1183     {2, 16},
1184     // The rest of bitmaps come in order, there is no sizes attribute.
1185     {3, -1},
1186     {4, -1},
1187   };
1188   const std::vector<FaviconURL>& icons = handler1.image_urls();
1189   ASSERT_EQ(5u, icons.size());
1190   for (size_t i = 0; i < icons.size(); ++i) {
1191     EXPECT_EQ(kSourceIconURLs[results[i].favicon_index].icon_url,
1192               icons[i].icon_url);
1193     if (results[i].width != -1)
1194       EXPECT_EQ(results[i].width, icons[i].icon_sizes[0].width());
1195   }
1196 }
1197
1198 TEST_F(FaviconHandlerTest, TestDownloadLargestFavicon) {
1199   const GURL kPageURL("http://www.google.com");
1200   std::vector<gfx::Size> icon1;
1201   icon1.push_back(gfx::Size(1024, 1024));
1202   icon1.push_back(gfx::Size(512, 512));
1203
1204   std::vector<gfx::Size> icon2;
1205   icon2.push_back(gfx::Size(15, 15));
1206   icon2.push_back(gfx::Size(14, 14));
1207
1208   std::vector<gfx::Size> icon3;
1209   icon3.push_back(gfx::Size(16, 16));
1210   icon3.push_back(gfx::Size(512, 512));
1211
1212   const FaviconURL kSourceIconURLs[] = {
1213       FaviconURL(
1214           GURL("http://www.google.com/a"), favicon_base::FAVICON, icon1),
1215       FaviconURL(
1216           GURL("http://www.google.com/b"), favicon_base::FAVICON, icon2),
1217       FaviconURL(
1218           GURL("http://www.google.com/c"), favicon_base::FAVICON, icon3),
1219       FaviconURL(GURL("http://www.google.com/d"),
1220                  favicon_base::FAVICON,
1221                  std::vector<gfx::Size>()),
1222       FaviconURL(GURL("http://www.google.com/e"),
1223                  favicon_base::FAVICON,
1224                  std::vector<gfx::Size>())};
1225
1226   TestFaviconDriver driver1;
1227   TestFaviconHandler handler1(kPageURL, &driver1,
1228                               favicon::FaviconHandler::FAVICON, true);
1229   std::vector<FaviconURL> urls1(kSourceIconURLs,
1230                                 kSourceIconURLs + arraysize(kSourceIconURLs));
1231   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
1232
1233   // Simulate the download failed, to check whether the icons were requested
1234   // to download according their size.
1235   struct ExpectedResult {
1236     // The size of image_urls_.
1237     size_t image_urls_size;
1238     // The favicon's index in kSourceIconURLs.
1239     size_t favicon_index;
1240     // Width of largest bitmap.
1241     int width;
1242   } results[] = {
1243     {5, 0, 1024},
1244     {4, 2, 512},
1245     {3, 1, 15},
1246     // The rest of bitmaps come in order.
1247     {2, 3, -1},
1248     {1, 4, -1},
1249   };
1250
1251   for (int i = 0; i < 5; ++i) {
1252     ASSERT_EQ(results[i].image_urls_size, handler1.image_urls().size());
1253     EXPECT_EQ(kSourceIconURLs[results[i].favicon_index].icon_url,
1254               handler1.current_candidate()->icon_url);
1255     if (results[i].width != -1) {
1256       EXPECT_EQ(results[i].width, handler1.current_candidate()->
1257                 icon_sizes[0].width());
1258     }
1259
1260     // Simulate no favicon from history.
1261     handler1.history_handler()->history_results_.clear();
1262     handler1.history_handler()->InvokeCallback();
1263
1264     // Verify download request
1265     ASSERT_TRUE(handler1.download_handler()->HasDownload());
1266     EXPECT_EQ(kSourceIconURLs[results[i].favicon_index].icon_url,
1267               handler1.download_handler()->GetImageUrl());
1268
1269     // Simulate the download failed.
1270     handler1.download_handler()->set_failed(true);
1271     handler1.download_handler()->InvokeCallback();
1272   }
1273 }
1274
1275 TEST_F(FaviconHandlerTest, TestSelectLargestFavicon) {
1276   const GURL kPageURL("http://www.google.com");
1277
1278   std::vector<gfx::Size> one_icon;
1279   one_icon.push_back(gfx::Size(15, 15));
1280
1281   std::vector<gfx::Size> two_icons;
1282   two_icons.push_back(gfx::Size(14, 14));
1283   two_icons.push_back(gfx::Size(16, 16));
1284
1285   const FaviconURL kSourceIconURLs[] = {
1286       FaviconURL(
1287           GURL("http://www.google.com/b"), favicon_base::FAVICON, one_icon),
1288       FaviconURL(
1289           GURL("http://www.google.com/c"), favicon_base::FAVICON, two_icons)};
1290
1291   TestFaviconDriver driver1;
1292   TestFaviconHandler handler1(kPageURL, &driver1,
1293                               favicon::FaviconHandler::FAVICON, true);
1294   std::vector<FaviconURL> urls1(kSourceIconURLs,
1295                                 kSourceIconURLs + arraysize(kSourceIconURLs));
1296   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
1297
1298   ASSERT_EQ(2u, handler1.urls().size());
1299
1300   // Index of largest favicon in kSourceIconURLs.
1301   size_t i = 1;
1302   // The largest bitmap's index in Favicon .
1303   int b = 1;
1304
1305   // Verify the icon_bitmaps_ was initialized correctly.
1306   EXPECT_EQ(kSourceIconURLs[i].icon_url,
1307             handler1.current_candidate()->icon_url);
1308   EXPECT_EQ(kSourceIconURLs[i].icon_sizes[b],
1309             handler1.current_candidate()->icon_sizes[0]);
1310
1311   // Simulate no favicon from history.
1312   handler1.history_handler()->history_results_.clear();
1313   handler1.history_handler()->InvokeCallback();
1314
1315   // Verify download request
1316   ASSERT_TRUE(handler1.download_handler()->HasDownload());
1317   EXPECT_EQ(kSourceIconURLs[i].icon_url,
1318             handler1.download_handler()->GetImageUrl());
1319
1320   // Give the correct download result.
1321   std::vector<int> sizes;
1322   for (std::vector<gfx::Size>::const_iterator j =
1323            kSourceIconURLs[i].icon_sizes.begin();
1324        j != kSourceIconURLs[i].icon_sizes.end(); ++j)
1325     sizes.push_back(j->width());
1326
1327   handler1.download_handler()->SetImageSizes(sizes);
1328   handler1.download_handler()->InvokeCallback();
1329
1330   // Verify the largest bitmap has been saved into history.
1331   EXPECT_EQ(kSourceIconURLs[i].icon_url, handler1.history_handler()->icon_url_);
1332   EXPECT_EQ(kSourceIconURLs[i].icon_sizes[b],
1333             handler1.history_handler()->size_);
1334   // Verify NotifyFaviconAvailable().
1335   EXPECT_FALSE(driver1.update_active_favicon());
1336   EXPECT_EQ(kSourceIconURLs[i].icon_url, driver1.available_icon_url());
1337   EXPECT_EQ(kSourceIconURLs[i].icon_sizes[b],
1338             driver1.available_favicon().Size());
1339 }
1340
1341 TEST_F(FaviconHandlerTest, TestFaviconWasScaledAfterDownload) {
1342   const GURL kPageURL("http://www.google.com");
1343   const int kMaximalSize =
1344     TestFaviconHandler::GetMaximalIconSize(favicon_base::FAVICON);
1345
1346   std::vector<gfx::Size> icon1;
1347   icon1.push_back(gfx::Size(kMaximalSize + 1, kMaximalSize + 1));
1348
1349   std::vector<gfx::Size> icon2;
1350   icon2.push_back(gfx::Size(kMaximalSize + 2, kMaximalSize + 2));
1351
1352   const FaviconURL kSourceIconURLs[] = {
1353       FaviconURL(
1354           GURL("http://www.google.com/b"), favicon_base::FAVICON, icon1),
1355       FaviconURL(
1356           GURL("http://www.google.com/c"), favicon_base::FAVICON, icon2)};
1357
1358   TestFaviconDriver driver1;
1359   TestFaviconHandler handler1(kPageURL, &driver1,
1360                               favicon::FaviconHandler::FAVICON, true);
1361   std::vector<FaviconURL> urls1(kSourceIconURLs,
1362                                 kSourceIconURLs + arraysize(kSourceIconURLs));
1363   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
1364
1365   ASSERT_EQ(2u, handler1.urls().size());
1366
1367   // Index of largest favicon in kSourceIconURLs.
1368   size_t i = 1;
1369   // The largest bitmap's index in Favicon .
1370   int b = 0;
1371
1372   // Verify the icon_bitmaps_ was initialized correctly.
1373   EXPECT_EQ(kSourceIconURLs[i].icon_url,
1374             handler1.current_candidate()->icon_url);
1375   EXPECT_EQ(kSourceIconURLs[i].icon_sizes[b],
1376             handler1.current_candidate()->icon_sizes[0]);
1377
1378   // Simulate no favicon from history.
1379   handler1.history_handler()->history_results_.clear();
1380   handler1.history_handler()->InvokeCallback();
1381
1382   // Verify download request
1383   ASSERT_TRUE(handler1.download_handler()->HasDownload());
1384   EXPECT_EQ(kSourceIconURLs[i].icon_url,
1385             handler1.download_handler()->GetImageUrl());
1386
1387   // Give the scaled download bitmap.
1388   std::vector<int> sizes;
1389   sizes.push_back(kMaximalSize);
1390
1391   handler1.download_handler()->SetImageSizes(sizes);
1392   handler1.download_handler()->InvokeCallback();
1393
1394   // Verify the largest bitmap has been saved into history though it was
1395   // scaled down to maximal size and smaller than icon1 now.
1396   EXPECT_EQ(kSourceIconURLs[i].icon_url, handler1.history_handler()->icon_url_);
1397   EXPECT_EQ(gfx::Size(kMaximalSize, kMaximalSize),
1398             handler1.history_handler()->size_);
1399 }
1400
1401 TEST_F(FaviconHandlerTest, TestKeepDownloadedLargestFavicon) {
1402   const GURL kPageURL("http://www.google.com");
1403
1404   std::vector<gfx::Size> icon1;
1405   icon1.push_back(gfx::Size(16, 16));
1406   const int actual_size1 = 10;
1407
1408   std::vector<gfx::Size> icon2;
1409   icon2.push_back(gfx::Size(15, 15));
1410   const int actual_size2 = 12;
1411
1412   const FaviconURL kSourceIconURLs[] = {
1413       FaviconURL(GURL("http://www.google.com/b"), favicon_base::FAVICON, icon1),
1414       FaviconURL(GURL("http://www.google.com/c"), favicon_base::FAVICON, icon2),
1415       FaviconURL(GURL("http://www.google.com/d"),
1416                  favicon_base::FAVICON,
1417                  std::vector<gfx::Size>())};
1418
1419   TestFaviconDriver driver1;
1420   TestFaviconHandler handler1(kPageURL, &driver1,
1421                               favicon::FaviconHandler::FAVICON, true);
1422   std::vector<FaviconURL> urls1(kSourceIconURLs,
1423                                 kSourceIconURLs + arraysize(kSourceIconURLs));
1424   UpdateFaviconURL(&driver1, &handler1, kPageURL, urls1);
1425   ASSERT_EQ(3u, handler1.urls().size());
1426
1427   // Simulate no favicon from history.
1428   handler1.history_handler()->history_results_.clear();
1429   handler1.history_handler()->InvokeCallback();
1430
1431   // Verify the first icon was request to download
1432   ASSERT_TRUE(handler1.download_handler()->HasDownload());
1433   EXPECT_EQ(kSourceIconURLs[0].icon_url,
1434             handler1.download_handler()->GetImageUrl());
1435
1436   // Give the incorrect size.
1437   std::vector<int> sizes;
1438   sizes.push_back(actual_size1);
1439   handler1.download_handler()->SetImageSizes(sizes);
1440   handler1.download_handler()->InvokeCallback();
1441
1442   // Simulate no favicon from history.
1443   handler1.history_handler()->history_results_.clear();
1444   handler1.history_handler()->InvokeCallback();
1445
1446   // Verify the 2nd icon was request to download
1447   ASSERT_TRUE(handler1.download_handler()->HasDownload());
1448   EXPECT_EQ(kSourceIconURLs[1].icon_url,
1449             handler1.download_handler()->GetImageUrl());
1450
1451   // Very the best candidate is icon1
1452   EXPECT_EQ(kSourceIconURLs[0].icon_url,
1453             handler1.best_favicon_candidate().image_url);
1454   EXPECT_EQ(gfx::Size(actual_size1, actual_size1),
1455             handler1.best_favicon_candidate().image.Size());
1456
1457   // Give the incorrect size.
1458   sizes.clear();
1459   sizes.push_back(actual_size2);
1460   handler1.download_handler()->SetImageSizes(sizes);
1461   handler1.download_handler()->InvokeCallback();
1462
1463   // Verify icon2 has been saved into history.
1464   EXPECT_EQ(kSourceIconURLs[1].icon_url, handler1.history_handler()->icon_url_);
1465   EXPECT_EQ(gfx::Size(actual_size2, actual_size2),
1466             handler1.history_handler()->size_);
1467 }
1468
1469 static KeyedService* BuildFaviconService(content::BrowserContext* context) {
1470   Profile* profile = Profile::FromBrowserContext(context);
1471   return new favicon::FaviconService(
1472       ChromeFaviconClientFactory::GetForProfile(profile),
1473       HistoryServiceFactory::GetForProfile(profile,
1474                                            ServiceAccessType::EXPLICIT_ACCESS));
1475 }
1476
1477 static KeyedService* BuildHistoryService(content::BrowserContext* context) {
1478   return nullptr;
1479 }
1480
1481 // Test that Favicon is not requested repeatedly during the same session if
1482 // server returns HTTP 404 status.
1483 TEST_F(FaviconHandlerTest, UnableToDownloadFavicon) {
1484   const GURL missing_icon_url("http://www.google.com/favicon.ico");
1485   const GURL another_icon_url("http://www.youtube.com/favicon.ico");
1486
1487   Profile* profile = Profile::FromBrowserContext(
1488       web_contents()->GetBrowserContext());
1489
1490   FaviconServiceFactory::GetInstance()->SetTestingFactory(
1491       profile, BuildFaviconService);
1492
1493   HistoryServiceFactory::GetInstance()->SetTestingFactory(
1494       profile, BuildHistoryService);
1495
1496   favicon::FaviconService* favicon_service =
1497       FaviconServiceFactory::GetForProfile(profile,
1498                                            ServiceAccessType::IMPLICIT_ACCESS);
1499
1500   FaviconTabHelper::CreateForWebContents(web_contents());
1501   FaviconTabHelper* favicon_tab_helper =
1502       FaviconTabHelper::FromWebContents(web_contents());
1503
1504   std::vector<SkBitmap> empty_icons;
1505   std::vector<gfx::Size> empty_icon_sizes;
1506   int download_id = 0;
1507
1508   // Try to download missing icon.
1509   download_id = favicon_tab_helper->StartDownload(missing_icon_url, 0);
1510   EXPECT_NE(0, download_id);
1511   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
1512
1513   // Report download failure with HTTP 503 status.
1514   favicon_tab_helper->DidDownloadFavicon(download_id, 503, missing_icon_url,
1515       empty_icons, empty_icon_sizes);
1516   // Icon is not marked as UnableToDownload as HTTP status is not 404.
1517   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
1518
1519   // Try to download again.
1520   download_id = favicon_tab_helper->StartDownload(missing_icon_url, 0);
1521   EXPECT_NE(0, download_id);
1522   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
1523
1524   // Report download failure with HTTP 404 status.
1525   favicon_tab_helper->DidDownloadFavicon(download_id, 404, missing_icon_url,
1526       empty_icons, empty_icon_sizes);
1527   // Icon is marked as UnableToDownload.
1528   EXPECT_TRUE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
1529
1530   // Try to download again.
1531   download_id = favicon_tab_helper->StartDownload(missing_icon_url, 0);
1532   // Download is not started and Icon is still marked as UnableToDownload.
1533   EXPECT_EQ(0, download_id);
1534   EXPECT_TRUE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
1535
1536   // Try to download another icon.
1537   download_id = favicon_tab_helper->StartDownload(another_icon_url, 0);
1538   // Download is started as another icon URL is not same as missing_icon_url.
1539   EXPECT_NE(0, download_id);
1540   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(another_icon_url));
1541
1542   // Clear the list of missing icons.
1543   favicon_service->ClearUnableToDownloadFavicons();
1544   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
1545   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(another_icon_url));
1546
1547   // Try to download again.
1548   download_id = favicon_tab_helper->StartDownload(missing_icon_url, 0);
1549   EXPECT_NE(0, download_id);
1550   // Report download success with HTTP 200 status.
1551   favicon_tab_helper->DidDownloadFavicon(download_id, 200, missing_icon_url,
1552       empty_icons, empty_icon_sizes);
1553   // Icon is not marked as UnableToDownload as HTTP status is not 404.
1554   EXPECT_FALSE(favicon_service->WasUnableToDownloadFavicon(missing_icon_url));
1555 }
1556
1557 class FaviconHandlerActiveFaviconValidityParamTest :
1558       public FaviconHandlerTest,
1559       public ::testing::WithParamInterface<bool> {
1560  public:
1561   FaviconHandlerActiveFaviconValidityParamTest() {}
1562
1563   ~FaviconHandlerActiveFaviconValidityParamTest() override {}
1564
1565   bool GetActiveFaviconValiditySetting() {
1566     return GetParam();
1567   }
1568
1569  private:
1570   DISALLOW_COPY_AND_ASSIGN(FaviconHandlerActiveFaviconValidityParamTest);
1571 };
1572
1573 TEST_P(FaviconHandlerActiveFaviconValidityParamTest,
1574        TestDownloadLargestIconDoesNotImpactActiveFaviconValidity) {
1575   const GURL page_url("http://www.google.com");
1576
1577   std::vector<gfx::Size> one_icon;
1578   one_icon.push_back(gfx::Size(15, 15));
1579
1580   const GURL old_favicon_url("http://www.google.com/old");
1581   const GURL new_favicon_url("http://www.google.com/b");
1582   const FaviconURL source_icon_urls[] = {
1583       FaviconURL(new_favicon_url, favicon_base::FAVICON, one_icon)};
1584   TestFaviconDriver driver1;
1585   TestFaviconHandler handler1(page_url, &driver1,
1586                               favicon::FaviconHandler::FAVICON, true);
1587   std::vector<FaviconURL> urls1(source_icon_urls,
1588                                 source_icon_urls + arraysize(source_icon_urls));
1589   UpdateFaviconURL(&driver1, &handler1, page_url, urls1);
1590
1591   HistoryRequestHandler* history_handler = handler1.history_handler();
1592
1593   // Simulate the active favicon is updated, this shouldn't happen in real
1594   // use case, but we want to verify the behavior below is not impacted by
1595   // accident.
1596   driver1.SetActiveFaviconValidity(GetActiveFaviconValiditySetting());
1597   // Simulate the get favicon from history, but favicon URL didn't match.
1598   SetFaviconRawBitmapResult(old_favicon_url,
1599                             &history_handler->history_results_);
1600   history_handler->InvokeCallback();
1601   // Since we downloaded largest icon, and don't want to set active favicon
1602   // NotifyFaviconAvaliable() should be called with is_active_favicon as false.
1603   EXPECT_EQ(old_favicon_url, driver1.available_icon_url());
1604   EXPECT_FALSE(driver1.update_active_favicon());
1605   EXPECT_EQ(1u, driver1.num_favicon_available());
1606
1607   // We are trying to get favicon from history again.
1608   history_handler = handler1.history_handler();
1609   EXPECT_EQ(new_favicon_url, history_handler->icon_url_);
1610   // Simulate the get expired favicon from history.
1611   history_handler->history_results_.clear();
1612   SetFaviconRawBitmapResult(new_favicon_url, favicon_base::FAVICON, true,
1613                             &history_handler->history_results_);
1614   history_handler->InvokeCallback();
1615   // Since we downloaded largest icon, and don't want to set active favicon
1616   // NotifyFaviconAvaliable() should be called with is_active_favicon as false.
1617   EXPECT_EQ(new_favicon_url, driver1.available_icon_url());
1618   EXPECT_FALSE(driver1.update_active_favicon());
1619   EXPECT_EQ(2u, driver1.num_favicon_available());
1620
1621   // We are trying to download favicon.
1622   DownloadHandler* download_handler = handler1.download_handler();
1623   EXPECT_TRUE(download_handler->HasDownload());
1624   EXPECT_EQ(new_favicon_url, download_handler->GetImageUrl());
1625   // Simulate the download succeed.
1626   download_handler->InvokeCallback();
1627   // Since we downloaded largest icon, and don't want to set active favicon
1628   // NotifyFaviconAvaliable() should be called with is_active_favicon as false.
1629   EXPECT_EQ(new_favicon_url, driver1.available_icon_url());
1630   EXPECT_FALSE(driver1.update_active_favicon());
1631   EXPECT_EQ(3u, driver1.num_favicon_available());
1632 }
1633
1634 INSTANTIATE_TEST_CASE_P(FaviconHandlerTestActiveFaviconValidityTrueOrFalse,
1635                         FaviconHandlerActiveFaviconValidityParamTest,
1636                         ::testing::Bool());
1637
1638 }  // namespace.