Make AppBannerInfoBar install WebAPK.

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 125 matching lines @@
       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);
+  CreateJavaRef();
 }
 
-WebApkInstaller::~WebApkInstaller() {}
+void WebApkInstaller::CreateJavaRef() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  java_ref_.Reset(Java_WebApkInstaller_create(
+      env, reinterpret_cast<intptr_t>(this)));
+}
+
+WebApkInstaller::~WebApkInstaller() {

[pkotwicz, 2016/08/25 22:23:15]

Noob question: Is calling WebApkInstaller#destroy() necessary?

(I know that C++ objects owned by Java objects need to be destroyed explicitly
but I am wondering whether Java objects owned by C++ objects are destroyed
automatically via the ScopedJavaGlobalRef destructor)

[Xi Han, 2016/08/26 17:04:18]

That is a good point. The ScopedJavaGlobalRef destructor will reset the Java
pointer in c++, but it doesn't set the native pointer in Jave to 0. I am not
sure whether that matters. AppBannerInfoBarDelegateAndroid is an example that
Java object owned by c++, and it does have a destroy function in Java. I found
ResourceManager(https://cs.chromium.org/chromium/src/ui/android/java/src/org/chromium/ui/resources/ResourceManager.java?rcl=0&l=180)
is created and destroy in the same way as I did.  

[pkotwicz, 2016/08/26 22:31:24]

Thank you for looking into this. I learned something today!

+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_WebApkInstaller_destroy(env, java_ref_);
+  java_ref_.Reset();
+}
 
 void WebApkInstaller::InstallAsync(content::BrowserContext* browser_context,
                                    const FinishCallback& finish_callback) {
   InstallAsyncWithURLRequestContextGetter(
       Profile::FromBrowserContext(browser_context)->GetRequestContext(),
       finish_callback);
 }
 
 void WebApkInstaller::InstallAsyncWithURLRequestContextGetter(
     net::URLRequestContextGetter* request_context_getter,
@@ skipping 46 matching lines @@
       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);
+  return Java_WebApkInstaller_installAsyncFromNative(
+      env, java_ref_, java_file_path, java_package_name);
 }
 
 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,
-                                                    java_package_name);
+  return Java_WebApkInstaller_updateAsyncFromNative(
+      env, java_ref_, java_file_path, java_package_name);
 }
 
 void WebApkInstaller::OnURLFetchComplete(const net::URLFetcher* source) {
   timer_.Stop();
 
   if (!source->GetStatus().is_success() ||
       source->GetResponseCode() != net::HTTP_OK) {
     OnFailure();
     return;
   }
@@ skipping 45 matching lines @@
   if (icon_murmur2_hash.empty()) {
     OnFailure();
     return;
   }
 
   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()));
+                 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 14 matching lines @@
 
   url_fetcher_ = net::URLFetcher::Create(server_url, request_type, this);
   url_fetcher_->SetRequestContext(request_context_getter_);
   std::string 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) {

[pkotwicz, 2016/08/25 22:23:15]

Can you set |webapk_package_| here? This avoids passing |webapk_package_| from
one function to the next

[Xi Han, 2016/08/26 17:04:17]

Done.

   base::FilePath output_dir;
   base::android::GetCacheDirectory(&output_dir);
   // TODO(pkotwicz): Download WebAPKs into WebAPK-specific subdirectory
   // directory.
   // TODO(pkotwicz): Figure out when downloaded WebAPK should be deleted.
 
   timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(download_timeout_ms_),
       base::Bind(&WebApkInstaller::OnTimeout, weak_ptr_factory_.GetWeakPtr()));
 
@@ skipping 34 matching lines @@
     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 = false;
   if (task_type_ == INSTALL) {
+    webapk_package_ = package_name;
     success = StartInstallingDownloadedWebApk(env, java_file_path,
                                               java_package_name);
-  } else if (task_type_ == UPDATE) {
+    if (success)
+      return;
+  }
+  if (task_type_ == UPDATE) {
     success = StartUpdateUsingDownloadedWebApk(env, java_file_path,
                                                java_package_name);

[pkotwicz, 2016/08/25 22:23:16]

For updates you should call onSuccess() only once the WebAPK has been updated.
You can detect whether a WebAPK has been updated by checking the Android version
code of the installed WebAPK. For now you can keep the stub in
WebApkInstaller#updateAsyncFromNative()

For the sake of clarity I am suggesting:

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)
  OnFailure();

[Xi Han, 2016/08/26 17:04:17]

Yes, the update will also get a callback for the real success. Updated.

   }
+  OnInstallFinished(success);
+}
+
+void WebApkInstaller::OnInstallFinished(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& obj,
+    jboolean success) {
+  OnInstallFinished(success);
+}
+
+void WebApkInstaller::OnInstallFinished(bool success) {
   if (success)
     OnSuccess();
   else
     OnFailure();
 }
 
 void WebApkInstaller::OnTimeout() {
   OnFailure();
 }
 
 void WebApkInstaller::OnSuccess() {
   FinishCallback callback = finish_callback_;
   delete this;
-  callback.Run(true);
+  callback.Run(true, webapk_package_);
 }
 
 void WebApkInstaller::OnFailure() {
   FinishCallback callback = finish_callback_;
   delete this;
-  callback.Run(false);
+  callback.Run(false, "");
 }
+
+// static
+bool WebApkInstaller::Register(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}