[WebAPK] Include image data for best icon per shortcut.

Send the image data for the best shortcut icon to the WebAPK server.
Duplicates are not sent, and a per-icon limit of 512KB is enforced.

Bug: 1045588
Change-Id: I2557584c32dc872013ecf1da3b3beee19047e5b0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2047166
Commit-Queue: Rayan Kanso <rayankans@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Cr-Commit-Position: refs/heads/master@{#740857}

chrome/browser/android/webapk/webapk_icon_hasher.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/browser/android/webapk/webapk_icon_hasher.h"
 
+#include <utility>
+
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
@@ -35,24 +37,24 @@ std::string ComputeMurmur2Hash(const std::string& raw_image_data) {
   return base::NumberToString(hash);
 }
 
-void OnMurmur2Hash(std::string* result,
+void OnMurmur2Hash(WebApkIconHasher::Icon* result,
                    base::OnceClosure done_closure,
-                   const std::string& hash) {
-  *result = hash;
+                   WebApkIconHasher::Icon icon) {
+  *result = std::move(icon);
   std::move(done_closure).Run();
 }
 
 void OnAllMurmur2Hashes(
-    std::unique_ptr<std::map<std::string, std::string>> hashes,
+    std::unique_ptr<std::map<std::string, WebApkIconHasher::Icon>> icons,
     WebApkIconHasher::Murmur2HashMultipleCallback callback) {
-  for (const auto& hash_pair : *hashes) {
-    if (hash_pair.second.empty()) {
+  for (const auto& icon_pair : *icons) {
+    if (icon_pair.second.hash.empty()) {
       std::move(callback).Run(base::nullopt);
       return;
     }
   }
 
-  std::move(callback).Run(std::move(*hashes));
+  std::move(callback).Run(std::move(*icons));
 }
 
 }  // anonymous namespace
@@ -63,12 +65,12 @@ void WebApkIconHasher::DownloadAndComputeMurmur2Hash(
     const url::Origin& request_initiator,
     const std::set<GURL>& icon_urls,
     Murmur2HashMultipleCallback callback) {
-  auto hashes_ptr = std::make_unique<std::map<std::string, std::string>>();
-  auto& hashes = *hashes_ptr;
+  auto icons_ptr = std::make_unique<std::map<std::string, Icon>>();
+  auto& icons = *icons_ptr;
 
   auto barrier_closure = base::BarrierClosure(
       icon_urls.size(),
-      base::BindOnce(&OnAllMurmur2Hashes, std::move(hashes_ptr),
+      base::BindOnce(&OnAllMurmur2Hashes, std::move(icons_ptr),
                      std::move(callback)));
 
   for (const auto& icon_url : icon_urls) {
@@ -76,7 +78,7 @@ void WebApkIconHasher::DownloadAndComputeMurmur2Hash(
     DownloadAndComputeMurmur2HashWithTimeout(
         url_loader_factory, request_initiator, icon_url,
         kDownloadTimeoutInMilliseconds,
-        base::BindOnce(&OnMurmur2Hash, &hashes[icon_url.spec()],
+        base::BindOnce(&OnMurmur2Hash, &icons[icon_url.spec()],
                        barrier_closure));
   }
 }
@@ -90,19 +92,20 @@ void WebApkIconHasher::DownloadAndComputeMurmur2HashWithTimeout(
     Murmur2HashCallback callback) {
   if (!icon_url.is_valid()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), ""));
+        FROM_HERE, base::BindOnce(std::move(callback), Icon{}));
     return;
   }
 
   if (icon_url.SchemeIs(url::kDataScheme)) {
     std::string mime_type, char_set, data;
-    std::string hash;
+    Icon icon;
     if (net::DataURL::Parse(icon_url, &mime_type, &char_set, &data) &&
         !data.empty()) {
-      hash = ComputeMurmur2Hash(data);
+      icon.hash = ComputeMurmur2Hash(data);
+      icon.data = std::move(data);
     }
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), hash));
+        FROM_HERE, base::BindOnce(std::move(callback), std::move(icon)));
     return;
   }
 
