Prioritize smaller favicons over larger ones for tabs, etc.

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 "build/build_config.h"
 
 #include <vector>
 
@@ skipping 33 matching lines @@
 
 bool DoUrlAndIconMatch(const FaviconURL& favicon_url,
                        const GURL& url,
                        history::IconType icon_type) {
   return favicon_url.icon_url == url &&
       favicon_url.icon_type == static_cast<FaviconURL::IconType>(icon_type);
 }
 
 }  // namespace
 
+////////////////////////////////////////////////////////////////////////////////
+
 FaviconHandler::DownloadRequest::DownloadRequest()
     : icon_type(history::INVALID_ICON) {
 }
 
 FaviconHandler::DownloadRequest::~DownloadRequest() {
 }
 
 FaviconHandler::DownloadRequest::DownloadRequest(
     const GURL& url,
     const GURL& image_url,
     const FaviconTabHelper::ImageDownloadCallback& callback,
     history::IconType icon_type)
     : url(url),
       image_url(image_url),
       callback(callback),
       icon_type(icon_type) {
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
+FaviconHandler::FaviconCandidate::FaviconCandidate()
+    : icon_type(history::INVALID_ICON) {
+}
+
+FaviconHandler::FaviconCandidate::~FaviconCandidate() {
+}
+
+FaviconHandler::FaviconCandidate::FaviconCandidate(
+    const GURL& url,
+    const GURL& image_url,
+    const gfx::Image& image,
+    const SkBitmap& bitmap,
+    history::IconType icon_type)
+    : url(url),
+      image_url(image_url),
+      image(image),
+      bitmap(bitmap),
+      icon_type(icon_type) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 FaviconHandler::FaviconHandler(Profile* profile,
                                FaviconHandlerDelegate* delegate,
                                Type icon_type)
     : got_favicon_from_history_(false),
       favicon_expired_(false),
       icon_types_(icon_type == FAVICON ? history::FAVICON :
           history::TOUCH_ICON | history::TOUCH_PRECOMPOSED_ICON),
-      current_url_index_(0),
       profile_(profile),
       delegate_(delegate) {
   DCHECK(profile_);
   DCHECK(delegate_);
 }
 
 FaviconHandler::~FaviconHandler() {
   // Call pending download callbacks with error to allow caller to clean up.
   for (DownloadRequests::iterator i = download_requests_.begin();
        i != download_requests_.end(); ++i) {
     if (!i->second.callback.is_null()) {
       i->second.callback.Run(i->first, true, SkBitmap());
     }
   }
 }
 
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_consumer_.CancelAllRequests();
 
   url_ = url;
 
   favicon_expired_ = got_favicon_from_history_ = false;
-  current_url_index_ = 0;
-  urls_.clear();
 
   // Request the favicon from the history service. In parallel to this the
   // renderer is going to notify us (well TabContents) when the favicon url is
   // available.
   if (GetFaviconService()) {
     GetFaviconForURL(url_, icon_types_, &cancelable_consumer_,
         base::Bind(&FaviconHandler::OnFaviconDataForInitialURL,
                    base::Unretained(this)));
   }
 }
 
 int FaviconHandler::DownloadImage(
     const GURL& image_url,
     int image_size,
     history::IconType icon_type,
     const FaviconTabHelper::ImageDownloadCallback& callback) {
   return ScheduleDownload(GURL(), image_url, image_size, icon_type, callback);
 }
 
 FaviconService* FaviconHandler::GetFaviconService() {
   return profile_->GetFaviconService(Profile::EXPLICIT_ACCESS);
 }
 
