Refactor FaviconDriver::OnFaviconAvailable()

components/favicon/core/favicon_handler.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 <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 192 matching lines @@
     const gfx::Image& image,
     float score,
     favicon_base::IconType icon_type)
     : image_url(image_url),
       image(image),
       score(score),
       icon_type(icon_type) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 
-FaviconHandler::FaviconHandler(FaviconService* service,
-                               FaviconDriver* driver,
-                               Type handler_type)
-    : got_favicon_from_history_(false),
+FaviconHandler::FaviconHandler(
+    FaviconService* service,
+    FaviconDriver* driver,
+    FaviconDriverObserver::NotificationIconType handler_type)
+    : handler_type_(handler_type),
+      got_favicon_from_history_(false),
       initial_history_result_expired_or_incomplete_(false),
       redownload_icons_(false),
       icon_types_(FaviconHandler::GetIconTypesFromHandlerType(handler_type)),
-      download_largest_icon_(handler_type == LARGEST_FAVICON ||
-                             handler_type == LARGEST_TOUCH),
+      download_largest_icon_(
+          handler_type == FaviconDriverObserver::NON_TOUCH_LARGEST ||
+          handler_type == FaviconDriverObserver::TOUCH_LARGEST),
       notification_icon_type_(favicon_base::INVALID_ICON),
       service_(service),
       driver_(driver),
       current_candidate_index_(0u) {
   DCHECK(driver_);
 }
 
 FaviconHandler::~FaviconHandler() {
 }
 
 // static
 int FaviconHandler::GetIconTypesFromHandlerType(
-    FaviconHandler::Type handler_type) {
+    FaviconDriverObserver::NotificationIconType handler_type) {
   switch (handler_type) {
-    case FAVICON:
-    case LARGEST_FAVICON:
+    case FaviconDriverObserver::NON_TOUCH_16_DIP:
+    case FaviconDriverObserver::NON_TOUCH_LARGEST:
       return favicon_base::FAVICON;
-    case LARGEST_TOUCH:
+    case FaviconDriverObserver::TOUCH_LARGEST:
       return favicon_base::TOUCH_ICON | favicon_base::TOUCH_PRECOMPOSED_ICON;
   }
   return 0;
 }
 
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_task_tracker_.TryCancelAll();
 
   url_ = url;
 
@@ skipping 63 matching lines @@
   }
   return exact_match;
 }
 
 void FaviconHandler::SetFavicon(const GURL& icon_url,
                                 const gfx::Image& image,
                                 favicon_base::IconType icon_type) {
   if (ShouldSaveFavicon())
     SetHistoryFavicons(url_, icon_url, icon_type, image);
 
-  NotifyFaviconAvailable(icon_url, icon_type, image);
+  NotifyFaviconUpdated(icon_url, icon_type, image);
 }
 
-void FaviconHandler::NotifyFaviconAvailable(
+void FaviconHandler::NotifyFaviconUpdated(
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
   if (favicon_bitmap_results.empty())
     return;
 
   gfx::Image resized_image = favicon_base::SelectFaviconFramesFromPNGs(
       favicon_bitmap_results,
       favicon_base::GetFaviconScales(),
       preferred_icon_size());
   // The history service sends back results for a single icon URL and icon
   // type, so it does not matter which result we get |icon_url| and |icon_type|
   // from.
   const GURL icon_url = favicon_bitmap_results[0].icon_url;
   favicon_base::IconType icon_type = favicon_bitmap_results[0].icon_type;
-  NotifyFaviconAvailable(icon_url, icon_type, resized_image);
+  NotifyFaviconUpdated(icon_url, icon_type, resized_image);
 }
 
-void FaviconHandler::NotifyFaviconAvailable(const GURL& icon_url,
-                                            favicon_base::IconType icon_type,
-                                            const gfx::Image& image) {
+void FaviconHandler::NotifyFaviconUpdated(const GURL& icon_url,
+                                          favicon_base::IconType icon_type,
+                                          const gfx::Image& image) {
+  if (image.IsEmpty())

[sky, 2015/11/20 00:44:26]

Are you sure no one needs to distinguish if only an empty icon was provided?

+    return;
+
   gfx::Image image_with_adjusted_colorspace = image;
   favicon_base::SetFaviconColorSpace(&image_with_adjusted_colorspace);
 
-  bool is_active_favicon = !download_largest_icon_;
-
-  driver_->OnFaviconAvailable(
-      url_, icon_url, image_with_adjusted_colorspace, is_active_favicon);
+  driver_->OnFaviconUpdated(url_, handler_type_, icon_url,
+                            icon_url != notification_icon_url_,
+                            image_with_adjusted_colorspace);
 
   notification_icon_url_ = icon_url;
   notification_icon_type_ = icon_type;
 }
 
 void FaviconHandler::OnUpdateFaviconURL(
     const GURL& page_url,
     const std::vector<FaviconURL>& candidates) {
   if (page_url != url_)
     return;
@@ skipping 218 matching lines @@
   redownload_icons_ = initial_history_result_expired_or_incomplete_ &&
                       !favicon_bitmap_results.empty();
 
   if (has_valid_result &&
       (!current_candidate() ||
        DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results))) {
     // The db knows the favicon (although it may be out of date) and the entry
     // doesn't have an icon. Set the favicon now, and if the favicon turns out
     // to be expired (or the wrong url) we'll fetch later on. This way the
     // user doesn't see a flash of the default favicon.
-
-    NotifyFaviconAvailable(favicon_bitmap_results);
+    NotifyFaviconUpdated(favicon_bitmap_results);
   }
 
   if (current_candidate())
     OnGotInitialHistoryDataAndIconURLCandidates();
 }
 
 void FaviconHandler::DownloadCurrentCandidateOrAskFaviconService() {
   GURL icon_url = current_candidate()->icon_url;
   favicon_base::IconType icon_type = current_candidate()->icon_type;
 
@@ skipping 29 matching lines @@
   bool has_valid_result = HasValidResult(favicon_bitmap_results);
   bool has_expired_or_incomplete_result =
       !has_valid_result || HasExpiredOrIncompleteResult(preferred_icon_size(),
                                                         favicon_bitmap_results);
 
   if (has_valid_result) {
     // There is a valid favicon. Notify any observers. It is useful to notify
     // the observers even if the favicon is expired or incomplete (incorrect
     // size) because temporarily showing the user an expired favicon or
     // streched favicon is preferable to showing the user the default favicon.
-    NotifyFaviconAvailable(favicon_bitmap_results);
+    NotifyFaviconUpdated(favicon_bitmap_results);
   }
 
   if (!current_candidate() ||
       (has_results &&
        !DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results))) {
     // The icon URLs have been updated since the favicon data was requested.
     return;
   }
 
   if (has_expired_or_incomplete_result) {
@@ skipping 18 matching lines @@
     // If DownloadFavicon() did not start a download, it returns a download id
     // of 0. We still need to call OnDidDownloadFavicon() because the method is
     // responsible for initiating the data request for the next candidate.
     OnDidDownloadFavicon(download_id, image_url, std::vector<SkBitmap>(),
                          std::vector<gfx::Size>());
 
   }
 }
 
 }  // namespace favicon