Add support to process favicons from Web Manifests

components/favicon/core/favicon_handler.h

 // 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.
 
 #ifndef COMPONENTS_FAVICON_CORE_FAVICON_HANDLER_H_
 #define COMPONENTS_FAVICON_CORE_FAVICON_HANDLER_H_
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/cancelable_callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/optional.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "components/favicon/core/favicon_driver_observer.h"
 #include "components/favicon/core/favicon_url.h"
 #include "components/favicon_base/favicon_callback.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image.h"
 #include "url/gurl.h"
 
 class SkBitmap;
 
+namespace base {
+struct Feature;
+}  // namespace base
+
 namespace favicon {
 
 class FaviconService;
 
+extern const base::Feature kFaviconsFromWebManifest;
+
 // FaviconHandler works with FaviconDriver to fetch the specific type of
 // favicon.
 //
 // FetchFavicon requests the favicon from the favicon service which in turn
 // requests the favicon from the history database. At this point
 // we only know the URL of the page, and not necessarily the url of the
 // favicon. To ensure we handle reloading stale favicons as well as
 // reloading a favicon on page reload we always request the favicon from
 // history regardless of whether the active favicon is valid.
 //
@@ skipping 52 matching lines @@
    public:
     // Mimics WebContents::ImageDownloadCallback.
     typedef base::Callback<void(
         int id,
         int status_code,
         const GURL& image_url,
         const std::vector<SkBitmap>& bitmaps,
         const std::vector<gfx::Size>& original_bitmap_sizes)>
         ImageDownloadCallback;
 
+    typedef base::Callback<void(
+        const std::vector<favicon::FaviconURL>& favicons)>
+        ManifestDownloadCallback;
+
     // Starts the download for the given favicon. When finished, the callback
     // is called with the results. Returns the unique id of the download
     // request, which will also be passed to the callback. In case of error, 0
     // is returned and no callback will be called.
     // Bitmaps with pixel sizes larger than |max_bitmap_size| are filtered out
     // from the bitmap results. If there are no bitmap results <=
     // |max_bitmap_size|, the smallest bitmap is resized to |max_bitmap_size|
     // and is the only result. A |max_bitmap_size| of 0 means unlimited.
     virtual int DownloadImage(const GURL& url,
                               int max_image_size,
                               ImageDownloadCallback callback) = 0;
 
+    // Downloads a WebManifest and returns the favicons listed there.
+    virtual void DownloadManifest(const GURL& url,
+                                  ManifestDownloadCallback callback) = 0;
+
     // Returns whether the user is operating in an off-the-record context.
     virtual bool IsOffTheRecord() = 0;
 
     // Returns whether |url| is bookmarked.
     virtual bool IsBookmarked(const GURL& url) = 0;
 
     // Notifies that the favicon image has been updated. Most delegates
     // propagate the notification to FaviconDriverObserver::OnFaviconUpdated().
     // See its documentation for details.
     virtual void OnFaviconUpdated(
         const GURL& page_url,
         FaviconDriverObserver::NotificationIconType notification_icon_type,
         const GURL& icon_url,
         bool icon_url_changed,
         const gfx::Image& image) = 0;
   };
 
   // |service| and |delegate| must not be nullptr and must outlive this class.
   FaviconHandler(FaviconService* service,
                  Delegate* delegate,
                  FaviconDriverObserver::NotificationIconType handler_type);
   ~FaviconHandler();
 
   // Initiates loading the favicon for the specified url.
   void FetchFavicon(const GURL& url);
 
