Pass icon and icon murmur2 hash to WebApkInstaller when updating WebAPKs.

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 143 matching lines @@
       finish_callback);
 }
 
 void WebApkInstaller::InstallAsyncWithURLRequestContextGetter(
     net::URLRequestContextGetter* request_context_getter,
     const FinishCallback& finish_callback) {
   request_context_getter_ = request_context_getter;
   finish_callback_ = finish_callback;
   task_type_ = INSTALL;
 
-  if (!shortcut_info_.icon_url.is_valid()) {
-    OnFailure();
-    return;
-  }
-
   // 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();
 }
 
 void WebApkInstaller::SetTimeoutMs(int timeout_ms) {
   webapk_download_url_timeout_ms_ = timeout_ms;
   download_timeout_ms_ = timeout_ms;
 }
 
 void WebApkInstaller::UpdateAsync(content::BrowserContext* browser_context,
                                   const FinishCallback& finish_callback,
+                                  const std::string& icon_murmur2_hash,
                                   const std::string& webapk_package,
                                   int webapk_version) {
   UpdateAsyncWithURLRequestContextGetter(
       Profile::FromBrowserContext(browser_context)->GetRequestContext(),
-      finish_callback, webapk_package, webapk_version);
+      finish_callback, icon_murmur2_hash, webapk_package, webapk_version);
 }
 
 void WebApkInstaller::UpdateAsyncWithURLRequestContextGetter(
     net::URLRequestContextGetter* request_context_getter,
     const FinishCallback& finish_callback,
+    const std::string& icon_murmur2_hash,
     const std::string& webapk_package,
     int webapk_version) {
   request_context_getter_ = request_context_getter;
   finish_callback_ = finish_callback;
+  shortcut_icon_murmur2_hash_ = icon_murmur2_hash;
   webapk_package_ = webapk_package;
   webapk_version_ = webapk_version;
   task_type_ = UPDATE;
 
-  if (!shortcut_info_.icon_url.is_valid()) {
-    OnFailure();
-    return;
-  }
-
-  DownloadAppIconAndComputeMurmur2Hash();
+  base::PostTaskAndReplyWithResult(
+      GetBackgroundTaskRunner().get(), FROM_HERE,
+      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_,
+                  shortcut_icon_, shortcut_icon_murmur2_hash_),
+      base::Bind(&WebApkInstaller::SendUpdateWebApkRequest,
+                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 bool WebApkInstaller::StartInstallingDownloadedWebApk(
     JNIEnv* env,
     const base::android::ScopedJavaLocalRef<jstring>& java_file_path,
     const base::android::ScopedJavaLocalRef<jstring>& java_package_name) {
   return Java_WebApkInstaller_installAsyncFromNative(env, java_file_path,
                                                      java_package_name);
 }
 
@@ skipping 26 matching lines @@
 
   GURL signed_download_url(response->signed_download_url());
   if (!signed_download_url.is_valid() || response->package_name().empty()) {
     OnFailure();
     return;
   }
   OnGotWebApkDownloadUrl(signed_download_url, response->package_name());
 }
 
 void WebApkInstaller::DownloadAppIconAndComputeMurmur2Hash() {
+  // Safeguard. WebApkIconHasher crashes if asked to fetch an invalid URL.
+  if (!shortcut_info_.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_.icon_url,
       base::Bind(&WebApkInstaller::OnGotIconMurmur2Hash,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebApkInstaller::OnGotIconMurmur2Hash(
     const std::string& icon_murmur2_hash) {
   timer_.Stop();
   icon_hasher_.reset();
 
   shortcut_icon_murmur2_hash_ = icon_murmur2_hash;
 
   // An empty hash indicates that |icon_hasher_| encountered an error.
   if (icon_murmur2_hash.empty()) {
     OnFailure();
     return;
   }
 
-  if (task_type_ == INSTALL) {
-    base::PostTaskAndReplyWithResult(
-        GetBackgroundTaskRunner().get(), FROM_HERE,
-        base::Bind(&BuildWebApkProtoInBackground, shortcut_info_,
-                   shortcut_icon_, shortcut_icon_murmur2_hash_),
-        base::Bind(&WebApkInstaller::SendCreateWebApkRequest,
-                   weak_ptr_factory_.GetWeakPtr()));
-  } else if (task_type_ == UPDATE) {
-    base::PostTaskAndReplyWithResult(
-        GetBackgroundTaskRunner().get(), FROM_HERE,
-        base::Bind(&BuildWebApkProtoInBackground, shortcut_info_,
-                   shortcut_icon_, shortcut_icon_murmur2_hash_),
-        base::Bind(&WebApkInstaller::SendUpdateWebApkRequest,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
+  base::PostTaskAndReplyWithResult(
+      GetBackgroundTaskRunner().get(), FROM_HERE,
+      base::Bind(&BuildWebApkProtoInBackground, shortcut_info_,
+                  shortcut_icon_, shortcut_icon_murmur2_hash_),
+      base::Bind(&WebApkInstaller::SendCreateWebApkRequest,
+                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebApkInstaller::SendCreateWebApkRequest(
     std::unique_ptr<webapk::WebApk> webapk) {
   GURL server_url(server_url_.spec() + kDefaultWebApkServerUrlResponseType);
   SendRequest(std::move(webapk), net::URLFetcher::POST, server_url);
 }
 
 void WebApkInstaller::SendUpdateWebApkRequest(
     std::unique_ptr<webapk::WebApk> webapk) {
@@ skipping 96 matching lines @@
   FinishCallback callback = finish_callback_;
   delete this;
   callback.Run(true);
 }
 
 void WebApkInstaller::OnFailure() {
   FinishCallback callback = finish_callback_;
   delete this;
   callback.Run(false);
 }