Add Observer in FaviconTabHelper

chrome/browser/favicon/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 "chrome/browser/favicon/favicon_handler.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 270 matching lines @@
   return exact_match;
 }
 
 void FaviconHandler::SetFavicon(const GURL& url,
                                 const GURL& icon_url,
                                 const gfx::Image& image,
                                 favicon_base::IconType icon_type) {
   if (client_->GetFaviconService() && ShouldSaveFavicon(url))
     SetHistoryFavicons(url, icon_url, icon_type, image);
 
-  if (UrlMatches(url, url_) && icon_type == favicon_base::FAVICON) {
-    if (!PageChangedSinceFaviconWasRequested())
-      SetFaviconOnActivePage(icon_url, image);
-  }
+  if (!UrlMatches(url, url_) || PageChangedSinceFaviconWasRequested())
+    return;
+
+  NotifyFaviconAvailable(
+      icon_url,
+      image,
+      icon_type == favicon_base::FAVICON && !download_largest_icon_);
 }
 
-void FaviconHandler::SetFaviconOnActivePage(const std::vector<
-    favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
+void FaviconHandler::NotifyFaviconAvailable(
+    const std::vector<favicon_base::FaviconRawBitmapResult>&
+        favicon_bitmap_results,
+    bool update_active_favicon) {
   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, so it does
   // not matter which result we get the |icon_url| from.
   const GURL icon_url = favicon_bitmap_results.empty() ?
       GURL() : favicon_bitmap_results[0].icon_url;
-  SetFaviconOnActivePage(icon_url, resized_image);
+  NotifyFaviconAvailable(icon_url, resized_image, update_active_favicon);
 }
 
-void FaviconHandler::SetFaviconOnActivePage(const GURL& icon_url,
-                                            const gfx::Image& image) {
-  // No matter what happens, we need to mark the favicon as being set.
-  driver_->SetActiveFaviconValidity(true);
-
-  bool icon_url_changed = driver_->GetActiveFaviconURL() != icon_url;
-  driver_->SetActiveFaviconURL(icon_url);
-
-  if (image.IsEmpty())
-    return;
-
+void FaviconHandler::NotifyFaviconAvailable(const GURL& icon_url,
+                                            const gfx::Image& image,
+                                            bool update_active_favicon) {
   gfx::Image image_with_adjusted_colorspace = image;
   favicon_base::SetFaviconColorSpace(&image_with_adjusted_colorspace);
 
-  driver_->SetActiveFaviconImage(image_with_adjusted_colorspace);
-  NotifyFaviconUpdated(icon_url_changed);
+  driver_->OnFaviconAvailable(
+      image_with_adjusted_colorspace, icon_url, update_active_favicon);
 }
 
 void FaviconHandler::OnUpdateFaviconURL(
     const std::vector<FaviconURL>& candidates) {
   image_urls_.clear();
   best_favicon_candidate_ = FaviconCandidate();
   for (std::vector<FaviconURL>::const_iterator i = candidates.begin();
        i != candidates.end(); ++i) {
     if (!i->icon_url.is_empty() && (i->icon_type & icon_types_))
       image_urls_.push_back(*i);
@@ skipping 167 matching lines @@
 }
 
 bool FaviconHandler::ShouldSaveFavicon(const GURL& url) {
   if (!driver_->IsOffTheRecord())
     return true;
 
   // Otherwise store the favicon if the page is bookmarked.
   return client_->IsBookmarked(url);
 }
 
-void FaviconHandler::NotifyFaviconUpdated(bool icon_url_changed) {
-  driver_->NotifyFaviconUpdated(icon_url_changed);
-}
-
 int FaviconHandler::GetMaximalIconSize(favicon_base::IconType icon_type) {
   switch (icon_type) {
     case favicon_base::FAVICON:
 #if defined(OS_ANDROID)
       return 192;
 #else
       return gfx::ImageSkia::GetMaxSupportedScale() * gfx::kFaviconSize;
 #endif
     case favicon_base::TOUCH_ICON:
     case favicon_base::TOUCH_PRECOMPOSED_ICON:
       return kTouchIconSize;
     case favicon_base::INVALID_ICON:
       return 0;
   }
   NOTREACHED();
   return 0;
 }
 
 void FaviconHandler::OnFaviconDataForInitialURLFromFaviconService(
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
   if (PageChangedSinceFaviconWasRequested())
     return;
   got_favicon_from_history_ = true;
   history_results_ = favicon_bitmap_results;
   bool has_results = !favicon_bitmap_results.empty();
   favicon_expired_or_incomplete_ = has_results && HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
+  bool has_valid_result = HasValidResult(favicon_bitmap_results);
+
   if (has_results && icon_types_ == favicon_base::FAVICON &&
       !driver_->GetActiveFaviconValidity() &&
       (!current_candidate() ||
        DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results))) {
-    if (HasValidResult(favicon_bitmap_results)) {
+    if (has_valid_result) {
       // 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.
-      SetFaviconOnActivePage(favicon_bitmap_results);
+      NotifyFaviconAvailable(favicon_bitmap_results, !download_largest_icon_);
     } else {
       // If |favicon_bitmap_results| does not have any valid results, treat the
       // favicon as if it's expired.
       // TODO(pkotwicz): Do something better.
       favicon_expired_or_incomplete_ = true;
     }
   }
   if (has_results && !favicon_expired_or_incomplete_) {
     if (current_candidate() &&
         !DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)) {
       // Mapping in the database is wrong. DownloadFavIconOrAskHistory will
       // update the mapping for this url and download the favicon if we don't
       // already have it.
       DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
                                          current_candidate()->icon_url,
                                          current_candidate()->icon_type);
     }
   } else if (current_candidate()) {
     // We know the official url for the favicon, but either don't have the
     // favicon or it's expired. Continue on to DownloadFaviconOrAskHistory to
     // either download or check history again.
     DownloadFaviconOrAskFaviconService(driver_->GetActiveURL(),
                                        current_candidate()->icon_url,
                                        current_candidate()->icon_type);
   }
   // else we haven't got the icon url. When we get it we'll ask the
   // renderer to download the icon.
+
+  if (has_valid_result && icon_types_ != favicon_base::FAVICON)
+    NotifyFaviconAvailable(favicon_bitmap_results, false);
 }
 
 void FaviconHandler::DownloadFaviconOrAskFaviconService(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type) {
   if (favicon_expired_or_incomplete_) {
     // We have the mapping, but the favicon is out of date. Download it now.
     ScheduleDownload(page_url, icon_url, icon_type);
   } else if (client_->GetFaviconService()) {
@@ skipping 20 matching lines @@
 }
 
 void FaviconHandler::OnFaviconData(const std::vector<
     favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
   if (PageChangedSinceFaviconWasRequested())
     return;
 
   bool has_results = !favicon_bitmap_results.empty();
   bool has_expired_or_incomplete_result = HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
+  bool has_valid_result = HasValidResult(favicon_bitmap_results);
 
   if (has_results && icon_types_ == favicon_base::FAVICON) {
-    if (HasValidResult(favicon_bitmap_results)) {
+    if (has_valid_result) {
       // There is a favicon, set it now. If expired we'll download the current
       // one again, but at least the user will get some icon instead of the
       // default and most likely the current one is fine anyway.
-      SetFaviconOnActivePage(favicon_bitmap_results);
+      NotifyFaviconAvailable(favicon_bitmap_results, !download_largest_icon_);
     }
     if (has_expired_or_incomplete_result) {
       // The favicon is out of date. Request the current one.
       ScheduleDownload(driver_->GetActiveURL(),
                        driver_->GetActiveFaviconURL(),
                        favicon_base::FAVICON);
     }
   } else if (current_candidate() &&
       (!has_results || has_expired_or_incomplete_result ||
        !(DoUrlsAndIconsMatch(*current_candidate(), favicon_bitmap_results)))) {
     // We don't know the favicon, it is out of date or its type is not same as
     // one got from page. Request the current one.
     ScheduleDownload(driver_->GetActiveURL(),
                      current_candidate()->icon_url,
                      current_candidate()->icon_type);
   }
   history_results_ = favicon_bitmap_results;
+
+  if (has_valid_result && icon_types_ != favicon_base::FAVICON)
+    NotifyFaviconAvailable(favicon_bitmap_results, false);
 }
 
 int FaviconHandler::ScheduleDownload(const GURL& url,
                                      const GURL& image_url,
                                      favicon_base::IconType icon_type) {
   // A max bitmap size is specified to avoid receiving huge bitmaps in
   // OnDidDownloadFavicon(). See FaviconDriver::StartDownload()
   // for more details about the max bitmap size.
   const int download_id = DownloadFavicon(image_url,
                                           GetMaximalIconSize(icon_type));
@@ skipping 13 matching lines @@
     if (i->icon_sizes.empty())
       continue;
 
     gfx::Size largest = i->icon_sizes[GetLargestSizeIndex(i->icon_sizes)];
     i->icon_sizes.clear();
     i->icon_sizes.push_back(largest);
   }
   std::stable_sort(image_urls_.begin(), image_urls_.end(),
                    CompareIconSize);
 }