Use array<uint8> rather than string to pass BroadcastChannel messages.

third_party/WebKit/Source/modules/broadcastchannel/BroadcastChannel.cpp

 // 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 "modules/broadcastchannel/BroadcastChannel.h"
 
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/events/EventQueue.h"
 #include "core/events/MessageEvent.h"
@@ skipping 45 matching lines @@
 void BroadcastChannel::postMessage(const ScriptValue& message, ExceptionState& exceptionState)
 {
     if (!m_binding.is_bound()) {
         exceptionState.throwDOMException(InvalidStateError, "Channel is closed");
         return;
     }
     RefPtr<SerializedScriptValue> value = SerializedScriptValue::serialize(message.isolate(), message.v8Value(), nullptr, nullptr, exceptionState);
     if (exceptionState.hadException())
         return;
 
-    String data = value->toWireString();
-    m_remoteClient->OnMessage(data);
+    Vector<char> data;

[esprehn, 2016/07/23 08:53:50]

you want to call reserveInitialCapacity on both of these vectors to avoid
resizes and copies. :)

[Marijn Kruisselbrink, 2016/07/23 19:14:18]

Not sure what resized and copies that would avoid?
SerializedScriptValue::toWireBytes resizes the output vector appropriately
before adding anything to it, and similarly Vector::appendVector resizes before
appending all the data. So both these vectors will only get resized once anyway.
Maybe it would make sense to add a
SerializedScriptValue::toWireBytes(Vector<uint8_t>&) overload to avoid having to
go through the extra Vector<char>, as that's a copy that really shouldn't be
necessary.

+    value->toWireBytes(data);
+    Vector<uint8_t> mojoData;
+    mojoData.appendVector(data);

[dcheng, 2016/07/22 02:33:03]

It's sad that this results in copying the data now, especially since we're just
going from char to uint8_t...

[Marijn Kruisselbrink, 2016/07/22 03:23:12]

Yeah... but reinterpret_casting a Vector didn't seem like a great idea either. I
don't think this copy is really going to matter too much for the overall
performance anyway.

+    m_remoteClient->OnMessage(std::move(mojoData));
 }
 
 void BroadcastChannel::close()
 {
     m_remoteClient.reset();
     if (m_binding.is_bound())
         m_binding.Close();
 }
 
 const AtomicString& BroadcastChannel::interfaceName() const
@@ skipping 10 matching lines @@
 {
     close();
 }
 
 DEFINE_TRACE(BroadcastChannel)
 {
     ContextLifecycleObserver::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
 }
 
-void BroadcastChannel::OnMessage(const String& message)
+void BroadcastChannel::OnMessage(mojo::WTFArray<uint8_t> message)
 {
     // Queue a task to dispatch the event.
-    RefPtr<SerializedScriptValue> value = SerializedScriptValue::create(message);
+    RefPtr<SerializedScriptValue> value = SerializedScriptValue::create(reinterpret_cast<const char*>(&message.front()), message.size());
     MessageEvent* event = MessageEvent::create(nullptr, value.release(), getExecutionContext()->getSecurityOrigin()->toString());
     event->setTarget(this);
     bool success = getExecutionContext()->getEventQueue()->enqueueEvent(event);
     DCHECK(success);
     ALLOW_UNUSED_LOCAL(success);
 }
 
 void BroadcastChannel::onError()
 {
     close();
@@ skipping 17 matching lines @@
     mojom::blink::BroadcastChannelClientAssociatedPtrInfo remoteClientInfo;
     mojo::AssociatedInterfaceRequest<mojom::blink::BroadcastChannelClient> remoteCientRequest;
     provider.associated_group()->CreateAssociatedInterface(mojo::AssociatedGroup::WILL_PASS_REQUEST, &remoteClientInfo, &remoteCientRequest);
     m_remoteClient.Bind(std::move(remoteClientInfo));
     m_remoteClient.set_connection_error_handler(convertToBaseCallback(WTF::bind(&BroadcastChannel::onError, wrapWeakPersistent(this))));
 
     provider->ConnectToChannel(m_origin, m_name, std::move(localClientInfo), std::move(remoteCientRequest));
 }
 
 } // namespace blink