[Android WebAPK] Make webapk_installer.cc return proto as base64 string

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 <utility>
+#include <vector>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/path_utils.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/timer/elapsed_timer.h"
 #include "chrome/browser/android/shortcut_helper.h"
 #include "chrome/browser/android/webapk/chrome_webapk_host.h"
@@ skipping 15 matching lines @@
 #include "ui/gfx/color_utils.h"
 #include "url/gurl.h"
 
 namespace {
 
 // The default WebAPK server URL.
 const char kDefaultServerUrl[] =
     "https://webapk.googleapis.com/v1/webApks/"
     "?alt=proto&key=AIzaSyAoI6v-F31-3t9NunLYEiKcPIqgTJIUZBw";
 
+// The current file format version of the file for storing update requests.
+const int kCurrentUpdateFileFormatVersion = 1;
+
 // The MIME type of the POST data sent to the server.
 const 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;
 
 // Returns the WebAPK server URL based on the command line.
 GURL GetServerUrl() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
@@ skipping 42 matching lines @@
 
 // Populates the webapk::Image::image_data field of |image| with |icon|.
 void SetImageData(webapk::Image* image, const SkBitmap& icon) {
   std::vector<unsigned char> png_bytes;
   gfx::PNGCodec::EncodeBGRASkBitmap(icon, false, &png_bytes);
   image->set_image_data(&png_bytes.front(), png_bytes.size());
 }
 
 // Populates webapk::WebApk and returns it.
 // Must be called on a worker thread because it encodes an SkBitmap.
-std::unique_ptr<std::vector<uint8_t>> BuildProtoInBackground(
+std::unique_ptr<std::string> BuildProtoInBackground(
     const ShortcutInfo& shortcut_info,
     const SkBitmap& primary_icon,
     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,
     bool is_manifest_stale) {
   std::unique_ptr<webapk::WebApk> webapk(new webapk::WebApk);
   webapk->set_manifest_url(shortcut_info.manifest_url.spec());
   webapk->set_requester_application_package(
@@ skipping 43 matching lines @@
           shortcut_info.best_primary_icon_url) {
         SetImageData(image, badge_icon);
       }
       image->add_usages(webapk::Image::BADGE_ICON);
     }
     image->set_src(entry.first);
     image->set_hash(entry.second);
   }
 
   size_t serialized_size = webapk->ByteSize();
-  std::unique_ptr<std::vector<uint8_t>> serialized_proto =
-      base::MakeUnique<std::vector<uint8_t>>();
+  std::unique_ptr<std::string> serialized_proto =
+      base::MakeUnique<std::string>();
   serialized_proto->resize(serialized_size);
-  webapk->SerializeToArray(serialized_proto->data(), serialized_size);
+  webapk->SerializeToString(serialized_proto.get());
   return serialized_proto;
 }
 
