[JJI] Convert to use string16 for data from JavaScript/Java

Since both Java and JavaScript uses UTF16 strings, makes it more
compatible to use base::string16 in C++.

Per comment from http://crrev/c/1719453.

Bug: 918065
Change-Id: Ie979c0e400604ec2230bd7cb8319dc74f39616e3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1750093
Commit-Queue: Shimi Zhang <ctzsm@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: Changwan Ryu <changwan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#686511}

android_webview/browser/js_java_interaction/js_api_handler.cc

@@ -24,7 +24,7 @@ void JsApiHandler::BindPendingReceiver(
 }
 
 void JsApiHandler::PostMessage(
-    const std::string& message,
+    const base::string16& message,
     std::vector<mojo::ScopedMessagePipeHandle> ports) {
   DCHECK(render_frame_host_);
 
@@ -50,7 +50,7 @@ void JsApiHandler::PostMessage(
 
   JNIEnv* env = base::android::AttachCurrentThread();
   aw_contents->OnPostMessage(
-      env, base::android::ConvertUTF8ToJavaString(env, message),
+      env, base::android::ConvertUTF16ToJavaString(env, message),
       base::android::ConvertUTF8ToJavaString(env, source_origin.Serialize()),
       web_contents->GetMainFrame() == render_frame_host_,
       base::android::ToJavaIntArray(env, int_ports.data(), int_ports.size()));

android_webview/browser/js_java_interaction/js_api_handler.h

@@ -5,10 +5,10 @@
 #ifndef ANDROID_WEBVIEW_BROWSER_JS_JAVA_INTERACTION_JS_API_HANDLER_H_
 #define ANDROID_WEBVIEW_BROWSER_JS_JAVA_INTERACTION_JS_API_HANDLER_H_
 
-#include <string>
 #include <vector>
 
 #include "android_webview/common/js_java_interaction/interfaces.mojom.h"
+#include "base/strings/string16.h"
 #include "mojo/public/cpp/bindings/associated_receiver.h"
 #include "mojo/public/cpp/bindings/associated_remote.h"
 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
@@ -32,7 +32,7 @@ class JsApiHandler : public mojom::JsApiHandler {
       mojo::PendingAssociatedReceiver<mojom::JsApiHandler> pending_receiver);
 
   // mojom::JsApiHandler implementation.
-  void PostMessage(const std::string& message,
+  void PostMessage(const base::string16& message,
                    std::vector<mojo::ScopedMessagePipeHandle> ports) override;
 
  private:

android_webview/browser/js_java_interaction/js_java_configurator_host.cc

@@ -28,16 +28,14 @@ JsJavaConfiguratorHost::SetJsApiService(
     bool need_to_inject_js_object,
     const base::android::JavaParamRef<jstring>& js_object_name,
     const base::android::JavaParamRef<jobjectArray>& allowed_origin_rules) {
-  std::string native_js_object_name;
-  base::android::ConvertJavaStringToUTF8(env, js_object_name,
-                                         &native_js_object_name);
+  base::android::ConvertJavaStringToUTF16(env, js_object_name,
+                                          &js_object_name_);
 
   std::vector<std::string> native_allowed_origin_rules;
   AppendJavaStringArrayToStringVector(env, allowed_origin_rules,
                                       &native_allowed_origin_rules);
 
   need_to_inject_js_object_ = need_to_inject_js_object;
-  js_object_name_ = native_js_object_name;
   allowed_origin_rules_ = net::ProxyBypassRules();
   for (auto& rule : native_allowed_origin_rules) {
     if (!allowed_origin_rules_.AddRuleFromString(rule)) {

android_webview/browser/js_java_interaction/js_java_configurator_host.h

@@ -5,11 +5,9 @@
 #ifndef ANDROID_WEBVIEW_BROWSER_JS_JAVA_INTERACTION_JS_JAVA_CONFIGURATOR_HOST_H_
 #define ANDROID_WEBVIEW_BROWSER_JS_JAVA_INTERACTION_JS_JAVA_CONFIGURATOR_HOST_H_
 
-#include <string>
-#include <vector>
-
 #include "android_webview/common/js_java_interaction/interfaces.mojom.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/strings/string16.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "net/proxy_resolution/proxy_bypass_rules.h"
 #include "services/network/public/mojom/proxy_config.mojom.h"
@@ -46,7 +44,7 @@ class JsJavaConfiguratorHost : public content::WebContentsObserver {
   void NotifyFrame(content::RenderFrameHost* render_frame_host);
 
   bool need_to_inject_js_object_ = false;
-  std::string js_object_name_;
+  base::string16 js_object_name_;
   // We use ProxyBypassRules because it has the functionality that suitable
   // here, but it is not for proxy bypass.
   net::ProxyBypassRules allowed_origin_rules_;

android_webview/common/js_java_interaction/interfaces.mojom

@@ -4,6 +4,7 @@
 
 module android_webview.mojom;
 
+import "mojo/public/mojom/base/string16.mojom";
 import "services/network/public/mojom/proxy_config.mojom";
 
 // For JavaScript postMessage() API, implemented by browser.
@@ -12,7 +13,8 @@ interface JsApiHandler {
   // the current frame |origin|.
   // The |message| is an opaque type and the contents are defined by the client
   // of this API.
-  PostMessage(string message, array<handle<message_pipe>> ports);
+  PostMessage(mojo_base.mojom.String16 message,
+              array<handle<message_pipe>> ports);
 };
 
 // For browser to configure renderer, implemented by renderer.
@@ -21,6 +23,7 @@ interface JsJavaConfigurator {
   // a JavaScript object with the given |js_object_name| based on
   // |need_to_inject_js_object| flag. Only frames with the origin matches
   // |allowed_origin_rules| will have the object injected.
-  SetJsApiService(bool need_to_inject_js_object, string js_object_name,
+  SetJsApiService(bool need_to_inject_js_object,
+                  mojo_base.mojom.String16 js_object_name,
                   network.mojom.ProxyBypassRules allowed_origin_rules);
 };
\ No newline at end of file

android_webview/renderer/js_java_interaction/js_binding.cc

@@ -4,7 +4,6 @@
 
 #include "android_webview/renderer/js_java_interaction/js_binding.h"
 
-#include <string>
 #include <vector>
 
 #include "base/strings/string_util.h"
@@ -32,7 +31,7 @@ gin::WrapperInfo JsBinding::kWrapperInfo = {gin::kEmbedderNativeGin};
 // static
 std::unique_ptr<JsBinding> JsBinding::Install(
     content::RenderFrame* render_frame,
-    const std::string& js_object_name) {
+    const base::string16& js_object_name) {
   CHECK(!js_object_name.empty())
       << "JavaScript wrapper name shouldn't be empty";
 
@@ -72,7 +71,7 @@ gin::ObjectTemplateBuilder JsBinding::GetObjectTemplateBuilder(
 }
 
 void JsBinding::PostMessage(gin::Arguments* args) {
-  std::string message;
+  base::string16 message;
   if (!args->GetNext(&message)) {
     args->ThrowError();
     return;

android_webview/renderer/js_java_interaction/js_binding.h

@@ -9,6 +9,7 @@
 
 #include "android_webview/common/js_java_interaction/interfaces.mojom.h"
 #include "base/auto_reset.h"
+#include "base/strings/string16.h"
 #include "gin/arguments.h"
 #include "gin/wrappable.h"
 #include "mojo/public/cpp/bindings/associated_remote.h"
@@ -27,8 +28,9 @@ namespace android_webview {
 class JsBinding : public gin::Wrappable<JsBinding> {
  public:
   static gin::WrapperInfo kWrapperInfo;
-  static std::unique_ptr<JsBinding> Install(content::RenderFrame* render_frame,
-                                            const std::string& js_object_name);
+  static std::unique_ptr<JsBinding> Install(
+      content::RenderFrame* render_frame,
+      const base::string16& js_object_name);
 
   ~JsBinding() final;
 

android_webview/renderer/js_java_interaction/js_java_configurator.cc

@@ -25,7 +25,7 @@ JsJavaConfigurator::~JsJavaConfigurator() = default;
 
 void JsJavaConfigurator::SetJsApiService(
     bool need_to_inject_js_object,
-    const std::string& js_object_name,
+    const base::string16& js_object_name,
     const net::ProxyBypassRules& allowed_origin_rules) {
   need_to_inject_js_object_ = need_to_inject_js_object;
   js_object_name_ = js_object_name;

android_webview/renderer/js_java_interaction/js_java_configurator.h

@@ -5,10 +5,8 @@
 #ifndef ANDROID_WEBVIEW_RENDERER_JS_JAVA_INTERACTION_JS_JAVA_CONFIGURATOR_H_
 #define ANDROID_WEBVIEW_RENDERER_JS_JAVA_INTERACTION_JS_JAVA_CONFIGURATOR_H_
 
-#include <string>
-#include <vector>
-
 #include "android_webview/common/js_java_interaction/interfaces.mojom.h"
+#include "base/strings/string16.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "mojo/public/cpp/bindings/associated_receiver.h"
 #include "net/proxy_resolution/proxy_bypass_rules.h"
@@ -30,7 +28,7 @@ class JsJavaConfigurator : public mojom::JsJavaConfigurator,
   // mojom::Configurator implementation
   void SetJsApiService(
       bool inject_js_object,
-      const std::string& js_object_name,
+      const base::string16& js_object_name,
       const net::ProxyBypassRules& allowed_origin_rules) override;
 
   // RenderFrameObserver implementation
@@ -45,7 +43,7 @@ class JsJavaConfigurator : public mojom::JsJavaConfigurator,
   bool IsOriginMatch();
 
   bool need_to_inject_js_object_ = false;
-  std::string js_object_name_;
+  base::string16 js_object_name_;
   // We use ProxyBypassRules because it has the functionality that suitable
   // here, but it is not for proxy bypass.
   net::ProxyBypassRules js_object_allowed_origin_rules_;

gin/converter.cc

@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 
+#include "base/strings/string_util.h"
 #include "v8/include/v8.h"
 
 using v8::ArrayBuffer;
@@ -151,6 +152,29 @@ bool Converter<std::string>::FromV8(Isolate* isolate,
   return true;
 }
 
+Local<Value> Converter<base::string16>::ToV8(Isolate* isolate,
+                                             const base::string16& val) {
+  return String::NewFromTwoByte(isolate,
+                                reinterpret_cast<const uint16_t*>(val.data()),
+                                v8::NewStringType::kNormal, val.size())
+      .ToLocalChecked();
+}
+
+bool Converter<base::string16>::FromV8(Isolate* isolate,
+                                       Local<Value> val,
+                                       base::string16* out) {
+  if (!val->IsString())
+    return false;
+  Local<String> str = Local<String>::Cast(val);
+  int length = str->Length();
+  // Note that the reinterpret cast is because on Windows string16 is an alias
+  // to wstring, and hence has character type wchar_t not uint16_t.
+  str->Write(isolate,
+             reinterpret_cast<uint16_t*>(base::WriteInto(out, length + 1)), 0,
+             length);
+  return true;
+}
+
 Local<Value> Converter<Local<Function>>::ToV8(Isolate* isolate,
                                               Local<Function> val) {
   return val.As<Value>();
@@ -240,6 +264,14 @@ v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
       .ToLocalChecked();
 }
 
+v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
+                                     const base::StringPiece16& val) {
+  return String::NewFromTwoByte(isolate,
+                                reinterpret_cast<const uint16_t*>(val.data()),
+                                v8::NewStringType::kInternalized, val.length())
+      .ToLocalChecked();
+}
+
 std::string V8ToString(v8::Isolate* isolate, v8::Local<v8::Value> value) {
   if (value.IsEmpty())
     return std::string();

gin/converter.h

@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "base/logging.h"
+#include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "gin/gin_export.h"
 #include "v8/include/v8.h"
@@ -119,8 +120,17 @@ struct GIN_EXPORT Converter<std::string> {
                      std::string* out);
 };
 
-template<>
-struct GIN_EXPORT Converter<v8::Local<v8::Function> > {
+template <>
+struct GIN_EXPORT Converter<base::string16> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const base::string16& val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     base::string16* out);
+};
+
+template <>
+struct GIN_EXPORT Converter<v8::Local<v8::Function>> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    v8::Local<v8::Function> val);
   static bool FromV8(v8::Isolate* isolate,
@@ -263,6 +273,10 @@ GIN_EXPORT inline v8::Local<v8::String> StringToV8(
 GIN_EXPORT v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
                                                  const base::StringPiece& val);
 
+// This crashes when input.size() > v8::String::kMaxLength.
+GIN_EXPORT v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
+                                                const base::StringPiece16& val);
+
 template<typename T>
 bool ConvertFromV8(v8::Isolate* isolate, v8::Local<v8::Value> input,
                    T* result) {