+bool FaviconHandler::UpdateFaviconCandidate(const GURL& url,
+                                            const GURL& image_url,
+                                            const gfx::Image& image,
+                                            history::IconType icon_type) {
+  bool update_candidate = false;
+  bool exact_match = false;
+  SkBitmap bitmap = *(image.ToSkBitmap());
+  if (preferred_icon_size() == 0) {
+    update_candidate = true;
+    exact_match = true;
+  } else if (favicon_candidate_.icon_type == history::INVALID_ICON) {
+    // No current candidate, use this.
+    update_candidate = true;
+  } else {
+    int bitmap_size = std::max(bitmap.width(), bitmap.height());
+    if (bitmap_size == preferred_icon_size()) {
+      // Exact match, use this.
+      update_candidate = true;
+      exact_match = true;
+    } else {
+      // Compare against current candidate.
+      int cur_size = std::max(favicon_candidate_.bitmap.width(),
+                              favicon_candidate_.bitmap.height());
+      if ((bitmap_size >= preferred_icon_size() && bitmap_size < cur_size) ||
+          (cur_size < preferred_icon_size() && bitmap_size > cur_size)) {
+        update_candidate = true;
+      }
+    }
+  }
+  if (update_candidate) {
+    favicon_candidate_ = FaviconCandidate(
+        url, image_url, image, bitmap, icon_type);
+  }
+  return exact_match;
+}
+
 void FaviconHandler::SetFavicon(
     const GURL& url,
     const GURL& image_url,
     const gfx::Image& image,
+    const SkBitmap& bitmap,
     history::IconType icon_type) {
-  const SkBitmap& bitmap = image;
   const gfx::Image& sized_image = (preferred_icon_size() == 0 ||
       (preferred_icon_size() == bitmap.width() &&
        preferred_icon_size() == bitmap.height())) ?
       image : ResizeFaviconIfNeeded(image);
 
   if (GetFaviconService() && ShouldSaveFavicon(url)) {
     std::vector<unsigned char> image_data;
     if (gfx::PNGEncodedDataFromImage(sized_image, &image_data))
       SetHistoryFavicon(url, image_url, image_data, icon_type);
   }
 
   if (url == url_ && icon_type == history::FAVICON) {
     NavigationEntry* entry = GetEntry();
-    if (entry)
+    if (entry) {
+      entry->GetFavicon().url = image_url;
       UpdateFavicon(entry, &sized_image);
+    }
   }
 }
 
 void FaviconHandler::UpdateFavicon(NavigationEntry* entry,
                                    scoped_refptr<RefCountedMemory> data) {
   scoped_ptr<gfx::Image> image(gfx::ImageFromPNGEncodedData(data->front(),
                                                             data->size()));
   UpdateFavicon(entry, image.get());
 }
 
 void FaviconHandler::UpdateFavicon(NavigationEntry* entry,
                                    const gfx::Image* image) {
   // No matter what happens, we need to mark the favicon as being set.
   entry->GetFavicon().valid = true;
 
   if (!image)
     return;
 
   entry->GetFavicon().bitmap = *image;
   delegate_->NotifyFaviconUpdated();
 }
 
 void FaviconHandler::OnUpdateFaviconURL(

[sky, 2012/03/19 20:34:56]

I'm pretty sure that the page can trigger this to be invoked via javascript. Is
that going to be problematic?

[stevenjb, 2012/03/19 20:48:26]

As long as this is always getting called with a complete set of urls, this
should be fine. If we were in the middle of updating (i.e. image_urls_ is not
empty and we are waiting for a callback), we will start over with the new list.
When OnDidDownloadFavicon() gets called with the stale url, the call to
DoUrlAndIconMatch() will fail and that data will be ignored.

Put another way, every call to OnUpdateFaviconURL() will generate a new complete
list of urls to consider, and the closest match from that list will be used. 

     int32 page_id,
     const std::vector<FaviconURL>& candidates) {
-  NavigationEntry* entry = GetEntry();
-  if (!entry)
-    return;
 
-  bool got_favicon_url_update = false;
+  image_urls_.clear();
+  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_)) {
-      if (!got_favicon_url_update) {
-        got_favicon_url_update = true;
-        urls_.clear();
-        current_url_index_ = 0;
-      }
-      urls_.push_back(*i);
-    }
+    if (!i->icon_url.is_empty() && (i->icon_type & icon_types_))
+      image_urls_.push_back(*i);
   }
 
   // TODO(davemoore) Should clear on empty url. Currently we ignore it.
   // This appears to be what FF does as well.
-  // No URL was added.
-  if (!got_favicon_url_update)
+  if (image_urls_.empty())
     return;
 
   if (!GetFaviconService())
     return;
 
+  ProcessCurrentUrl();
+}
+
+void FaviconHandler::ProcessCurrentUrl() {
+  DCHECK(!image_urls_.empty());
+
+  NavigationEntry* entry = GetEntry();
+  if (!entry)
+    return;
+
   // For FAVICON.
   if (current_candidate()->icon_type == FaviconURL::FAVICON) {
     if (!favicon_expired_ && entry->GetFavicon().valid &&
         DoUrlAndIconMatch(*current_candidate(), entry->GetFavicon().url,
                           history::FAVICON))
       return;
 
     entry->GetFavicon().url = current_candidate()->icon_url;
   } else if (!favicon_expired_ && got_favicon_from_history_ &&
               history_icon_.is_valid() &&
@@ skipping 19 matching lines @@
     return;
   }
 
   if (!i->second.callback.is_null()) {
     i->second.callback.Run(id, errored, *(&image));
   } else if (current_candidate() &&
              DoUrlAndIconMatch(*current_candidate(), image_url,
                                i->second.icon_type)) {
     // The downloaded icon is still valid when there is no FaviconURL update
     // during the downloading.
+    bool request_next_icon = true;
     if (!errored) {
-      SetFavicon(i->second.url, image_url, image, i->second.icon_type);
-    } else if (GetEntry() && ++current_url_index_ < urls_.size()) {
-      // Copies all candidate except first one and notifies the FaviconHandler,
-      // so the next candidate can be processed.
-      std::vector<FaviconURL> new_candidates(urls_.begin() + 1, urls_.end());
-      OnUpdateFaviconURL(0, new_candidates);
+      request_next_icon = !UpdateFaviconCandidate(
+          i->second.url, image_url, image, i->second.icon_type);
+    }
+    if (request_next_icon && GetEntry() && image_urls_.size() > 1) {
+      // Remove the first member of image_urls_ and process the remaining.
+      image_urls_.pop_front();
+      ProcessCurrentUrl();
+    } else if (favicon_candidate_.icon_type != history::INVALID_ICON) {
+      // No more icons to request, set the favicon from the candidate.
+      SetFavicon(favicon_candidate_.url, favicon_candidate_.image_url,
+                 favicon_candidate_.image, favicon_candidate_.bitmap,
+                 favicon_candidate_.icon_type);
+      // Reset candidate.
+      favicon_candidate_ = FaviconCandidate();
     }
   }
   download_requests_.erase(i);
 }
 
 NavigationEntry* FaviconHandler::GetEntry() {
   NavigationEntry* entry = delegate_->GetActiveEntry();
   if (entry && entry->GetURL() == url_)
     return entry;
 
@@ skipping 195 matching lines @@
   int height = bitmap.height();
   if (width > 0 && height > 0) {
     gfx::CalculateFaviconTargetSize(&width, &height);
     return gfx::Image(skia::ImageOperations::Resize(
                           bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
                           width, height));
   }
 
   return image;
 }