+// Builds the WebAPK proto for an update or an install request and stores it
+// to |file|. Returns whether the proto was successfully written to disk.
+bool StoreUpdateRequestToDiskInBackground(
+    const base::FilePath& file,
+    const ShortcutInfo& shortcut_info,
+    const SkBitmap& primary_icon,
+    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,
+    bool is_manifest_stale) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
+  std::unique_ptr<std::string> proto = BuildProtoInBackground(
+      shortcut_info, primary_icon, badge_icon, package_name, version,
+      icon_url_to_murmur2_hash, is_manifest_stale);
+
+  base::Pickle to_store;
+  to_store.WriteInt(kCurrentUpdateFileFormatVersion);
+  to_store.WriteString(package_name);
+  to_store.WriteString(shortcut_info.url.spec());
+  to_store.WriteString16(shortcut_info.short_name);
+  to_store.WriteString(*proto);
+
+  // Create directory if it does not exist.
+  base::CreateDirectory(file.DirName());
+
+  int bytes_written = base::WriteFile(
+      file, static_cast<const char*>(to_store.data()), to_store.size());
+  return (bytes_written != -1);
+}
+
+// Reads |file| and returns contents. Must be called on a background thread.
+std::unique_ptr<std::string> ReadFileFromDiskInBackground(
+    const base::FilePath& file) {
+  base::ThreadRestrictions::AssertIOAllowed();
+  std::unique_ptr<std::string> update_request = base::MakeUnique<std::string>();
+  base::ReadFileToString(file, update_request.get());
+  return update_request;
+}
+
 // Returns task runner for running background tasks.
 scoped_refptr<base::TaskRunner> GetBackgroundTaskRunner() {
   return base::CreateTaskRunnerWithTraits(
       {base::MayBlock(), base::TaskPriority::BACKGROUND,
        base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
 }
 
 }  // anonymous namespace
 
 WebApkInstaller::~WebApkInstaller() {
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_WebApkInstaller_destroy(env, java_ref_);
   java_ref_.Reset();
 }
 
 // static
 void WebApkInstaller::InstallAsync(content::BrowserContext* context,
                                    const ShortcutInfo& shortcut_info,
                                    const SkBitmap& primary_icon,
                                    const SkBitmap& badge_icon,
                                    const FinishCallback& finish_callback) {
   // The installer will delete itself when it is done.
   WebApkInstaller* installer = new WebApkInstaller(context);
   installer->InstallAsync(shortcut_info, primary_icon, badge_icon,
                           finish_callback);
 }
 
 // static
-void WebApkInstaller::UpdateAsync(
-    content::BrowserContext* context,
-    const std::string& webapk_package,
-    const GURL& start_url,
-    const base::string16& short_name,
-    std::unique_ptr<std::vector<uint8_t>> serialized_proto,
-    const FinishCallback& finish_callback) {
+void WebApkInstaller::UpdateAsync(content::BrowserContext* context,
+                                  const base::FilePath& update_request_file,
+                                  const FinishCallback& finish_callback) {
   // The installer will delete itself when it is done.
   WebApkInstaller* installer = new WebApkInstaller(context);
-  installer->UpdateAsync(webapk_package, start_url, short_name,
-                         std::move(serialized_proto), finish_callback);
+  installer->UpdateAsync(update_request_file, finish_callback);
 }
 
 // static
 void WebApkInstaller::InstallAsyncForTesting(WebApkInstaller* installer,
                                              const ShortcutInfo& shortcut_info,
                                              const SkBitmap& primary_icon,
                                              const SkBitmap& badge_icon,
                                              const FinishCallback& callback) {
   installer->InstallAsync(shortcut_info, primary_icon, badge_icon, callback);
 }
 
 // static
 void WebApkInstaller::UpdateAsyncForTesting(
     WebApkInstaller* installer,
-    const std::string& webapk_package,
-    const GURL& start_url,
-    const base::string16& short_name,
-    std::unique_ptr<std::vector<uint8_t>> serialized_proto,
+    const base::FilePath& update_request_file,
     const FinishCallback& finish_callback) {
-  installer->UpdateAsync(webapk_package, start_url, short_name,
-                         std::move(serialized_proto), finish_callback);
+  installer->UpdateAsync(update_request_file, finish_callback);
 }
 
 void WebApkInstaller::SetTimeoutMs(int timeout_ms) {
   webapk_server_timeout_ms_ = timeout_ms;
 }
 
 void WebApkInstaller::OnInstallFinished(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     jint result) {
   OnResult(static_cast<WebApkInstallResult>(result));
 }
 
 // static
 void WebApkInstaller::BuildProto(
     const ShortcutInfo& shortcut_info,
     const SkBitmap& primary_icon,
     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,
     bool is_manifest_stale,
-    const base::Callback<void(std::unique_ptr<std::vector<uint8_t>>)>&
-        callback) {
+    const base::Callback<void(std::unique_ptr<std::string>)>& callback) {
   base::PostTaskAndReplyWithResult(
       GetBackgroundTaskRunner().get(), FROM_HERE,
       base::Bind(&BuildProtoInBackground, shortcut_info, primary_icon,
                  badge_icon, package_name, version, icon_url_to_murmur2_hash,
                  is_manifest_stale),
       callback);
 }
 
+// static
+void WebApkInstaller::StoreUpdateRequestToDisk(
+    const base::FilePath& file,
+    const ShortcutInfo& shortcut_info,
+    const SkBitmap& primary_icon,
+    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,
+    bool is_manifest_stale,
+    const base::Callback<void(bool)> callback) {
+  base::PostTaskAndReplyWithResult(
+      GetBackgroundTaskRunner().get(), FROM_HERE,
+      base::Bind(&StoreUpdateRequestToDiskInBackground, file, shortcut_info,
+                 primary_icon, badge_icon, package_name, version,
+                 icon_url_to_murmur2_hash, is_manifest_stale),
+      callback);
+}
+
 void WebApkInstaller::InstallOrUpdateWebApk(const std::string& package_name,
                                             int version,
                                             const std::string& token) {
   webapk_package_ = package_name;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jstring> java_webapk_package =
       base::android::ConvertUTF8ToJavaString(env, webapk_package_);
   base::android::ScopedJavaLocalRef<jstring> java_title =
       base::android::ConvertUTF16ToJavaString(env, short_name_);
@@ skipping 68 matching lines @@
   // 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.
   WebApkIconHasher::DownloadAndComputeMurmur2Hash(
       request_context_getter_, install_shortcut_info_->best_primary_icon_url,
       base::Bind(&WebApkInstaller::OnGotPrimaryIconMurmur2Hash,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void WebApkInstaller::UpdateAsync(
-    const std::string& webapk_package,
-    const GURL& start_url,
-    const base::string16& short_name,
-    std::unique_ptr<std::vector<uint8_t>> serialized_proto,
-    const FinishCallback& finish_callback) {
-  webapk_package_ = webapk_package;
-  start_url_ = start_url;
-  short_name_ = short_name;
+void WebApkInstaller::UpdateAsync(const base::FilePath& update_request_file,
+                                  const FinishCallback& finish_callback) {
   finish_callback_ = finish_callback;
   task_type_ = UPDATE;
 
-  if (!serialized_proto || serialized_proto->empty()) {
+  base::PostTaskAndReplyWithResult(
+      GetBackgroundTaskRunner().get(), FROM_HERE,
+      base::Bind(&ReadFileFromDiskInBackground, update_request_file),
+      base::Bind(&WebApkInstaller::OnReadUpdateRequest,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void WebApkInstaller::OnReadUpdateRequest(
+    std::unique_ptr<std::string> update_request) {
+  base::Pickle pickle(update_request->data(), update_request->size());
+  base::PickleIterator pickle_iterator(pickle);
+  int version = 0;
+  std::string webapk_package;
+  std::string start_url;
+  base::string16 short_name;
+  std::unique_ptr<std::string> serialized_proto =
+      base::MakeUnique<std::string>();
+  if (!pickle_iterator.ReadInt(&version) ||
+      !pickle_iterator.ReadString(&webapk_package) ||
+      !pickle_iterator.ReadString(&start_url) ||
+      !pickle_iterator.ReadString16(&short_name) ||
+      !pickle_iterator.ReadString(serialized_proto.get())) {
+    OnResult(WebApkInstallResult::FAILURE);
+    return;
+  }
+  if (version != kCurrentUpdateFileFormatVersion || serialized_proto->empty()) {
     OnResult(WebApkInstallResult::FAILURE);
     return;
   }
 
+  webapk_package_ = webapk_package;
+  start_url_ = GURL(start_url);
+  short_name_ = short_name;
   SendRequest(std::move(serialized_proto));
 }
 
 void WebApkInstaller::OnURLFetchComplete(const net::URLFetcher* source) {
   timer_.Stop();
 
   if (!source->GetStatus().is_success() ||
       source->GetResponseCode() != net::HTTP_OK) {
     LOG(WARNING) << base::StringPrintf(
         "WebAPK server returned response code %d.", source->GetResponseCode());
@@ skipping 73 matching lines @@
   }
 
   BuildProto(*install_shortcut_info_, install_primary_icon_,
              install_badge_icon_, "" /* package_name */, "" /* version */,
              icon_url_to_murmur2_hash, false /* is_manifest_stale */,
              base::Bind(&WebApkInstaller::SendRequest,
                         weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebApkInstaller::SendRequest(
-    std::unique_ptr<std::vector<uint8_t>> serialized_proto) {
+    std::unique_ptr<std::string> serialized_proto) {
   timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(webapk_server_timeout_ms_),
       base::Bind(&WebApkInstaller::OnResult, weak_ptr_factory_.GetWeakPtr(),
                  WebApkInstallResult::FAILURE));
 
-  std::string serialized_proto_string(serialized_proto->begin(),
-                                      serialized_proto->end());
-
   url_fetcher_ =
       net::URLFetcher::Create(server_url_, net::URLFetcher::POST, this);
   url_fetcher_->SetRequestContext(request_context_getter_);
-  url_fetcher_->SetUploadData(kProtoMimeType, serialized_proto_string);
+  url_fetcher_->SetUploadData(kProtoMimeType, *serialized_proto);
   url_fetcher_->SetLoadFlags(
       net::LOAD_DISABLE_CACHE | net::LOAD_DO_NOT_SEND_COOKIES |
       net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_DO_NOT_SEND_AUTH_DATA);
   url_fetcher_->Start();
 }