[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/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.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"
@@ skipping 81 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 42 matching lines @@
       if (shortcut_info.best_badge_icon_url !=
           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>>();
-  serialized_proto->resize(serialized_size);
-  webapk->SerializeToArray(serialized_proto->data(), serialized_size);
-  return serialized_proto;
+  std::string serialized_proto;

[dominickn, 2017/06/20 01:07:21]

Base64Encode can be run in place, which will save a string allocation. Can you
do:

auto serialized_proto = base::MakeUnique<std::string>();
webapk->SerializeToString(&serialized_proto.get());
 base::Base64Encode(serialized_proto.get(), serialized_proto.get());

[pkotwicz, 2017/06/20 22:18:26]

I can do this change. However, this does not decrease the number of string
allocations since base::Base64Encode() does a copy internally

[dominickn, 2017/06/21 04:13:49]

I meant that you'll save one of |serialized_proto| and |base64_serialized_proto|
from being allocated when they're default-constructed (we only use one instead
of both). I'm not overly fussed though.

+  webapk->SerializeToString(&serialized_proto);
+  std::unique_ptr<std::string> base64_serialized_proto =
+      base::MakeUnique<std::string>();
+  base::Base64Encode(serialized_proto, base64_serialized_proto.get());
+  return base64_serialized_proto;
 }
 
 // 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
@@ skipping 10 matching lines @@
                                    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 std::string& webapk_package,
+                                  const GURL& start_url,
+                                  const base::string16& short_name,
+                                  std::unique_ptr<std::string> serialized_proto,
+                                  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);
 }
 
 // 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,
+    std::unique_ptr<std::string> serialized_proto,
     const FinishCallback& finish_callback) {
   installer->UpdateAsync(webapk_package, start_url, short_name,
                          std::move(serialized_proto), 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
 bool WebApkInstaller::Register(JNIEnv* env) {
@@ skipping 81 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) {
+void WebApkInstaller::UpdateAsync(const std::string& webapk_package,
+                                  const GURL& start_url,
+                                  const base::string16& short_name,
+                                  std::unique_ptr<std::string> serialized_proto,
+                                  const FinishCallback& finish_callback) {
   webapk_package_ = webapk_package;
   start_url_ = start_url;
   short_name_ = short_name;
   finish_callback_ = finish_callback;
   task_type_ = UPDATE;
 
   if (!serialized_proto || serialized_proto->empty()) {
     OnResult(WebApkInstallResult::FAILURE);
     return;
   }
@@ skipping 84 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());
+  std::string decoded_proto;
+  base::Base64Decode(*serialized_proto, &decoded_proto);
 
   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, decoded_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();
 }