Add calls to the server to request WebAPK updates.

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 10 matching lines @@
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/android/shortcut_helper.h"
 #include "chrome/browser/android/webapk/webapk.pb.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/manifest_util.h"
 #include "jni/WebApkInstaller_jni.h"
 #include "net/http/http_status_code.h"
-#include "net/url_request/url_fetcher.h"
 #include "third_party/smhasher/src/MurmurHash2.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "url/gurl.h"
 
 namespace {
 
 // The default WebAPK server URL.
 const char kDefaultWebApkServerUrl[] =
-    "https://webapk.googleapis.com/v1alpha/webApks?alt=proto";
+    "https://webapk.googleapis.com/v1alpha/webApks/";
+
+// The response format type expected from the WebAPK server.
+const char kDefaultWebApkServerUrlResponseType[] = "?alt=proto";
 
 // The MIME type of the POST data sent to the server.
 const char kProtoMimeType[] = "application/x-protobuf";
 
 // The seed to use the murmur2 hash of the app icon.
 const uint32_t kMurmur2HashSeed = 0;
 
 // The default number of milliseconds to wait for the WebAPK download URL from
 // the WebAPK server.
 const int kWebApkDownloadUrlTimeoutMs = 60000;
@@ skipping 26 matching lines @@
     return "";
 
   SkColor sk_color = reinterpret_cast<uint32_t&>(color);
   int r = SkColorGetR(sk_color);
   int g = SkColorGetG(sk_color);
   int b = SkColorGetB(sk_color);
   double a = SkColorGetA(sk_color) / 255.0;
   return base::StringPrintf("rgba(%d,%d,%d,%.2f)", r, g, b, a);
 }
 
+GURL GetServerUrlForUpdate(const GURL& server_url,
+                           const std::string& webapk_package) {
+  return GURL(server_url.spec() + webapk_package + "/" +

[Yaron, 2016/08/12 21:16:17]

i see what you're saying now about the url. I think this was cause the api team
was trying to make this a restful api but it's not anyway, so perhaps we can get
it removed.

[Xi Han, 2016/08/15 21:38:45]

Yes, I added the bug number back.

+              kDefaultWebApkServerUrlResponseType);
+}
+
 }  // anonymous namespace
 
 WebApkInstaller::WebApkInstaller(const ShortcutInfo& shortcut_info,
                                  const SkBitmap& shortcut_icon)
     : shortcut_info_(shortcut_info),
       shortcut_icon_(shortcut_icon),
       webapk_download_url_timeout_ms_(kWebApkDownloadUrlTimeoutMs),
       download_timeout_ms_(kDownloadTimeoutMs),
+      task_type_(UNDEFINED),
       weak_ptr_factory_(this) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   server_url_ =
       GURL(command_line->HasSwitch(switches::kWebApkServerUrl)
                ? command_line->GetSwitchValueASCII(switches::kWebApkServerUrl)
                : kDefaultWebApkServerUrl);
 }
 
 WebApkInstaller::~WebApkInstaller() {}
 
 void WebApkInstaller::InstallAsync(content::BrowserContext* browser_context,
                                    const FinishCallback& finish_callback) {
   InstallAsyncWithURLRequestContextGetter(

[Yaron, 2016/08/12 21:16:17]

there's no thread-hopping anymore - can we just inline these two functions (the
install one and the update one?)

[Xi Han, 2016/08/15 21:38:45]

The |InstallAsyncWithURLRequestContextGetter| is written for the tests when the
URLRequestContextGetter is passed in as a parameter. Same as the
|UpdatelAsyncWithURLRequestContextGetter|.

[Yaron, 2016/08/16 00:32:03]

got it, thanks

       Profile::FromBrowserContext(browser_context)->GetRequestContext(),
       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;
 
   // base::Unretained() is safe because WebApkInstaller owns itself and does not
   // start the timeout timer till after SendCreateWebApkRequest() is called.
   scoped_refptr<base::TaskRunner> background_task_runner =
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   base::PostTaskAndReplyWithResult(
       background_task_runner.get(), FROM_HERE,
       base::Bind(&WebApkInstaller::BuildWebApkProtoInBackground,
                  base::Unretained(this)),
       base::Bind(&WebApkInstaller::SendCreateWebApkRequest,
                  base::Unretained(this)));
 }
 
 void WebApkInstaller::SetTimeoutMs(int timeout_ms) {
   webapk_download_url_timeout_ms_ = timeout_ms;
   download_timeout_ms_ = timeout_ms;
 }
 