-  // Message Handler.  Must be public, because also called from
-  // PrerenderContents. Collects the |image_urls| list.
+  // Collects the candidate favicons as listed in the HTML head, as well as
+  // the WebManifest URL if available.
   void OnUpdateCandidates(const GURL& page_url,
-                          const std::vector<favicon::FaviconURL>& candidates);
+                          const std::vector<favicon::FaviconURL>& candidates,
+                          const base::Optional<GURL>& manifest_url);
+
+  // Returns the supported icon types, inferred from the handler type as passed
+  // in the constructor.
+  int icon_types() const { return icon_types_; }
 
   // For testing.
   const std::vector<GURL> GetIconURLs() const;
 
   // Returns whether the handler is waiting for a download to complete or for
   // data from the FaviconService. Reserved for testing.
   bool HasPendingTasksForTest();
 
   // Get the maximal icon size in pixels for a handler of type |handler_type|.
   static int GetMaximalIconSize(
@@ skipping 26 matching lines @@
 
   struct DownloadedFavicon {
     FaviconCandidate candidate;
     gfx::Image image;
   };
 
   // Returns the bit mask of favicon_base::IconType based on the handler's type.
   static int GetIconTypesFromHandlerType(
       FaviconDriverObserver::NotificationIconType handler_type);
 
+  // Called with the result of looking up cached icon data for the manifest's
+  // URL, which is used as icon URL.
+  void OnFaviconDataForManifestFromFaviconService(
+      const std::vector<favicon_base::FaviconRawBitmapResult>&
+          favicon_bitmap_results);
+
+  // Called when the dowloading of a manifest completes.
+  void OnDidDownloadManifest(const std::vector<FaviconURL>& candidates);
+
+  // Called when the actual list of favicon candidates to be processed is
+  // available, which can be either icon URLs listed in the HTML head instead
+  // or, if a Web Manifest was provided, the list of icons there.
+  void OnGotFinalIconURLCandidates(const std::vector<FaviconURL>& candidates);
+
   // Called when the history request for favicon data mapped to |url_| has
   // completed and the renderer has told us the icon URLs used by |url_|
   void OnGotInitialHistoryDataAndIconURLCandidates();
 
   // See description above class for details.
   void OnFaviconDataForInitialURLFromFaviconService(const std::vector<
       favicon_base::FaviconRawBitmapResult>& favicon_bitmap_results);
 
   // If the favicon currently mapped to |url_| has expired, downloads the
   // current candidate favicon from the renderer. Otherwise requests data for
   // the current favicon from history. If data is requested from history,
   // OnFaviconData() is called with the history data once it has been retrieved.
   void DownloadCurrentCandidateOrAskFaviconService();
 
+  // Requests the favicon for |icon_url| from the favicon service. Unless in
+  // incognito, it also updates the page URL (url_) to |icon_url| mappings.
+  void GetFaviconAndUpdateMappingsUnlessIncognito(
+      const GURL& icon_url,
+      favicon_base::IconType icon_type,
+      const favicon_base::FaviconResultsCallback& callback);
+
   // See description above class for details.
   void OnFaviconData(const std::vector<favicon_base::FaviconRawBitmapResult>&
                          favicon_bitmap_results);
 
   // Schedules a download for the specified entry. This adds the request to
   // image_download_requests_.
   void ScheduleImageDownload(const GURL& image_url,
                              favicon_base::IconType icon_type);
 
   // Triggered when a download of an image has finished.
@@ skipping 62 matching lines @@
   // to be incomplete. If true, it means there is a favicon mapped to |url_| in
   // history, but we need to redownload the icon URLs because the icon in the
   // database has expired or the data in the database is incomplete.
   bool initial_history_result_expired_or_incomplete_;
 
   // Whether FaviconHandler should ignore history state and determine the
   // optimal icon URL out of |image_urls_| for |url_| by downloading
   // |image_urls_| one by one.
   bool redownload_icons_;
 
+  // Requests to the renderer to download a manifest.
+  base::CancelableCallback<Delegate::ManifestDownloadCallback::RunType>
+      manifest_download_request_;
+
   // Requests to the renderer to download favicons.
   base::CancelableCallback<Delegate::ImageDownloadCallback::RunType>
       image_download_request_;
 
   // The combination of the supported icon types.
   const int icon_types_;
 
   // Whether the largest icon should be downloaded.
   const bool download_largest_icon_;
 
+  // The manifest URL from the renderer.
+  base::Optional<GURL> manifest_url_;
+
+  // Original list of candidates provided to OnUpdateCandidates(), stored to
+  // be able to fall back to, in case a manifest was provided and downloading it
+  // failed (or provided no icons).
+  std::vector<FaviconURL> non_manifest_original_candidates_;
+
   // The prioritized favicon candidates from the page back from the renderer.
   std::vector<FaviconCandidate> candidates_;
 
   // The icon URL and the icon type of the favicon in the most recent
   // FaviconDriver::OnFaviconAvailable() notification.
   GURL notification_icon_url_;
   favicon_base::IconType notification_icon_type_;
 
   // The FaviconService which implements favicon operations. May be null during
   // testing.
@@ skipping 15 matching lines @@
   // UpdateFaviconCandidate()), the favicon service and the delegate are
   // notified.
   DownloadedFavicon best_favicon_;
 
   DISALLOW_COPY_AND_ASSIGN(FaviconHandler);
 };
 
 }  // namespace favicon
 
 #endif  // COMPONENTS_FAVICON_CORE_FAVICON_HANDLER_H_