Add support to process favicons from Web Manifests

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 <utility>
 #include <vector>
@@ skipping 84 matching lines @@
   for (float favicon_scale : favicon_scales) {
     int edge_size_in_pixel = std::ceil(desired_size_in_dip * favicon_scale);
     auto it = std::find(favicon_sizes.begin(), favicon_sizes.end(),
                         gfx::Size(edge_size_in_pixel, edge_size_in_pixel));
     if (it == favicon_sizes.end())
       return true;
   }
   return false;
 }
 
-// Returns true if at least one of |bitmap_results| is valid.
-bool HasValidResult(
+// Finds a valid bitmap in |bitmap_results| or returns nullptr otherwise.
+const favicon_base::FaviconRawBitmapResult* FindValidResult(
     const std::vector<favicon_base::FaviconRawBitmapResult>& bitmap_results) {
-  return std::find_if(bitmap_results.begin(), bitmap_results.end(), IsValid) !=
-      bitmap_results.end();
+  for (const favicon_base::FaviconRawBitmapResult& result : bitmap_results) {
+    if (IsValid(result))
+      return &result;
+  }
+  return nullptr;
 }
 
 std::vector<int> GetDesiredPixelSizes(
     FaviconDriverObserver::NotificationIconType handler_type) {
   switch (handler_type) {
     case FaviconDriverObserver::NON_TOUCH_16_DIP: {
       std::vector<int> pixel_sizes;
       for (float scale_factor : favicon_base::GetFaviconScales()) {
         pixel_sizes.push_back(
             static_cast<int>(ceil(scale_factor * gfx::kFaviconSize)));
@@ skipping 68 matching lines @@
 }
 
 void FaviconHandler::FetchFavicon(const GURL& url) {
   cancelable_task_tracker_.TryCancelAll();
 
   url_ = url;
 
   initial_history_result_expired_or_incomplete_ = false;
   redownload_icons_ = false;
   got_favicon_from_history_ = false;
-  download_request_.Cancel();
+  manifest_download_request_.Cancel();
+  image_download_request_.Cancel();
+  manifest_url_.reset();
   candidates_.clear();
   notification_icon_url_ = GURL();
   notification_icon_type_ = favicon_base::INVALID_ICON;
   current_candidate_index_ = 0u;
   best_favicon_ = DownloadedFavicon();
 
   // Request the favicon from the history service. In parallel to this the
   // renderer is going to notify us (well WebContents) when the favicon url is
   // available.
   if (service_) {
@@ skipping 27 matching lines @@
            candidates_[current_candidate_index_ + 1].score <=
                best_favicon_.candidate.score;
   } else {
     return best_favicon_.candidate.score == 1;
   }
 }
 
 void FaviconHandler::SetFavicon(const GURL& icon_url,
                                 const gfx::Image& image,
                                 favicon_base::IconType icon_type) {
-  if (service_ && ShouldSaveFavicon())
+  if (service_ && ShouldSaveFavicon()) {
     service_->SetFavicons(url_, icon_url, icon_type, image);
+    // If the icon list was coming from a Web Manifest, let's also store
+    // the association using the manifest's URL as page URL.
+    if (manifest_url_)
+      service_->SetFavicons(*manifest_url_, icon_url, icon_type, image);

[pkotwicz, 2017/04/07 14:13:04]

- We will need to add expiry logic specifically for manifest URLs

- We avoid some of these problems if we use the "manifest URL" as the "icon URL"
instead of the "page URL". For instance, we would not need to call SetFavicons()
twice here. When we use the "manifest URL" as the "page URL" we have to call
FaviconService::SetFavicons() twice. We need to store the "page URL" <-> "image
data" association for the sake of the bookmark page and the history page.

[mastiz, 2017/04/10 15:34:12]

The first argument above is convincing to go for icon URLs, and it'd be good to
document that in the Design Doc. I'll change the implementation.

+  }
 
   NotifyFaviconUpdated(icon_url, icon_type, image);
 }
 
 void FaviconHandler::NotifyFaviconUpdated(
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
   if (favicon_bitmap_results.empty())
     return;
 
@@ skipping 19 matching lines @@
   favicon_base::SetFaviconColorSpace(&image_with_adjusted_colorspace);
 
   delegate_->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(
+void FaviconHandler::OnUpdateCandidates(
     const GURL& page_url,
+    const std::vector<FaviconURL>& candidates,
+    const base::Optional<GURL>& manifest_url) {
+  DCHECK_EQ(page_url, url_);
+
+  manifest_url_ = manifest_url;
+
+  // If no manifest available, proceed with the regular candidates only.
+  if (!manifest_url.has_value()) {
+    OnGotFinalIconURLCandidates(candidates);
+    return;
+  }
+
+  // See if there is a cached favicon for the manifest.
+  service_->GetFaviconForPageURL(
+      *manifest_url, icon_types_, preferred_icon_size(),
+      base::Bind(&FaviconHandler::OnFaviconDataForManifestURLFromFaviconService,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+}
+
+void FaviconHandler::OnGotFinalIconURLCandidates(
     const std::vector<FaviconURL>& candidates) {
-  if (page_url != url_)
-    return;
+  // Mark manifest download as finished, if there was one.
+  manifest_download_request_.Cancel();
 
   std::vector<FaviconCandidate> sorted_candidates;
   const std::vector<int> desired_pixel_sizes =
       GetDesiredPixelSizes(handler_type_);
   for (const FaviconURL& candidate : candidates) {
     if (!candidate.icon_url.is_empty() && (candidate.icon_type & icon_types_)) {
       sorted_candidates.push_back(
           FaviconCandidate::FromFaviconURL(candidate, desired_pixel_sizes));
     }
   }
 
   std::stable_sort(sorted_candidates.begin(), sorted_candidates.end(),
                    &FaviconCandidate::CompareScore);
 
   if (candidates_.size() == sorted_candidates.size() &&
       std::equal(sorted_candidates.begin(), sorted_candidates.end(),
                  candidates_.begin())) {
     return;
   }
 
-  download_request_.Cancel();
+  image_download_request_.Cancel();
   candidates_ = std::move(sorted_candidates);
   current_candidate_index_ = 0u;
   best_favicon_ = DownloadedFavicon();
 
   // TODO(davemoore) Should clear on empty url. Currently we ignore it.
   // This appears to be what FF does as well.
   if (current_candidate() && got_favicon_from_history_)
     OnGotInitialHistoryDataAndIconURLCandidates();
 }
 
 // static
 int FaviconHandler::GetMaximalIconSize(
     FaviconDriverObserver::NotificationIconType handler_type) {
   int max_size = 0;
   for (int size : GetDesiredPixelSizes(handler_type))
     max_size = std::max(max_size, size);
   return max_size;
 }
 
 void FaviconHandler::OnGotInitialHistoryDataAndIconURLCandidates() {
   if (!initial_history_result_expired_or_incomplete_ &&
       current_candidate()->icon_url == notification_icon_url_ &&

[pkotwicz, 2017/04/07 14:13:04]

This check will fail if the database icon URL is from the Web Manifest

[mastiz, 2017/04/10 15:34:12]

Can you please elaborate this? I can see how this would be a problem if we used
the manifest URL as icon URL, but this version actually doesn't.

[pkotwicz, 2017/04/11 03:47:07]

Looks like I was wrong. I was thinking that this check would not work if
OnGotInitialHistoryDataAndIconURLCandidates() is called:
after OnUpdateCandidates() is called
before manifest download completes

However, I see that the candidates are only stored once
OnGotFinalIconURLCandidates() is called

       current_candidate()->icon_type == notification_icon_type_) {
     // - The data from history is valid and not expired.
     // - The icon URL of the history data matches one of the page's icon URLs.
     // - The icon URL of the history data matches the icon URL of the last
     //   OnFaviconAvailable() notification.
     // We are done. No additional downloads or history requests are needed.
     // TODO: Store all of the icon URLs associated with a page in history so
     // that we can check whether the page's icon URLs match the page's icon URLs
     // at the time that the favicon data was stored to the history database.
     return;
   }
 
   DownloadCurrentCandidateOrAskFaviconService();
 }
 
+void FaviconHandler::OnFaviconDataForManifestURLFromFaviconService(
+    const std::vector<favicon_base::FaviconRawBitmapResult>&
+        favicon_bitmap_results) {
+  DCHECK(manifest_download_request_.IsCancelled());
+
+  const favicon_base::FaviconRawBitmapResult* valid_result =
+      FindValidResult(favicon_bitmap_results);
+
+  if (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.
+    NotifyFaviconUpdated(favicon_bitmap_results);
+  }
+
+  if (valid_result && !HasExpiredOrIncompleteResult(preferred_icon_size(),
+                                                    favicon_bitmap_results)) {
+    // Register a direct mapping between the page URL and the icons listed in
+    // the manifest.
+    if (service_ && ShouldSaveFavicon()) {
+      service_->MergeFavicon(url_, {valid_result->icon_url},
+                             valid_result->icon_type, valid_result->bitmap_data,
+                             valid_result->pixel_size);

[pkotwicz, 2017/04/07 14:13:04]

Why are you calling FaviconService::MergeFavicon() instead of
FaviconService::SetFavicons()

If we stored the "manifest URL" as the "icon URL" we would be able to use
FaviconService::UpdateFaviconMappingsAndFetch() to establish the "page URL" <->
"manifest URL" mapping

[mastiz, 2017/04/10 15:34:12]

I could explain why but this is a moot point anyway, unless we get back to using
manifest URLs as page URLs.

+    }
+  } else {
+    manifest_download_request_.Reset(base::Bind(
+        &FaviconHandler::OnGotFinalIconURLCandidates, base::Unretained(this)));
+    delegate_->DownloadManifest(*manifest_url_,
+                                manifest_download_request_.callback());
+  }
+}
+
 void FaviconHandler::OnDidDownloadFavicon(
     favicon_base::IconType icon_type,
     int id,
     int http_status_code,
     const GURL& image_url,
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& original_bitmap_sizes) {
   // Mark download as finished.
-  download_request_.Cancel();
+  image_download_request_.Cancel();
 
   if (bitmaps.empty() && http_status_code == 404) {
     DVLOG(1) << "Failed to Download Favicon:" << image_url;
     if (service_)
       service_->UnableToDownloadFavicon(image_url);
   }
 
   bool request_next_icon = true;
   if (!bitmaps.empty()) {
     float score = 0.0f;
@@ skipping 43 matching lines @@
 }
 
 const std::vector<GURL> FaviconHandler::GetIconURLs() const {
   std::vector<GURL> icon_urls;
   for (const FaviconCandidate& candidate : candidates_)
     icon_urls.push_back(candidate.icon_url);
   return icon_urls;
 }
 
 bool FaviconHandler::HasPendingTasksForTest() {
-  return !download_request_.IsCancelled() ||
+  return !manifest_download_request_.IsCancelled() ||
+         !image_download_request_.IsCancelled() ||
          cancelable_task_tracker_.HasTrackedTasks();
 }
 
 bool FaviconHandler::ShouldSaveFavicon() {
   if (!delegate_->IsOffTheRecord())
     return true;
 
   // Always save favicon if the page is bookmarked.
   return delegate_->IsBookmarked(url_);
 }
 
 void FaviconHandler::OnFaviconDataForInitialURLFromFaviconService(
     const std::vector<favicon_base::FaviconRawBitmapResult>&
         favicon_bitmap_results) {
   got_favicon_from_history_ = true;
-  bool has_valid_result = HasValidResult(favicon_bitmap_results);
+  bool has_valid_result = FindValidResult(favicon_bitmap_results) != nullptr;
   initial_history_result_expired_or_incomplete_ =
       !has_valid_result ||
       HasExpiredOrIncompleteResult(preferred_icon_size(),
                                    favicon_bitmap_results);
   redownload_icons_ = initial_history_result_expired_or_incomplete_ &&
                       !favicon_bitmap_results.empty();
 
   if (has_valid_result && (!current_candidate() ||
                            DoUrlsAndIconsMatch(current_candidate()->icon_url,
                                                current_candidate()->icon_type,
@@ skipping 37 matching lines @@
           url_, {icon_url}, icon_type, preferred_icon_size(),
           base::Bind(&FaviconHandler::OnFaviconData, base::Unretained(this)),
           &cancelable_task_tracker_);
     }
   }
 }
 
 void FaviconHandler::OnFaviconData(const std::vector<
     favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results) {
   bool has_results = !favicon_bitmap_results.empty();
-  bool has_valid_result = HasValidResult(favicon_bitmap_results);
+  const favicon_base::FaviconRawBitmapResult* valid_result =
+      FindValidResult(favicon_bitmap_results);
   bool has_expired_or_incomplete_result =
-      !has_valid_result || HasExpiredOrIncompleteResult(preferred_icon_size(),
-                                                        favicon_bitmap_results);
+      !valid_result || HasExpiredOrIncompleteResult(preferred_icon_size(),
+                                                    favicon_bitmap_results);
 
-  if (has_valid_result) {
+  if (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.
     NotifyFaviconUpdated(favicon_bitmap_results);
+    // If a manifest is being used, let's also store the association using the
+    // manifest's URL as page URL.
+    if (manifest_url_ && service_ && ShouldSaveFavicon()) {
+      service_->MergeFavicon(*manifest_url_, {valid_result->icon_url},
+                             valid_result->icon_type, valid_result->bitmap_data,
+                             valid_result->pixel_size);
+    }
   }
 
   if (!current_candidate() ||
       (has_results && !DoUrlsAndIconsMatch(current_candidate()->icon_url,
                                            current_candidate()->icon_type,
                                            favicon_bitmap_results))) {
     // The icon URLs have been updated since the favicon data was requested.
     return;
   }
 
   if (has_expired_or_incomplete_result) {
     ScheduleDownload(current_candidate()->icon_url,
                      current_candidate()->icon_type);
   }
 }
 
 void FaviconHandler::ScheduleDownload(const GURL& image_url,
                                       favicon_base::IconType icon_type) {
   DCHECK(image_url.is_valid());
   // Note that CancelableCallback starts cancelled.
-  DCHECK(download_request_.IsCancelled()) << "More than one ongoing download";
+  DCHECK(image_download_request_.IsCancelled())
+      << "More than one ongoing download";
   if (service_ && service_->WasUnableToDownloadFavicon(image_url)) {
     DVLOG(1) << "Skip Failed FavIcon: " << image_url;
     OnDidDownloadFavicon(icon_type, 0, 0, image_url, std::vector<SkBitmap>(),
                          std::vector<gfx::Size>());
     return;
   }
-  download_request_.Reset(base::Bind(&FaviconHandler::OnDidDownloadFavicon,
-                                     base::Unretained(this), icon_type));
+  image_download_request_.Reset(
+      base::Bind(&FaviconHandler::OnDidDownloadFavicon, base::Unretained(this),
+                 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 =
       delegate_->DownloadImage(image_url, GetMaximalIconSize(handler_type_),
-                               download_request_.callback());
+                               image_download_request_.callback());
   DCHECK_NE(download_id, 0);
 }
 
 }  // namespace favicon