-bool WebApkInstaller::StartDownloadedWebApkInstall(
+void WebApkInstaller::UpdateAsync(content::BrowserContext* browser_context,
+                                  const FinishCallback& finish_callback,
+                                  const std::string& webapk_package,
+                                  int webapk_version) {
+  UpdateAsyncWithURLRequestContextGetter(
+      Profile::FromBrowserContext(browser_context)->GetRequestContext(),
+      finish_callback, webapk_package, webapk_version);
+}
+
+void WebApkInstaller::UpdateAsyncWithURLRequestContextGetter(
+    net::URLRequestContextGetter* request_context_getter,
+    const FinishCallback& finish_callback,
+    const std::string& webapk_package,
+    int webapk_version) {
+  request_context_getter_ = request_context_getter;
+  finish_callback_ = finish_callback;
+  webapk_package_ = webapk_package;
+  webapk_version_ = webapk_version;
+  task_type_ = UPDATE;
+

[pkotwicz, 2016/08/11 22:02:44]

Nit: You can steal GetBackgroundTaskRunner() from
https://codereview.chromium.org/2236033003/diff/20001/chrome/browser/android/...

[Xi Han, 2016/08/15 21:38:45]

Done.

+  // base::Unretained() is safe because WebApkInstaller owns itself and does not
+  // start the timeout timer till after SendUpdateWebApkRequest() is called.
+  scoped_refptr<base::TaskRunner> background_task_runner =
+      content::BrowserThread::GetBlockingPool()
+          ->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  base::PostTaskAndReplyWithResult(
+      background_task_runner.get(), FROM_HERE,
+      base::Bind(&WebApkInstaller::BuildWebApkProtoInBackground,
+                 base::Unretained(this)),
+      base::Bind(&WebApkInstaller::SendUpdateWebApkRequest,
+                 base::Unretained(this)));
+}
+
+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.obj(),
                                                      java_package_name.obj());
 }
 
+bool WebApkInstaller::StartUpdateUsingDownloadedWebApk(
+    JNIEnv* env,
+    const base::android::ScopedJavaLocalRef<jstring>& java_file_path,
+    const base::android::ScopedJavaLocalRef<jstring>& java_package_name) {
+  return Java_WebApkInstaller_updateAsyncFromNative(env, java_file_path.obj(),
+                                                    java_package_name.obj());
+}
+
 void WebApkInstaller::OnURLFetchComplete(const net::URLFetcher* source) {
   timer_.Stop();
 
   if (!source->GetStatus().is_success() ||
       source->GetResponseCode() != net::HTTP_OK) {
     OnFailure();
     return;
   }
 
   std::string response_string;
   source->GetResponseAsString(&response_string);
 
   std::unique_ptr<webapk::WebApkResponse> response(
       new webapk::WebApkResponse);
   if (!response->ParseFromString(response_string)) {
     OnFailure();
     return;
   }
 
   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::SendCreateWebApkRequest(
-    std::unique_ptr<webapk::WebApk> webapk_proto) {
+    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) {
+  webapk->set_package_name(webapk_package_);
+  webapk->set_version(std::to_string(webapk_version_));
+
+  SendRequest(std::move(webapk), net::URLFetcher::PUT,
+              GetServerUrlForUpdate(server_url_, webapk_package_));
+}
+
+void WebApkInstaller::SendRequest(std::unique_ptr<webapk::WebApk> request_proto,
+                                  net::URLFetcher::RequestType request_type,
+                                  const GURL& server_url) {
   timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(webapk_download_url_timeout_ms_),
       base::Bind(&WebApkInstaller::OnTimeout, weak_ptr_factory_.GetWeakPtr()));
 
-  url_fetcher_ =
-      net::URLFetcher::Create(server_url_, net::URLFetcher::POST, this);
+  url_fetcher_ = net::URLFetcher::Create(server_url, request_type, this);
   url_fetcher_->SetRequestContext(request_context_getter_);
   std::string serialized_request;
-  webapk_proto->SerializeToString(&serialized_request);
+  request_proto->SerializeToString(&serialized_request);
   url_fetcher_->SetUploadData(kProtoMimeType, serialized_request);
   url_fetcher_->Start();
 }
 
 void WebApkInstaller::OnGotWebApkDownloadUrl(const GURL& download_url,
                                              const std::string& package_name) {
   base::FilePath output_dir;
   base::android::GetCacheDirectory(&output_dir);
   // TODO(pkotwicz): Download WebAPKs into WebAPK-specific subdirectory
   // directory.
@@ skipping 18 matching lines @@
   if (result != FileDownloader::DOWNLOADED) {
     OnFailure();
     return;
   }
 
   JNIEnv* env = base::android::AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jstring> java_file_path =
       base::android::ConvertUTF8ToJavaString(env, file_path.value());
   base::android::ScopedJavaLocalRef<jstring> java_package_name =
       base::android::ConvertUTF8ToJavaString(env, package_name);
-  bool success =
-      StartDownloadedWebApkInstall(env, java_file_path, java_package_name);
+  bool success = false;
+  if (task_type_ == INSTALL) {
+    success =
+        StartInstallingDownloadedWebApk(env, java_file_path, java_package_name);
+  } else if (task_type_ == UPDATE) {
+    success = StartUpdateUsingDownloadedWebApk(env, java_file_path,
+                                               java_package_name);
+  }
   if (success)
     OnSuccess();
   else
     OnFailure();
 }
 
 std::unique_ptr<webapk::WebApk>
 WebApkInstaller::BuildWebApkProtoInBackground() {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
@@ skipping 37 matching lines @@
 
 void WebApkInstaller::OnSuccess() {
   finish_callback_.Run(true);
   delete this;
 }
 
 void WebApkInstaller::OnFailure() {
   finish_callback_.Run(false);
   delete this;
 }