@@ -148,7 +151,7 @@ void WebApkIconHasher::OnSimpleLoaderComplete(
 
   // Check for non-empty body in case of HTTP 204 (no content) response.
   if (!response_body || response_body->empty()) {
-    RunCallback("");
+    RunCallback({});
     return;
   }
 
@@ -156,16 +159,19 @@ void WebApkIconHasher::OnSimpleLoaderComplete(
   // image's raw, unsanitized bytes from the web. |*response_body| may contain
   // malicious data. Decoding unsanitized bitmap data to an SkBitmap in the
   // browser process is a security bug.
-  RunCallback(ComputeMurmur2Hash(*response_body));
+  Icon icon;
+  icon.data = std::move(*response_body);
+  icon.hash = ComputeMurmur2Hash(icon.data);
+  RunCallback(std::move(icon));
 }
 
 void WebApkIconHasher::OnDownloadTimedOut() {
   simple_url_loader_.reset();
 
-  RunCallback("");
+  RunCallback({});
 }
 
-void WebApkIconHasher::RunCallback(const std::string& icon_murmur2_hash) {
-  std::move(callback_).Run(icon_murmur2_hash);
+void WebApkIconHasher::RunCallback(Icon icon) {
+  std::move(callback_).Run(std::move(icon));
   delete this;
 }

chrome/browser/android/webapk/webapk_icon_hasher.h

@@ -27,10 +27,15 @@ class URLLoaderFactory;
 // Downloads an icon and takes a Murmur2 hash of the downloaded image.
 class WebApkIconHasher {
  public:
-  using Murmur2HashCallback =
-      base::OnceCallback<void(const std::string& icon_murmur2_hash)>;
-  using Murmur2HashMultipleCallback = base::OnceCallback<void(
-      base::Optional<std::map<std::string, std::string>>)>;
+  // Result struct for holding the downloaded icon data and its hash.
+  struct Icon {
+    std::string data;
+    std::string hash;
+  };
+
+  using Murmur2HashCallback = base::OnceCallback<void(Icon)>;
+  using Murmur2HashMultipleCallback =
+      base::OnceCallback<void(base::Optional<std::map<std::string, Icon>>)>;
 
   // Creates a self-owned WebApkIconHasher instance. The instance downloads all
   // the |icon_urls| and calls |callback| with the Murmur2 hash of the
@@ -64,7 +69,7 @@ class WebApkIconHasher {
   void OnDownloadTimedOut();
 
   // Calls |callback_| with |icon_murmur2_hash|. Also deletes the instance.
-  void RunCallback(const std::string& icon_murmur2_hash);
+  void RunCallback(Icon icon_murmur2_hash);
 
   // Called with the image hash.
   Murmur2HashCallback callback_;

chrome/browser/android/webapk/webapk_icon_hasher_browsertest.cc

@@ -78,7 +78,7 @@ void OnDownloadedManifestIcon(base::OnceClosure callback,
 
 void OnGotMurmur2Hash(
     base::OnceClosure callback,
-    base::Optional<std::map<std::string, std::string>> hashes) {
+    base::Optional<std::map<std::string, WebApkIconHasher::Icon>> hashes) {
   std::move(callback).Run();
 }
 

chrome/browser/android/webapk/webapk_icon_hasher_unittest.cc

@@ -49,15 +49,16 @@ class WebApkIconHasherRunner {
     run_loop.Run();
   }
 
-  std::map<std::string, std::string> RunMultiple(
+  std::map<std::string, WebApkIconHasher::Icon> RunMultiple(
       network::mojom::URLLoaderFactory* url_loader_factory,
       const std::set<GURL>& icon_urls) {
-    std::map<std::string, std::string> result;
+    std::map<std::string, WebApkIconHasher::Icon> result;
     base::RunLoop run_loop;
     WebApkIconHasher::DownloadAndComputeMurmur2Hash(
         url_loader_factory, url::Origin::Create(*icon_urls.begin()), icon_urls,
         base::BindLambdaForTesting(
-            [&](base::Optional<std::map<std::string, std::string>> hashes) {
+            [&](base::Optional<std::map<std::string, WebApkIconHasher::Icon>>
+                    hashes) {
               ASSERT_TRUE(hashes);
               result = std::move(*hashes);
               run_loop.Quit();
@@ -66,22 +67,22 @@ class WebApkIconHasherRunner {
     return result;
   }
 
-  const std::string& murmur2_hash() { return murmur2_hash_; }
+  const WebApkIconHasher::Icon& icon() { return icon_; }
 
  private:
-  void OnCompleted(const std::string& murmur2_hash) {
-    murmur2_hash_ = murmur2_hash;
-    on_completed_callback_.Run();
+  void OnCompleted(WebApkIconHasher::Icon icon) {
+    icon_ = std::move(icon);
+    std::move(on_completed_callback_).Run();
   }
 
   // Fake factory that can be primed to return fake data.
   network::TestURLLoaderFactory test_url_loader_factory_;
 
   // Called once the Murmur2 hash is taken.
-  base::Closure on_completed_callback_;
+  base::OnceClosure on_completed_callback_;
 
   // Computed Murmur2 hash.
-  std::string murmur2_hash_;
+  WebApkIconHasher::Icon icon_;
 
   DISALLOW_COPY_AND_ASSIGN(WebApkIconHasherRunner);
 };
@@ -123,7 +124,8 @@ TEST_F(WebApkIconHasherTest, Success) {
 
   WebApkIconHasherRunner runner;
   runner.Run(test_url_loader_factory(), GURL(icon_url));
-  EXPECT_EQ(kIconMurmur2Hash, runner.murmur2_hash());
+  EXPECT_EQ(kIconMurmur2Hash, runner.icon().hash);
+  EXPECT_FALSE(runner.icon().data.empty());
 }
 
 TEST_F(WebApkIconHasherTest, DataUri) {
@@ -132,7 +134,8 @@ TEST_F(WebApkIconHasherTest, DataUri) {
       "9TXL0Y4OHwAAAABJRU5ErkJggg==");
   WebApkIconHasherRunner runner;
   runner.Run(test_url_loader_factory(), icon_url);
-  EXPECT_EQ("536500236142107998", runner.murmur2_hash());
+  EXPECT_EQ("536500236142107998", runner.icon().hash);
+  EXPECT_FALSE(runner.icon().data.empty());
 }
 
 TEST_F(WebApkIconHasherTest, MultipleIconUrls) {
@@ -160,15 +163,19 @@ TEST_F(WebApkIconHasherTest, MultipleIconUrls) {
   {
     auto result = runner.RunMultiple(test_url_loader_factory(), {icon_url1});
     ASSERT_EQ(result.size(), 1u);
-    EXPECT_EQ(result[icon_url1.spec()], kIconMurmur2Hash);
+    EXPECT_EQ(result[icon_url1.spec()].hash, kIconMurmur2Hash);
+    EXPECT_FALSE(result[icon_url1.spec()].data.empty());
   }
 
   {
     auto result =
         runner.RunMultiple(test_url_loader_factory(), {icon_url1, icon_url2});
     ASSERT_EQ(result.size(), 2u);
-    EXPECT_EQ(result[icon_url1.spec()], kIconMurmur2Hash);
-    EXPECT_EQ(result[icon_url2.spec()], "536500236142107998");
+    EXPECT_EQ(result[icon_url1.spec()].hash, kIconMurmur2Hash);
+    EXPECT_FALSE(result[icon_url1.spec()].data.empty());
+
+    EXPECT_EQ(result[icon_url2.spec()].hash, "536500236142107998");
+    EXPECT_FALSE(result[icon_url2.spec()].data.empty());
   }
 }
 
@@ -176,21 +183,24 @@ TEST_F(WebApkIconHasherTest, DataUriInvalid) {
   GURL icon_url("data:image/png;base64");
   WebApkIconHasherRunner runner;
   runner.Run(test_url_loader_factory(), icon_url);
-  EXPECT_EQ("", runner.murmur2_hash());
+  EXPECT_TRUE(runner.icon().hash.empty());
+  EXPECT_TRUE(runner.icon().data.empty());
 }
 
 TEST_F(WebApkIconHasherTest, InvalidUrl) {
   GURL icon_url("http::google.com");
   WebApkIconHasherRunner runner;
   runner.Run(test_url_loader_factory(), icon_url);
-  EXPECT_EQ("", runner.murmur2_hash());
+  EXPECT_TRUE(runner.icon().hash.empty());
+  EXPECT_TRUE(runner.icon().data.empty());
 }
 
 TEST_F(WebApkIconHasherTest, DownloadTimedOut) {
   std::string icon_url = "http://www.google.com/timeout";
   WebApkIconHasherRunner runner;
   runner.Run(test_url_loader_factory(), GURL(icon_url));
-  EXPECT_EQ("", runner.murmur2_hash());
+  EXPECT_TRUE(runner.icon().hash.empty());
+  EXPECT_TRUE(runner.icon().data.empty());
 }
 
 // Test that the hash callback is called with an empty string if an HTTP error
@@ -209,5 +219,6 @@ TEST_F(WebApkIconHasherTest, HTTPError) {
 
   WebApkIconHasherRunner runner;
   runner.Run(test_url_loader_factory(), GURL(icon_url));
-  EXPECT_EQ("", runner.murmur2_hash());
+  EXPECT_TRUE(runner.icon().hash.empty());
+  EXPECT_TRUE(runner.icon().data.empty());
 }

chrome/browser/android/webapk/webapk_installer.cc

@@ -31,7 +31,6 @@
 #include "chrome/browser/android/color_helpers.h"
 #include "chrome/browser/android/shortcut_helper.h"
 #include "chrome/browser/android/webapk/webapk.pb.h"
-#include "chrome/browser/android/webapk/webapk_icon_hasher.h"
 #include "chrome/browser/android/webapk/webapk_install_service.h"
 #include "chrome/browser/android/webapk/webapk_metrics.h"
 #include "chrome/browser/android/webapk/webapk_ukm_recorder.h"
@@ -58,16 +57,19 @@
 namespace {
 
 // The default WebAPK server URL.
-const char kDefaultServerUrl[] =
+constexpr char kDefaultServerUrl[] =
     "https://webapk.googleapis.com/v1/webApks/"
     "?alt=proto&key=AIzaSyAoI6v-F31-3t9NunLYEiKcPIqgTJIUZBw";
 
 // The MIME type of the POST data sent to the server.
-const char kProtoMimeType[] = "application/x-protobuf";
+constexpr char kProtoMimeType[] = "application/x-protobuf";
 
 // The default number of milliseconds to wait for the WebAPK download URL from
 // the WebAPK server.
-const int kWebApkDownloadUrlTimeoutMs = 60000;
+constexpr int kWebApkDownloadUrlTimeoutMs = 60000;
+
+// Limit the icon size to 512KB.
+constexpr size_t kMaxIconSizeInBytes = 512 * 1024;
 
 class CacheClearer : public content::BrowsingDataRemover::Observer {
  public:
@@ -186,7 +188,7 @@ std::unique_ptr<std::string> BuildProtoInBackground(
     const SkBitmap& badge_icon,
     const std::string& package_name,
     const std::string& version,
-    const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
+    std::map<std::string, WebApkIconHasher::Icon> icon_url_to_murmur2_hash,
     bool is_manifest_stale,
     WebApkUpdateReason update_reason) {
   std::unique_ptr<webapk::WebApk> webapk(new webapk::WebApk);
@@ -272,7 +274,7 @@ std::unique_ptr<std::string> BuildProtoInBackground(
     auto it = icon_url_to_murmur2_hash.find(icon_url);
     image->set_src(icon_url);
     if (it != icon_url_to_murmur2_hash.end())
-      image->set_hash(it->second);
+      image->set_hash(it->second.hash);
 
     if (icon_url == shortcut_info.best_primary_icon_url.spec()) {
       SetImageData(image, primary_icon);
@@ -305,7 +307,14 @@ std::unique_ptr<std::string> BuildProtoInBackground(
       auto shortcut_hash_it =
           icon_url_to_murmur2_hash.find(shortcut_icon->src());
       if (shortcut_hash_it != icon_url_to_murmur2_hash.end()) {
-        shortcut_icon->set_hash(shortcut_hash_it->second);
+        // Don't move the hash to avoid clearing it in case of duplicates.
+        shortcut_icon->set_hash(shortcut_hash_it->second.hash);
+
+        if (shortcut_hash_it->second.data.size() <= kMaxIconSizeInBytes) {
+          // Duplicate icons will have an empty |image_data|.
+          shortcut_icon->set_image_data(
+              std::move(shortcut_hash_it->second.data));
+        }
       }
     }
   }
@@ -327,7 +336,7 @@ bool StoreUpdateRequestToFileInBackground(
     const SkBitmap& badge_icon,
     const std::string& package_name,
     const std::string& version,
-    const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
+    std::map<std::string, WebApkIconHasher::Icon> icon_url_to_murmur2_hash,
     bool is_manifest_stale,
     WebApkUpdateReason update_reason) {
   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
@@ -335,8 +344,8 @@ bool StoreUpdateRequestToFileInBackground(
 
   std::unique_ptr<std::string> proto = BuildProtoInBackground(
       shortcut_info, primary_icon, is_primary_icon_maskable, badge_icon,
-      package_name, version, icon_url_to_murmur2_hash, is_manifest_stale,
-      update_reason);
+      package_name, version, std::move(icon_url_to_murmur2_hash),
+      is_manifest_stale, update_reason);
 
   // Create directory if it does not exist.
   base::CreateDirectory(update_request_path.DirName());
@@ -431,15 +440,15 @@ void WebApkInstaller::BuildProto(
     const SkBitmap& badge_icon,
     const std::string& package_name,
     const std::string& version,
-    const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
+    std::map<std::string, WebApkIconHasher::Icon> icon_url_to_murmur2_hash,
     bool is_manifest_stale,
     base::OnceCallback<void(std::unique_ptr<std::string>)> callback) {
   base::PostTaskAndReplyWithResult(
       GetBackgroundTaskRunner().get(), FROM_HERE,
       base::BindOnce(&BuildProtoInBackground, shortcut_info, primary_icon,
                      is_primary_icon_maskable, badge_icon, package_name,
-                     version, icon_url_to_murmur2_hash, is_manifest_stale,
-                     WebApkUpdateReason::NONE),
+                     version, std::move(icon_url_to_murmur2_hash),
+                     is_manifest_stale, WebApkUpdateReason::NONE),
       std::move(callback));
 }
 
@@ -452,7 +461,7 @@ void WebApkInstaller::StoreUpdateRequestToFile(
     const SkBitmap& badge_icon,
     const std::string& package_name,
     const std::string& version,
-    const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
+    std::map<std::string, WebApkIconHasher::Icon> icon_url_to_murmur2_hash,
     bool is_manifest_stale,
     WebApkUpdateReason update_reason,
     base::OnceCallback<void(bool)> callback) {
@@ -461,7 +470,7 @@ void WebApkInstaller::StoreUpdateRequestToFile(
       base::BindOnce(&StoreUpdateRequestToFileInBackground, update_request_path,
                      shortcut_info, primary_icon, is_primary_icon_maskable,
                      badge_icon, package_name, version,
-                     icon_url_to_murmur2_hash, is_manifest_stale,
+                     std::move(icon_url_to_murmur2_hash), is_manifest_stale,
                      update_reason),
       std::move(callback));
 }
@@ -677,7 +686,7 @@ void WebApkInstaller::OnHaveSufficientSpaceForInstall() {
 }
 
 void WebApkInstaller::OnGotIconMurmur2Hashes(
-    base::Optional<std::map<std::string, std::string>> hashes) {
+    base::Optional<std::map<std::string, WebApkIconHasher::Icon>> hashes) {
   if (!hashes) {
     OnResult(WebApkInstallResult::FAILURE);
     return;
@@ -685,7 +694,7 @@ void WebApkInstaller::OnGotIconMurmur2Hashes(
 
   BuildProto(*install_shortcut_info_, install_primary_icon_,
              is_primary_icon_maskable_, install_badge_icon_,
-             "" /* package_name */, "" /* version */, *hashes,
+             "" /* package_name */, "" /* version */, std::move(*hashes),
              false /* is_manifest_stale */,
              base::BindOnce(&WebApkInstaller::SendRequest,
                             weak_ptr_factory_.GetWeakPtr()));

chrome/browser/android/webapk/webapk_installer.h

@@ -18,6 +18,7 @@
 #include "base/strings/string16.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/android/shortcut_info.h"
+#include "chrome/browser/android/webapk/webapk_icon_hasher.h"
 #include "chrome/browser/android/webapk/webapk_install_service.h"
 #include "chrome/browser/android/webapk/webapk_types.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -110,11 +111,10 @@ class WebApkInstaller {
       const ShortcutInfo& shortcut_info,
       const SkBitmap& primary_icon,
       bool is_primary_icon_maskable,
-
       const SkBitmap& badge_icon,
       const std::string& package_name,
       const std::string& version,
-      const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
+      std::map<std::string, WebApkIconHasher::Icon> icon_url_to_murmur2_hash,
       bool is_manifest_stale,
       base::OnceCallback<void(std::unique_ptr<std::string>)> callback);
 
@@ -129,7 +129,7 @@ class WebApkInstaller {
       const SkBitmap& badge_icon,
       const std::string& package_name,
       const std::string& version,
-      const std::map<std::string, std::string>& icon_url_to_murmur2_hash,
+      std::map<std::string, WebApkIconHasher::Icon> icon_url_to_murmur2_hash,
       bool is_manifest_stale,
       WebApkUpdateReason update_reason,
       base::OnceCallback<void(bool)> callback);
@@ -187,7 +187,7 @@ class WebApkInstaller {
 
   // Called with the computed Murmur2 hash for the icons.
   void OnGotIconMurmur2Hashes(
-      base::Optional<std::map<std::string, std::string>> hashes);
+      base::Optional<std::map<std::string, WebApkIconHasher::Icon>> hashes);
 
   // Sends a request to WebAPK server to create/update WebAPK. During a
   // successful request the WebAPK server responds with a token to send to

chrome/browser/android/webapk/webapk_update_data_fetcher.cc

@@ -17,7 +17,6 @@
 #include "chrome/android/chrome_jni_headers/WebApkUpdateDataFetcher_jni.h"
 #include "chrome/browser/android/color_helpers.h"
 #include "chrome/browser/android/shortcut_helper.h"
-#include "chrome/browser/android/webapk/webapk_icon_hasher.h"
 #include "chrome/browser/android/webapk/webapk_web_manifest_checker.h"
 #include "chrome/browser/installable/installable_manager.h"
 #include "chrome/browser/profiles/profile.h"
@@ -181,7 +180,7 @@ void WebApkUpdateDataFetcher::OnDidGetInstallableData(
 }
 
 void WebApkUpdateDataFetcher::OnGotIconMurmur2Hashes(
-    base::Optional<std::map<std::string, std::string>> hashes) {
+    base::Optional<std::map<std::string, WebApkIconHasher::Icon>> hashes) {
   if (!hashes)
     return;
 
@@ -200,7 +199,7 @@ void WebApkUpdateDataFetcher::OnGotIconMurmur2Hashes(
           env, info_.best_primary_icon_url.spec());
   ScopedJavaLocalRef<jstring> java_primary_icon_murmur2_hash =
       base::android::ConvertUTF8ToJavaString(
-          env, (*hashes)[info_.best_primary_icon_url.spec()]);
+          env, (*hashes)[info_.best_primary_icon_url.spec()].hash);
   ScopedJavaLocalRef<jobject> java_primary_icon =
       gfx::ConvertToJavaBitmap(&primary_icon_);
   jboolean java_is_primary_icon_maskable = is_primary_icon_maskable_;
@@ -209,7 +208,7 @@ void WebApkUpdateDataFetcher::OnGotIconMurmur2Hashes(
                                              info_.best_badge_icon_url.spec());
   ScopedJavaLocalRef<jstring> java_badge_icon_murmur2_hash =
       base::android::ConvertUTF8ToJavaString(
-          env, (*hashes)[info_.best_badge_icon_url.spec()]);
+          env, (*hashes)[info_.best_badge_icon_url.spec()].hash);
   ScopedJavaLocalRef<jobject> java_badge_icon;
   if (!badge_icon_.drawsNothing())
     java_badge_icon = gfx::ConvertToJavaBitmap(&badge_icon_);
@@ -264,7 +263,7 @@ void WebApkUpdateDataFetcher::OnGotIconMurmur2Hashes(
     auto it = hashes->find(chosen_icon_url.spec());
     std::string chosen_icon_hash;
     if (it != hashes->end())
-      chosen_icon_hash = it->second;
+      chosen_icon_hash = it->second.hash;
 
     shortcuts.push_back({shortcut.name, shortcut.short_name.string(),
                          base::UTF8ToUTF16(shortcut.url.spec()),

chrome/browser/android/webapk/webapk_update_data_fetcher.h

@@ -11,6 +11,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "chrome/browser/android/shortcut_info.h"
+#include "chrome/browser/android/webapk/webapk_icon_hasher.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
@@ -59,7 +60,7 @@ class WebApkUpdateDataFetcher : public content::WebContentsObserver {
 
   // Called with the computed Murmur2 hashes for the icons.
   void OnGotIconMurmur2Hashes(
-      base::Optional<std::map<std::string, std::string>> hashes);
+      base::Optional<std::map<std::string, WebApkIconHasher::Icon>> hashes);
 
   // Called when a page has no Web Manifest or the Web Manifest is not WebAPK
   // compatible.

chrome/browser/android/webapk/webapk_update_manager.cc

@@ -4,6 +4,7 @@
 
 #include <jni.h>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "base/android/callback_android.h"
@@ -13,6 +14,7 @@
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/strings/string16.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/android/chrome_jni_headers/WebApkUpdateManager_jni.h"
@@ -143,9 +145,11 @@ static void JNI_WebApkUpdateManager_StoreWebApkUpdateRequestToFile(
   base::android::AppendJavaStringArrayToStringVector(env, java_icon_hashes,
                                                      &icon_hashes);
 
-  std::map<std::string, std::string> icon_url_to_murmur2_hash;
-  for (size_t i = 0; i < info.icon_urls.size(); ++i)
-    icon_url_to_murmur2_hash[info.icon_urls[i]] = icon_hashes[i];
+  std::map<std::string, WebApkIconHasher::Icon> icon_url_to_murmur2_hash;
+  for (size_t i = 0; i < info.icon_urls.size(); ++i) {
+    icon_url_to_murmur2_hash[info.icon_urls[i]] =
+        WebApkIconHasher::Icon{/* data= */ "", icon_hashes[i]};
+  }
 
   gfx::JavaBitmap java_primary_icon_bitmap_lock(java_primary_icon_bitmap);
   SkBitmap primary_icon =
@@ -178,8 +182,8 @@ static void JNI_WebApkUpdateManager_StoreWebApkUpdateRequestToFile(
     icon.purpose.push_back(blink::Manifest::ImageResource::Purpose::ANY);
 
     if (icon.src.is_valid()) {
-      icon_url_to_murmur2_hash[icon.src.spec()] =
-          base::UTF16ToUTF8(shortcut_data[4]);
+      icon_url_to_murmur2_hash[icon.src.spec()] = WebApkIconHasher::Icon{
+          /* data= */ "", /* hash= */ base::UTF16ToUTF8(shortcut_data[4])};
     }
     info.best_shortcut_icon_urls.push_back(icon.src);
     info.shortcut_items.push_back(std::move(shortcut_item));
@@ -191,8 +195,9 @@ static void JNI_WebApkUpdateManager_StoreWebApkUpdateRequestToFile(
   WebApkInstaller::StoreUpdateRequestToFile(
       base::FilePath(update_request_path), info, primary_icon,
       java_is_primary_icon_maskable, badge_icon, webapk_package,
-      std::to_string(java_webapk_version), icon_url_to_murmur2_hash,
-      java_is_manifest_stale, update_reason,
+      base::NumberToString(java_webapk_version),
+      std::move(icon_url_to_murmur2_hash), java_is_manifest_stale,
+      update_reason,
       base::BindOnce(&base::android::RunBooleanCallbackAndroid,
                      ScopedJavaGlobalRef<jobject>(java_callback)));
 }