Update WebApkInstaller to support badge icon in installation.

chrome/browser/android/webapk/webapk_installer.cc

 // Copyright 2016 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/webapk/webapk_installer.h"
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/path_utils.h"
@@ skipping 93 matching lines @@
   return "arm64-v8a";
 #else
 #error "Unsupported target abi"
 #endif
 }
 
 // Populates webapk::WebApk and returns it.
 // Must be called on a worker thread because it encodes an SkBitmap.
 std::unique_ptr<webapk::WebApk> BuildWebApkProtoInBackground(
     const ShortcutInfo& shortcut_info,
-    const SkBitmap& shortcut_icon,
+    const SkBitmap& primary_icon,
+    const SkBitmap& badge_icon,
     const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
     bool is_manifest_stale) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   std::unique_ptr<webapk::WebApk> webapk(new webapk::WebApk);
   webapk->set_manifest_url(shortcut_info.manifest_url.spec());
   webapk->set_requester_application_package(
       base::android::BuildInfo::GetInstance()->package_name());
   webapk->set_requester_application_version(version_info::GetVersionNumber());
   webapk->set_android_abi(getCurrentAbi());
   webapk->set_stale_manifest(is_manifest_stale);
 
   webapk::WebAppManifest* web_app_manifest = webapk->mutable_manifest();
   web_app_manifest->set_name(base::UTF16ToUTF8(shortcut_info.name));
   web_app_manifest->set_short_name(base::UTF16ToUTF8(shortcut_info.short_name));
   web_app_manifest->set_start_url(shortcut_info.url.spec());
   web_app_manifest->set_orientation(
       content::WebScreenOrientationLockTypeToString(shortcut_info.orientation));
   web_app_manifest->set_display_mode(
       content::WebDisplayModeToString(shortcut_info.display));
   web_app_manifest->set_background_color(
       ColorToString(shortcut_info.background_color));
   web_app_manifest->set_theme_color(ColorToString(shortcut_info.theme_color));
 
   std::string* scope = web_app_manifest->add_scopes();
   scope->assign(GetScope(shortcut_info).spec());
 
-  webapk::Image* best_image = web_app_manifest->add_icons();
+  webapk::Image* best_primary_icon_image = web_app_manifest->add_icons();
   std::string best_primary_icon_url =
       shortcut_info.best_primary_icon_url.spec();
-  best_image->set_src(best_primary_icon_url);
+  best_primary_icon_image->set_src(best_primary_icon_url);
   auto it = icon_url_to_murmur2_hash.find(best_primary_icon_url);
   if (it != icon_url_to_murmur2_hash.end())
-    best_image->set_hash(it->second);
+    best_primary_icon_image->set_hash(it->second);
   std::vector<unsigned char> png_bytes;
