Get rid of FrameMsg_PostMessage_Params.is_data_raw_string.

Instead use the helper method we already have to just convert a raw
string to a serialized string value encoded byte array on the browser
side. This gets rid of some special casing and possible confusion in
this codepath.

Does requre moving string_message_codec to some non-android specific
location (even though this code is only really used on android), and for
that blink/common seemed like a sensible place.

Bug: none
Change-Id: I4ebc70cb68a1c12ad57d3949a1ac606392f7c908
Reviewed-on: https://chromium-review.googlesource.com/1053169Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Marijn Kruisselbrink <mek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#557363}

content/browser/BUILD.gn

@@ -325,8 +325,6 @@ jumbo_source_set("browser") {
     "android/launcher_thread.h",
     "android/scoped_surface_request_manager.cc",
     "android/scoped_surface_request_manager.h",
-    "android/string_message_codec.cc",
-    "android/string_message_codec.h",
     "android/text_suggestion_host_android.cc",
     "android/text_suggestion_host_android.h",
     "android/text_suggestion_host_mojo_impl_android.cc",

content/browser/android/app_web_message_port.cc

@@ -9,8 +9,8 @@
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "content/browser/android/string_message_codec.h"
 #include "jni/AppWebMessagePort_jni.h"
+#include "third_party/blink/public/common/message_port/string_message_codec.h"
 
 using blink::MessagePortChannel;
 
@@ -44,7 +44,7 @@ JNI_AppWebMessagePort_DecodeStringMessage(
                                            &encoded_message);
 
   base::string16 message;
-  if (!DecodeStringMessage(encoded_message, &message))
+  if (!blink::DecodeStringMessage(encoded_message, &message))
     return nullptr;
 
   base::android::ScopedJavaLocalRef<jstring> jmessage =
@@ -57,8 +57,8 @@ JNI_AppWebMessagePort_EncodeStringMessage(
     JNIEnv* env,
     const base::android::JavaParamRef<jclass>& jcaller,
     const base::android::JavaParamRef<jstring>& jmessage) {
-  std::vector<uint8_t> encoded_message =
-      EncodeStringMessage(base::android::ConvertJavaStringToUTF16(jmessage));
+  std::vector<uint8_t> encoded_message = blink::EncodeStringMessage(
+      base::android::ConvertJavaStringToUTF16(jmessage));
   return base::android::ToJavaByteArray(env, encoded_message);
 }
 

content/browser/message_port_provider.cc

@@ -9,6 +9,7 @@
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/browser_thread.h"
+#include "third_party/blink/public/common/message_port/string_message_codec.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/jni_string.h"
@@ -28,11 +29,10 @@ void PostMessageToFrameInternal(WebContents* web_contents,
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   FrameMsg_PostMessage_Params params;
-  params.is_data_raw_string = true;
   params.message = new base::RefCountedData<blink::TransferableMessage>();
+  params.message->data.owned_encoded_message = blink::EncodeStringMessage(data);
   params.message->data.encoded_message =
-      base::make_span(reinterpret_cast<const uint8_t*>(data.data()),
-                      data.size() * sizeof(base::char16));
+      params.message->data.owned_encoded_message;
   params.message->data.ports = std::move(channels);
   params.source_routing_id = MSG_ROUTING_NONE;
   params.source_origin = source_origin;

content/common/frame_messages.h

@@ -431,11 +431,6 @@ IPC_STRUCT_BEGIN_WITH_PARENT(FrameHostMsg_DidCommitProvisionalLoad_Params,
 IPC_STRUCT_END()
 
 IPC_STRUCT_BEGIN(FrameMsg_PostMessage_Params)
-  // Whether the data format is supplied as serialized script value, or as
-  // a simple string. If it is a raw string, must be converted from string to a
-  // WebSerializedScriptValue in the renderer process.
-  IPC_STRUCT_MEMBER(bool, is_data_raw_string)
-
   // When sent to the browser, this is the routing ID of the source frame in
   // the source process.  The browser replaces it with the routing ID of the
   // equivalent frame proxy in the destination process.

content/renderer/render_frame_impl.cc

@@ -2297,33 +2297,9 @@ void RenderFrameImpl::OnPostMessageEvent(
         WebString::FromUTF16(params.target_origin));
   }
 
-  WebDOMMessageEvent msg_event;
-  if (params.is_data_raw_string) {
-    v8::Isolate* isolate = blink::MainThreadIsolate();
-    v8::HandleScope handle_scope(isolate);
-    v8::Local<v8::Context> context = frame_->MainWorldScriptContext();
-    v8::Context::Scope context_scope(context);
-    V8ValueConverterImpl converter;
-    converter.SetDateAllowed(true);
-    converter.SetRegExpAllowed(true);
-    base::string16 data;
-    data.resize(params.message->data.encoded_message.size() /
-                sizeof(base::char16));
-    std::memcpy(&data[0], params.message->data.encoded_message.data(),
-                data.length() * sizeof(base::char16));
-    base::Value value(data);
-    v8::Local<v8::Value> result_value = converter.ToV8Value(&value, context);
-    WebSerializedScriptValue serialized_script_value =
-        WebSerializedScriptValue::Serialize(isolate, result_value);
-    msg_event = WebDOMMessageEvent(serialized_script_value,
-                                   WebString::FromUTF16(params.source_origin),
-                                   source_frame, frame_->GetDocument(),
-                                   std::move(params.message->data.ports));
-  } else {
-    msg_event = WebDOMMessageEvent(std::move(params.message->data),
-                                   WebString::FromUTF16(params.source_origin),
-                                   source_frame, frame_->GetDocument());
-  }
+  WebDOMMessageEvent msg_event(std::move(params.message->data),
+                               WebString::FromUTF16(params.source_origin),
+                               source_frame, frame_->GetDocument());
 
   frame_->DispatchMessageEventWithOriginCheck(
       target_origin, msg_event, params.message->data.has_user_gesture);

content/renderer/render_frame_proxy.cc

@@ -734,7 +734,6 @@ void RenderFrameProxy::ForwardPostMessage(
   DCHECK(!web_frame_ || web_frame_ == target_frame);
 
   FrameMsg_PostMessage_Params params;
-  params.is_data_raw_string = false;
   params.message =
       new base::RefCountedData<blink::TransferableMessage>(event.AsMessage());
   params.message->data.has_user_gesture = has_user_gesture;

content/test/BUILD.gn

@@ -1954,7 +1954,6 @@ test("content_unittests") {
       "../browser/android/java/java_type_unittest.cc",
       "../browser/android/overscroll_controller_android_unittest.cc",
       "../browser/android/scoped_surface_request_manager_unittest.cc",
-      "../browser/android/string_message_codec_unittest.cc",
       "../browser/android/url_request_content_job_unittest.cc",
       "../browser/media/capture/screen_capture_device_android_unittest.cc",
       "../renderer/java/gin_java_bridge_value_converter_unittest.cc",

third_party/blink/common/BUILD.gn

@@ -25,6 +25,7 @@ jumbo_source_set("common") {
     "message_port/cloneable_message_struct_traits.cc",
     "message_port/cloneable_message_struct_traits.h",
     "message_port/message_port_channel.cc",
+    "message_port/string_message_codec.cc",
     "message_port/transferable_message.cc",
     "message_port/transferable_message_struct_traits.cc",
     "message_port/transferable_message_struct_traits.h",
@@ -64,6 +65,7 @@ jumbo_source_set("common_unittests_sources") {
   sources = [
     "device_memory/approximated_device_memory_unittest.cc",
     "feature_policy/feature_policy_unittest.cc",
+    "message_port/string_message_codec_unittest.cc",
     "mime_util/mime_util_unittest.cc",
     "origin_manifest/origin_manifest_unittest.cc",
     "origin_trials/trial_token_unittest.cc",
@@ -78,5 +80,7 @@ jumbo_source_set("common_unittests_sources") {
     "//testing/gtest",
     "//third_party/blink/public/common:headers",
     "//third_party/boringssl",
+    "//v8",
+    "//v8:v8_libplatform",
   ]
 }

third_party/blink/common/DEPS

@@ -18,3 +18,6 @@ include_rules = [
     "+third_party/blink/public/mojom",
     "+url",
 ]
+specific_include_rules = {
+  '.*unittest.?.cc': [ "+v8" ],
+}

content/browser/android/string_message_codec.cc → third_party/blink/common/message_port/string_message_codec.cc

@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/android/string_message_codec.h"
+#include "third_party/blink/public/common/message_port/string_message_codec.h"
 
 #include <vector>
 
 #include "base/logging.h"
 
-namespace content {
+namespace blink {
 namespace {
 
 const uint32_t kVarIntShift = 7;
@@ -46,7 +46,8 @@ void WriteUint32(uint32_t value, std::vector<uint8_t>* buffer) {
   }
 }
 
-void WriteBytes(const char* bytes, size_t num_bytes,
+void WriteBytes(const char* bytes,
+                size_t num_bytes,
                 std::vector<uint8_t>* buffer) {
   buffer->insert(buffer->end(), bytes, bytes + num_bytes);
 }
@@ -79,7 +80,7 @@ bool ContainsOnlyLatin1(const base::string16& data) {
   return !(x & 0xFF00);
 }
 
-} // namespace
+}  // namespace
 
 std::vector<uint8_t> EncodeStringMessage(const base::string16& data) {
   std::vector<uint8_t> buffer;
@@ -142,4 +143,4 @@ bool DecodeStringMessage(const std::vector<uint8_t>& encoded_data,
   return false;
 }
 
-}  // namespace content
+}  // namespace blink

content/browser/android/string_message_codec_unittest.cc → third_party/blink/common/message_port/string_message_codec_unittest.cc

@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/android/string_message_codec.h"
+#include "third_party/blink/public/common/message_port/string_message_codec.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_task_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
-namespace content {
+namespace blink {
 namespace {
 
 base::string16 DecodeWithV8(const std::vector<uint8_t>& encoded) {
@@ -59,10 +59,9 @@ std::vector<uint8_t> EncodeWithV8(const base::string16& message) {
     v8::Local<v8::Context> context = v8::Context::New(isolate);
 
     v8::Local<v8::String> message_as_value =
-        v8::String::NewFromTwoByte(isolate,
-                                   message.data(),
-                                   v8::NewStringType::kNormal,
-                                   message.size()).ToLocalChecked();
+        v8::String::NewFromTwoByte(isolate, message.data(),
+                                   v8::NewStringType::kNormal, message.size())
+            .ToLocalChecked();
 
     v8::ValueSerializer serializer(isolate);
     serializer.WriteHeader();
@@ -136,4 +135,4 @@ TEST(StringMessageCodecTest, V8ToSelfTest_NonASCIILongEnoughToForcePadding) {
 }
 
 }  // namespace
-}  // namespace content
+}  // namespace blink

third_party/blink/common/test/run_all_unittests.cc

@@ -8,10 +8,18 @@
 
 #include "base/bind.h"
 #include "base/test/test_suite.h"
+#include "v8/include/libplatform/libplatform.h"
+#include "v8/include/v8.h"
 
 int main(int argc, char** argv) {
   base::TestSuite test_suite(argc, argv);
 
+  v8::V8::InitializeICUDefaultLocation(argv[0]);
+  v8::V8::InitializeExternalStartupData(argv[0]);
+  auto platform = base::WrapUnique(v8::platform::CreateDefaultPlatform());
+  v8::V8::InitializePlatform(platform.get());
+  v8::V8::Initialize();
+
   return base::LaunchUnitTests(
       argc, argv,
       base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));

third_party/blink/public/common/BUILD.gn

@@ -41,6 +41,7 @@ source_set("headers") {
     "frame/sandbox_flags.h",
     "message_port/cloneable_message.h",
     "message_port/message_port_channel.h",
+    "message_port/string_message_codec.h",
     "message_port/transferable_message.h",
     "mime_util/mime_util.h",
     "origin_manifest/origin_manifest.h",

content/browser/android/string_message_codec.h → third_party/blink/public/common/message_port/string_message_codec.h

@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_ANDROID_STRING_MESSAGE_CODEC_H_
-#define CONTENT_BROWSER_ANDROID_STRING_MESSAGE_CODEC_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_COMMON_MESSAGE_PORT_STRING_MESSAGE_CODEC_H_
+#define THIRD_PARTY_BLINK_PUBLIC_COMMON_MESSAGE_PORT_STRING_MESSAGE_CODEC_H_
 
 #include <vector>
 #include "base/strings/string16.h"
-#include "content/common/content_export.h"
+#include "third_party/blink/common/common_export.h"
 
-namespace content {
+namespace blink {
 
 // To support exposing HTML message ports to Java, it is necessary to be able
 // to encode and decode message data using the same serialization format as V8.
@@ -21,13 +21,13 @@ namespace content {
 // handle string messages and this serialization format is static, as it is a
 // format we currently persist to disk via IndexedDB.
 
-CONTENT_EXPORT std::vector<uint8_t> EncodeStringMessage(
+BLINK_COMMON_EXPORT std::vector<uint8_t> EncodeStringMessage(
     const base::string16& data);
 
-CONTENT_EXPORT bool DecodeStringMessage(
+BLINK_COMMON_EXPORT bool DecodeStringMessage(
     const std::vector<uint8_t>& encoded_data,
     base::string16* result);
 
-}  // namespace content
+}  // namespace blink
 
-#endif  // CONTENT_BROWSER_ANDROID_STRING_MESSAGE_CODEC_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_COMMON_MESSAGE_PORT_STRING_MESSAGE_CODEC_H_