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() {
+  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 17 matching lines @@
   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) {
   base::FilePath output_dir;
   base::android::GetCacheDirectory(&output_dir);
+  webapk_package_ = package_name;
   // 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()));
 
-  base::FilePath output_path = output_dir.AppendASCII(package_name);
+  base::FilePath output_path = output_dir.AppendASCII(webapk_package_);
   downloader_.reset(new FileDownloader(
       download_url, output_path, true, request_context_getter_,
       base::Bind(&WebApkInstaller::OnWebApkDownloaded,
-                 weak_ptr_factory_.GetWeakPtr(), output_path, package_name)));
+                 weak_ptr_factory_.GetWeakPtr(), output_path)));
 }
 
 void WebApkInstaller::OnWebApkDownloaded(const base::FilePath& file_path,
-                                         const std::string& package_name,
                                          FileDownloader::Result result) {
   timer_.Stop();
 
   if (result != FileDownloader::DOWNLOADED) {
     OnFailure();
     return;
   }
 
   int posix_permissions = base::FILE_PERMISSION_READ_BY_USER |
                           base::FILE_PERMISSION_WRITE_BY_USER |
                           base::FILE_PERMISSION_READ_BY_GROUP |
                           base::FILE_PERMISSION_READ_BY_OTHERS;
   base::PostTaskAndReplyWithResult(
       GetBackgroundTaskRunner().get(), FROM_HERE,
       base::Bind(&base::SetPosixFilePermissions, file_path, posix_permissions),
       base::Bind(&WebApkInstaller::OnWebApkMadeWorldReadable,
-                 weak_ptr_factory_.GetWeakPtr(), file_path, package_name));
+                 weak_ptr_factory_.GetWeakPtr(), file_path));
 }
 
 void WebApkInstaller::OnWebApkMadeWorldReadable(
     const base::FilePath& file_path,
-    const std::string& package_name,
     bool change_permission_success) {
   if (!change_permission_success) {
     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);
+      base::android::ConvertUTF8ToJavaString(env, webapk_package_);
   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)
+    OnFailure();
+}
+
+void WebApkInstaller::OnInstallFinished(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& obj,
+    jboolean 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);
+}