Update AddToHomescreenDataFetcher to accept badge icon for WebAPK.

chrome/browser/android/webapps/add_to_homescreen_data_fetcher.cc

 // Copyright 2015 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/android/webapps/add_to_homescreen_data_fetcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 25 matching lines @@
 namespace {
 
 // Looks up the original, online URL of the site requested.  The URL from the
 // WebContents may be a distilled article which is not appropriate for a home
 // screen shortcut.
 GURL GetShortcutUrl(content::BrowserContext* browser_context,
                     const GURL& actual_url) {
   return dom_distiller::url_utils::GetOriginalUrlFromDistillerUrl(actual_url);
 }
 
-InstallableParams ParamsToPerformInstallableCheck(int ideal_icon_size_in_px,
-                                                  int minimum_icon_size_in_px,
-                                                  bool check_installable) {
+InstallableParams ParamsToPerformInstallableCheck(
+    int ideal_icon_size_in_px,
+    int minimum_icon_size_in_px,
+    bool check_webapk_compatibility,

[dominickn, 2017/02/02 19:16:50]

It's weird to me to see the bool in the middle of the argument list,
particularly since it's last elsewhere.

[F, 2017/02/02 21:05:51]

Done.

+    int ideal_badge_size_in_px,
+    int minimum_badge_size_in_px) {
   InstallableParams params;
   params.ideal_primary_icon_size_in_px = ideal_icon_size_in_px;
   params.minimum_primary_icon_size_in_px = minimum_icon_size_in_px;
-  params.check_installable = check_installable;
+  params.check_installable = check_webapk_compatibility;
   params.fetch_valid_primary_icon = true;
+  if (check_webapk_compatibility) {
+    params.ideal_badge_icon_size_in_px = ideal_badge_size_in_px;
+    params.minimum_badge_icon_size_in_px = minimum_badge_size_in_px;
+    params.fetch_valid_badge_icon = true;
+  }
   return params;
 }
 
 }  // namespace
 
 AddToHomescreenDataFetcher::AddToHomescreenDataFetcher(
     content::WebContents* web_contents,
     int ideal_icon_size_in_px,
     int minimum_icon_size_in_px,
     int ideal_splash_image_size_in_px,
     int minimum_splash_image_size_in_px,
+    int ideal_badge_size_in_px,
+    int minimum_badge_size_in_px,
     bool check_webapk_compatibility,
     Observer* observer)
     : WebContentsObserver(web_contents),
       weak_observer_(observer),
       shortcut_info_(GetShortcutUrl(web_contents->GetBrowserContext(),
                                     web_contents->GetLastCommittedURL())),
       data_timeout_timer_(false, false),
       ideal_icon_size_in_px_(ideal_icon_size_in_px),
       minimum_icon_size_in_px_(minimum_icon_size_in_px),
       ideal_splash_image_size_in_px_(ideal_splash_image_size_in_px),
       minimum_splash_image_size_in_px_(minimum_splash_image_size_in_px),
+      ideal_badge_size_in_px_(ideal_badge_size_in_px),
+      minimum_badge_size_in_px_(minimum_badge_size_in_px),
       check_webapk_compatibility_(check_webapk_compatibility),
       is_waiting_for_web_application_info_(true),
       is_installable_check_complete_(false),
       is_icon_saved_(false),
       is_ready_(false) {
   DCHECK(minimum_icon_size_in_px <= ideal_icon_size_in_px);
   DCHECK(minimum_splash_image_size_in_px <= ideal_splash_image_size_in_px);
+  DCHECK(minimum_badge_size_in_px <= ideal_badge_size_in_px);
 
   // Send a message to the renderer to retrieve information about the page.
   Send(new ChromeViewMsg_GetWebApplicationInfo(routing_id()));
 }
 
 base::Closure AddToHomescreenDataFetcher::FetchSplashScreenImageCallback(
     const std::string& webapp_id) {
   return base::Bind(&ShortcutHelper::FetchSplashScreenImage, web_contents(),
                     splash_screen_url_, ideal_splash_image_size_in_px_,
                     minimum_splash_image_size_in_px_, webapp_id);
@@ skipping 45 matching lines @@
 
   // Kick off a timeout for downloading data. If we haven't finished within the
   // timeout, fall back to using a dynamically-generated launcher icon.
   data_timeout_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(4000),
       base::Bind(&AddToHomescreenDataFetcher::OnDataTimedout, this));
 
   manager->GetData(
       ParamsToPerformInstallableCheck(ideal_icon_size_in_px_,
                                       minimum_icon_size_in_px_,
-                                      check_webapk_compatibility_),
+                                      check_webapk_compatibility_,
+                                      ideal_badge_size_in_px_,
+                                      minimum_badge_size_in_px_),
       base::Bind(&AddToHomescreenDataFetcher::OnDidPerformInstallableCheck,
                  this));
 }
 
 AddToHomescreenDataFetcher::~AddToHomescreenDataFetcher() {
   DCHECK(!weak_observer_);
 }
 
 bool AddToHomescreenDataFetcher::OnMessageReceived(
     const IPC::Message& message) {
@@ skipping 15 matching lines @@
   if (!web_contents() || !weak_observer_)
     return;
 
   if (!is_installable_check_complete_) {
     is_installable_check_complete_ = true;
     if (check_webapk_compatibility_)
       weak_observer_->OnDidDetermineWebApkCompatibility(false);
     weak_observer_->OnUserTitleAvailable(base::string16());
   }
 
-  if (!is_icon_saved_)
+  if (!is_icon_saved_) {
+    shortcut_badge_.reset();
     CreateLauncherIcon(SkBitmap());
+  }
 }
 
 void AddToHomescreenDataFetcher::OnDidPerformInstallableCheck(
     const InstallableData& data) {
+  shortcut_badge_.reset();
+
   if (!web_contents() || !weak_observer_)
     return;
 
   is_installable_check_complete_ = true;
 
   if (check_webapk_compatibility_) {
     bool webapk_compatible =
         (data.error_code == NO_ERROR_DETECTED &&
          AreWebManifestUrlsWebApkCompatible(data.manifest));
     weak_observer_->OnDidDetermineWebApkCompatibility(webapk_compatible);
 
-    // WebAPKs are wholly defined by the Web Manifest. Ignore the <meta> tag
-    // data received in OnDidGetWebApplicationInfo().
-    if (webapk_compatible)
+    if (webapk_compatible) {
+      // WebAPKs are wholly defined by the Web Manifest. Ignore the <meta> tag
+      // data received in OnDidGetWebApplicationInfo().
       shortcut_info_ = ShortcutInfo(GURL());
+
+      if (data.badge_icon && !data.badge_icon->drawsNothing()) {
+        shortcut_info_.best_badge_url = data.badge_icon_url;
+
+        data.badge_icon->deepCopyTo(&shortcut_badge_);

[dominickn, 2017/02/02 19:16:50]

Why does this need to be a deep copy as opposed to just using the copy
constructor?

[F, 2017/02/02 21:05:51]

My bad. I wasn't sure of the life span of SkBitmap owned by InstallableManager.

[dominickn, 2017/02/02 21:17:11]

We use the copy constructor for the primary icon here so it should be fine.
InstallableManager's icon is cached for the lifetime of the navigation. :)

[F, 2017/02/02 22:30:42]

Thanks for the info :)

+      }
+    }
   }
 
   if (!data.manifest.IsEmpty()) {
     content::RecordAction(
         base::UserMetricsAction("webapps.AddShortcut.Manifest"));
     shortcut_info_.UpdateFromManifest(data.manifest);
     shortcut_info_.manifest_url = data.manifest_url;
   }
 
   // Save the splash screen URL for the later download.
@@ skipping 96 matching lines @@
 }
 
 void AddToHomescreenDataFetcher::NotifyObserver(const SkBitmap& icon) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!web_contents() || !weak_observer_ || is_icon_saved_)
     return;
 
   is_icon_saved_ = true;
   shortcut_icon_ = icon;
   is_ready_ = true;
-  weak_observer_->OnDataAvailable(shortcut_info_, shortcut_icon_);
+  weak_observer_->OnDataAvailable(shortcut_info_, shortcut_icon_,
+                                  shortcut_badge_);
 }