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())
+  if (UrlMatches(url, url_) && !PageChangedSinceFaviconWasRequested()) {
+    if (icon_type == favicon_base::FAVICON && !download_largest_icon_)
       SetFaviconOnActivePage(icon_url, image);
+    if (!image.IsEmpty())
+      NotifyFaviconUpdated(icon_url);

[sky, 2014/10/29 15:50:55]

Sorry, this is wrong. We shouldn't need the invalidate anything if the favicon
hasn't changed. Who is listening for the changes that needs that you need to
update? Seems like they should instead be listening for history change, if that
is what they care about, right?

   }
 }
 
 void FaviconHandler::SetFaviconOnActivePage(const std::vector<
     favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
   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);
 }
 
 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;
 
   gfx::Image image_with_adjusted_colorspace = image;
   favicon_base::SetFaviconColorSpace(&image_with_adjusted_colorspace);
 
   driver_->SetActiveFaviconImage(image_with_adjusted_colorspace);
-  NotifyFaviconUpdated(icon_url_changed);
 }
 
 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) {
+void FaviconHandler::NotifyFaviconUpdated(const GURL& icon_url) {
+  bool icon_url_changed = false;
+  if (icon_types_ == favicon_base::FAVICON) {
+    icon_url_changed = driver_->GetActiveFaviconURL() != icon_url;
+  } else {
+    icon_url_changed = icon_url != notified_touch_icon_url_;
+    notified_touch_icon_url_ = icon_url;
+  }
   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;
@@ skipping 20 matching lines @@
       preferred_icon_size(), 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)) {
       // 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);
+      if (!download_largest_icon_)
+        SetFaviconOnActivePage(favicon_bitmap_results);
+      NotifyFaviconUpdated(favicon_bitmap_results[0].icon_url);
     } 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.
+
+  // Notify the TOUCH_ICON or TOUCH_PRECOMPOSED_ICON available in
+  // HistoryBackend.
+  if (icon_types_ != favicon_base::FAVICON &&
+      HasValidResult(favicon_bitmap_results)) {
+    NotifyFaviconUpdated(favicon_bitmap_results[0].icon_url);
+  }

[michaelbai, 2014/10/29 04:30:32]

I just simply added code here because this is touch icon specific and will be
deleted when we remove the icon type concept.

 }
 
 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 26 matching lines @@
 
   bool has_results = !favicon_bitmap_results.empty();
   bool has_expired_or_incomplete_result = HasExpiredOrIncompleteResult(
       preferred_icon_size(), favicon_bitmap_results);
 
   if (has_results && icon_types_ == favicon_base::FAVICON) {
     if (HasValidResult(favicon_bitmap_results)) {
       // 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);
+      if (!download_largest_icon_)
+        SetFaviconOnActivePage(favicon_bitmap_results);
+      NotifyFaviconUpdated(favicon_bitmap_results[0].icon_url);
     }
     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);
   }
+  // Notify the TOUCH_ICON or TOUCH_PRECOMPOSED_ICON available in
+  // HistoryBackend.
+  if (icon_types_ != favicon_base::FAVICON &&
+      HasValidResult(favicon_bitmap_results)) {
+    NotifyFaviconUpdated(favicon_bitmap_results[0].icon_url);
+  }
   history_results_ = favicon_bitmap_results;
 }
 
 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,
@@ skipping 14 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);
 }