-  gfx::PNGCodec::EncodeBGRASkBitmap(shortcut_icon, false, &png_bytes);
-  best_image->set_image_data(&png_bytes.front(), png_bytes.size());
+  gfx::PNGCodec::EncodeBGRASkBitmap(primary_icon, false, &png_bytes);
+  best_primary_icon_image->set_image_data(&png_bytes.front(), png_bytes.size());
+  best_primary_icon_image->add_usages(webapk::Image::PRIMARY_ICON);
+
+  if (!badge_icon.drawsNothing()) {
+    std::string best_badge_icon_url = shortcut_info.best_badge_icon_url.spec();
+    if (best_badge_icon_url == best_primary_icon_url) {
+      best_primary_icon_image->add_usages(webapk::Image::BADGE_ICON);
+    } else {
+      webapk::Image* best_badge_icon_image = web_app_manifest->add_icons();
+      std::string best_badge_icon_url =

[dominickn, 2017/02/23 02:08:52]

This variable looks redundant (you already have it at line 156?)

[F, 2017/03/30 18:20:12]

Oops. Thanks!

+          shortcut_info.best_badge_icon_url.spec();
+      best_badge_icon_image->set_src(best_badge_icon_url);
+      auto it = icon_url_to_murmur2_hash.find(best_badge_icon_url);
+      if (it != icon_url_to_murmur2_hash.end())
+        best_badge_icon_image->set_hash(it->second);
+      std::vector<unsigned char> png_bytes;
+      gfx::PNGCodec::EncodeBGRASkBitmap(badge_icon, false, &png_bytes);
+      best_badge_icon_image->set_image_data(&png_bytes.front(),
+                                            png_bytes.size());
+      best_badge_icon_image->add_usages(webapk::Image::BADGE_ICON);
+    }
+  }
 
   for (const auto& entry : icon_url_to_murmur2_hash) {
-    if (entry.first == shortcut_info.best_primary_icon_url.spec())
+    if (entry.first == shortcut_info.best_primary_icon_url.spec() ||
+        entry.first == shortcut_info.best_badge_icon_url.spec()) {
       continue;
+    }
     webapk::Image* image = web_app_manifest->add_icons();
     image->set_src(entry.first);
     image->set_hash(entry.second);
   }
 
   return webapk;
 }
 
 // Calls the callback when the |webapk| request is created.
 void OnWebApkProtoBuilt(
@@ skipping 45 matching lines @@
 
 WebApkInstaller::~WebApkInstaller() {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_WebApkInstaller_destroy(env, java_ref_);
   java_ref_.Reset();
 }
 
 // static
 void WebApkInstaller::InstallAsync(content::BrowserContext* context,
                                    const ShortcutInfo& shortcut_info,
-                                   const SkBitmap& shortcut_icon,
+                                   const SkBitmap& primary_icon,
+                                   const SkBitmap& badge_icon,
                                    const FinishCallback& finish_callback) {
   // The installer will delete itself when it is done.
   WebApkInstaller* installer =
-      new WebApkInstaller(context, shortcut_info, shortcut_icon);
+      new WebApkInstaller(context, shortcut_info, primary_icon, badge_icon);
   installer->InstallAsync(finish_callback);
 }
 
 // static
 void WebApkInstaller::UpdateAsync(
     content::BrowserContext* context,
     const ShortcutInfo& shortcut_info,
-    const SkBitmap& shortcut_icon,
+    const SkBitmap& primary_icon,
     const std::string& webapk_package,
     int webapk_version,
     const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
     bool is_manifest_stale,
     const FinishCallback& finish_callback) {
   // The installer will delete itself when it is done.
-  WebApkInstaller* installer =
-      new WebApkInstaller(context, shortcut_info, shortcut_icon);
+  SkBitmap empty_badge_icon;
+  WebApkInstaller* installer = new WebApkInstaller(
+      context, shortcut_info, primary_icon, empty_badge_icon);
   installer->UpdateAsync(webapk_package, webapk_version,
                          icon_url_to_murmur2_hash, is_manifest_stale,
                          finish_callback);
 }
 
 // staic
 void WebApkInstaller::InstallAsyncForTesting(
     WebApkInstaller* installer,
     const FinishCallback& finish_callback) {
   installer->InstallAsync(finish_callback);
@@ skipping 26 matching lines @@
   else
     OnFailure();
 }
 
 void WebApkInstaller::BuildWebApkProtoInBackgroundForTesting(
     const base::Callback<void(std::unique_ptr<webapk::WebApk>)>& callback,
     const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
     bool is_manifest_stale) {
   base::PostTaskAndReplyWithResult(
       GetBackgroundTaskRunner().get(), FROM_HERE,
-      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_, shortcut_icon_,
-                 icon_url_to_murmur2_hash, is_manifest_stale),
+      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_, primary_icon_,
+                 badge_icon_, icon_url_to_murmur2_hash, is_manifest_stale),
       base::Bind(&OnWebApkProtoBuilt, callback));
 }
 
 // static
 bool WebApkInstaller::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 bool WebApkInstaller::StartInstallingDownloadedWebApk(
     JNIEnv* env,
@@ skipping 37 matching lines @@
         java_url);
   } else {
     return Java_WebApkInstaller_updateAsyncFromGooglePlay(
         env, java_ref_, java_webapk_package, version, java_title, java_token,
         java_url);
   }
 }
 
 WebApkInstaller::WebApkInstaller(content::BrowserContext* browser_context,
                                  const ShortcutInfo& shortcut_info,
-                                 const SkBitmap& shortcut_icon)
+                                 const SkBitmap& primary_icon,
+                                 const SkBitmap& badge_icon)
     : request_context_getter_(
           Profile::FromBrowserContext(browser_context)->GetRequestContext()),
       shortcut_info_(shortcut_info),
-      shortcut_icon_(shortcut_icon),
+      primary_icon_(primary_icon),
+      badge_icon_(badge_icon),
       server_url_(GetServerUrl()),
       webapk_download_url_timeout_ms_(kWebApkDownloadUrlTimeoutMs),
       download_timeout_ms_(kDownloadTimeoutMs),
       task_type_(UNDEFINED),
       weak_ptr_factory_(this) {
   CreateJavaRef();
 }
 
 void WebApkInstaller::CreateJavaRef() {
   JNIEnv* env = base::android::AttachCurrentThread();
   java_ref_.Reset(
       Java_WebApkInstaller_create(env, reinterpret_cast<intptr_t>(this)));
 }
 
 void WebApkInstaller::InstallAsync(const FinishCallback& finish_callback) {
   finish_callback_ = finish_callback;
   task_type_ = INSTALL;
 
   // We need to take the hash of the bitmap at the icon URL prior to any
   // transformations being applied to the bitmap (such as encoding/decoding
   // the bitmap). The icon hash is used to determine whether the icon that
   // the user sees matches the icon of a WebAPK that the WebAPK server
   // generated for another user. (The icon can be dynamically generated.)
   //
   // We redownload the icon in order to take the Murmur2 hash. The redownload
   // should be fast because the icon should be in the HTTP cache.
-  DownloadAppIconAndComputeMurmur2Hash();
+  DownloadPrimaryIconAndComputeMurmur2Hash();
 }
 
 void WebApkInstaller::UpdateAsync(
     const std::string& webapk_package,
     int webapk_version,
     const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
     bool is_manifest_stale,
     const FinishCallback& finish_callback) {
   webapk_package_ = webapk_package;
   webapk_version_ = webapk_version;
   finish_callback_ = finish_callback;
   task_type_ = UPDATE;
 
   base::PostTaskAndReplyWithResult(
       GetBackgroundTaskRunner().get(), FROM_HERE,
-      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_, shortcut_icon_,
-                 icon_url_to_murmur2_hash, is_manifest_stale),
+      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_, primary_icon_,
+                 badge_icon_, icon_url_to_murmur2_hash, is_manifest_stale),
       base::Bind(&WebApkInstaller::SendUpdateWebApkRequest,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebApkInstaller::OnURLFetchComplete(const net::URLFetcher* source) {
   timer_.Stop();
 
   if (!source->GetStatus().is_success() ||
       source->GetResponseCode() != net::HTTP_OK) {
     LOG(WARNING) << base::StringPrintf(
@@ skipping 34 matching lines @@
     // asynchronously after the install or upidate has either failed or
     // completed.
     InstallOrUpdateWebApkFromGooglePlay(response->package_name(), version,
                                         response->token());
     return;
   }
 
   OnGotWebApkDownloadUrl(signed_download_url, response->package_name());
 }
 
-void WebApkInstaller::DownloadAppIconAndComputeMurmur2Hash() {
+void WebApkInstaller::DownloadPrimaryIconAndComputeMurmur2Hash() {
   // Safeguard. WebApkIconHasher crashes if asked to fetch an invalid URL.
   if (!shortcut_info_.best_primary_icon_url.is_valid()) {
     OnFailure();
     return;
   }
 
   timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(download_timeout_ms_),
       base::Bind(&WebApkInstaller::OnTimeout, weak_ptr_factory_.GetWeakPtr()));
 
   icon_hasher_.reset(new WebApkIconHasher());
   icon_hasher_->DownloadAndComputeMurmur2Hash(
       request_context_getter_, shortcut_info_.best_primary_icon_url,
-      base::Bind(&WebApkInstaller::OnGotIconMurmur2Hash,
+      base::Bind(&WebApkInstaller::OnGotPrimaryIconMurmur2Hash,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void WebApkInstaller::OnGotIconMurmur2Hash(
-    const std::string& icon_murmur2_hash) {
+void WebApkInstaller::OnGotPrimaryIconMurmur2Hash(
+    const std::string& primary_icon_hash) {
   timer_.Stop();
   icon_hasher_.reset();
 
   // An empty hash indicates that |icon_hasher_| encountered an error.
-  if (icon_murmur2_hash.empty()) {
+  if (primary_icon_hash.empty()) {
     OnFailure();
     return;
   }
 
+  primary_icon_hash_ = primary_icon_hash;
+
+  if (!shortcut_info_.best_badge_icon_url.is_empty() ||
+      shortcut_info_.best_badge_icon_url.spec() ==
+          shortcut_info_.best_primary_icon_url.spec()) {
+    DownloadBadgeIconAndComputeMurmur2Hash();
+  } else {
+    MapIconUrlToMurmur2Hash();
+  }
+}
+
+void WebApkInstaller::DownloadBadgeIconAndComputeMurmur2Hash() {

[dominickn, 2017/02/23 02:08:52]

Instead of mostly duplicating DownloadPrimaryIconAndComputeMurmur2Hash(), can
you make it something like:

DownloadIconAndComputeMurmur2Hash(const GURL& icon_url, std::string*
hash_result);

And then explicitly call it twice in ::InstallAsync()?

At the very least, the downloading of the icon and hash computation should be
identical and thus one method. The only difference is where you save the final
result.

[F, 2017/03/30 18:20:12]

After the refactoring of WebApkIconHasher, this has become much cleaner. WDUT?

+  // Safeguard. WebApkIconHasher crashes if asked to fetch an invalid URL.
+  if (!shortcut_info_.best_badge_icon_url.is_valid()) {
+    OnFailure();
+    return;
+  }
+
+  timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(download_timeout_ms_),
+      base::Bind(&WebApkInstaller::OnTimeout, weak_ptr_factory_.GetWeakPtr()));
+
+  icon_hasher_.reset(new WebApkIconHasher());
+  icon_hasher_->DownloadAndComputeMurmur2Hash(
+      request_context_getter_, shortcut_info_.best_badge_icon_url,
+      base::Bind(&WebApkInstaller::OnGotBadgeIconMurmur2Hash,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void WebApkInstaller::OnGotBadgeIconMurmur2Hash(
+    const std::string& badge_icon_hash) {
+  timer_.Stop();
+  icon_hasher_.reset();
+
+  // An empty hash indicates that |icon_hasher_| encountered an error.
+  if (badge_icon_hash.empty()) {
+    OnFailure();
+    return;
+  }
+
+  badge_icon_hash_ = badge_icon_hash;
+
+  MapIconUrlToMurmur2Hash();
+}
+
+void WebApkInstaller::MapIconUrlToMurmur2Hash() {
   std::map<std::string, std::string> icon_url_to_murmur2_hash;
   for (const std::string& icon_url : shortcut_info_.icon_urls) {
-    if (icon_url != shortcut_info_.best_primary_icon_url.spec())
+    if (icon_url == shortcut_info_.best_primary_icon_url.spec())
+      icon_url_to_murmur2_hash[icon_url] = primary_icon_hash_;
+    else if (icon_url == shortcut_info_.best_badge_icon_url.spec())
+      icon_url_to_murmur2_hash[icon_url] = badge_icon_hash_;
+    else
       icon_url_to_murmur2_hash[icon_url] = "";
-    else
-      icon_url_to_murmur2_hash[icon_url] = icon_murmur2_hash;
   }
 
   base::PostTaskAndReplyWithResult(
       GetBackgroundTaskRunner().get(), FROM_HERE,
-      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_, shortcut_icon_,
-                 icon_url_to_murmur2_hash, false /* is_manifest_stale */),
+      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_, primary_icon_,
+                 badge_icon_, icon_url_to_murmur2_hash,
+                 false /* is_manifest_stale */),
       base::Bind(&WebApkInstaller::SendCreateWebApkRequest,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebApkInstaller::SendCreateWebApkRequest(
     std::unique_ptr<webapk::WebApk> webapk) {
   SendRequest(std::move(webapk), server_url_);
 }
 
 void WebApkInstaller::SendUpdateWebApkRequest(
@@ skipping 129 matching lines @@
 
 void WebApkInstaller::OnSuccess() {
   finish_callback_.Run(true, webapk_package_);
   delete this;
 }
 
 void WebApkInstaller::OnFailure() {
   finish_callback_.Run(false, webapk_package_);
   delete this;
 }