Support Transferable objects

content/renderer/webworker_proxy.cc

 // Copyright (c) 2009 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 "content/renderer/webworker_proxy.h"
 
 #include "content/common/child_thread.h"
 #include "content/common/content_client.h"
 #include "content/common/view_messages.h"
 #include "content/common/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
 #include "content/renderer/worker_devtools_agent_proxy.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebSerializedScriptValue.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebWorkerClient.h"
 
 using WebKit::WebCommonWorkerClient;
 using WebKit::WebMessagePortChannel;
-using WebKit::WebMessagePortChannelArray;
+#ifdef WebTransferableReceipt_h
+using WebKit::WebMessagePortReceipt;
+#endif
+using WebKit::WebTransferableReceiptArray;
+using WebKit::WebSerializedScriptValue;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebWorkerClient;
 
 WebWorkerProxy::WebWorkerProxy(
     WebWorkerClient* client,
     ChildThread* child_thread,
     int render_view_route_id,
     int parent_appcache_host_id)
     : WebWorkerBase(
@@ skipping 31 matching lines @@
 
 void WebWorkerProxy::terminateWorkerContext() {
   if (route_id_ != MSG_ROUTING_NONE) {
     Send(new WorkerMsg_TerminateWorkerContext(route_id_));
     CancelCreation();
     Disconnect();
   }
 }
 
 void WebWorkerProxy::postMessageToWorkerContext(
-    const WebString& message, const WebMessagePortChannelArray& channels) {
-  std::vector<int> message_port_ids(channels.size());
-  std::vector<int> routing_ids(channels.size());
-  for (size_t i = 0; i < channels.size(); ++i) {
-    WebMessagePortChannelImpl* webchannel =
-        static_cast<WebMessagePortChannelImpl*>(channels[i]);
-    message_port_ids[i] = webchannel->message_port_id();
-    webchannel->QueueMessages();
-    routing_ids[i] = MSG_ROUTING_NONE;
-    DCHECK(message_port_ids[i] != MSG_ROUTING_NONE);
+    const WebString& raw_message,
+    const WebTransferableReceiptArray& receipts) {
+  size_t unflattenable_count;
+#ifndef WebTransferableReceipt_h
+  WebString message = raw_message;
+  unflattenable_count = receipts.size();
+#else
+  WebString message = WebSerializedScriptValue::flattenReceiptList(
+      raw_message, receipts, &unflattenable_count);
+#endif
+  std::vector<int> message_port_ids(unflattenable_count);
+  std::vector<int> routing_ids(unflattenable_count);
+  size_t next_unflattenable = 0;
+  for (size_t i = 0; i < receipts.size(); ++i) {
+#ifndef WebTransferableReceipt_h
+    {
+#else
+    if (!WebSerializedScriptValue::isFlattenable(receipts[i])) {
+      DCHECK(toWebMessagePortReceipt(receipts[i]));
+#endif
+      DCHECK(next_unflattenable < unflattenable_count);
+      WebMessagePortChannelImpl* webchannel =
+#ifndef WebTransferableReceipt_h
+          static_cast<WebMessagePortChannelImpl*>(receipts[i]);
+#else
+          static_cast<WebMessagePortChannelImpl*>(
+              static_cast<WebMessagePortReceipt*>(receipts[i])->channel());
+#endif
+      message_port_ids[next_unflattenable] = webchannel->message_port_id();
+      webchannel->QueueMessages();
+      routing_ids[next_unflattenable] = MSG_ROUTING_NONE;
+      DCHECK(message_port_ids[next_unflattenable] != MSG_ROUTING_NONE);
+      ++next_unflattenable;
+    }
   }
-
+  DCHECK(next_unflattenable == unflattenable_count);
   Send(new WorkerMsg_PostMessage(
       route_id_, message, message_port_ids, routing_ids));
 }
 
 void WebWorkerProxy::workerObjectDestroyed() {
   Send(new WorkerMsg_WorkerObjectDestroyed(route_id_));
   delete this;
 }
 
 void WebWorkerProxy::clientDestroyed() {
@@ skipping 45 matching lines @@
   // The worker is created - now send off the CreateWorkerContext message and
   // any other queued messages
   SendQueuedMessages();
 }
 
 void WebWorkerProxy::OnPostMessage(
     const string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
   DCHECK(new_routing_ids.size() == sent_message_port_ids.size());
-  WebMessagePortChannelArray channels(sent_message_port_ids.size());
+  WebTransferableReceiptArray receipts(sent_message_port_ids.size());
   for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-    channels[i] = new WebMessagePortChannelImpl(
+    WebMessagePortChannelImpl* impl = new WebMessagePortChannelImpl(
         new_routing_ids[i], sent_message_port_ids[i]);
+#ifndef WebTransferableReceipt_h
+    receipts[i] = impl;
+#else
+    receipts[i] = new WebMessagePortReceipt(impl);
+#endif
   }
 
-  client_->postMessageToWorkerObject(message, channels);
+  client_->postMessageToWorkerObject(message, receipts);
+
+#ifdef WebTransferableReceipt_h
+  for (size_t i = 0; i < receipts.size(); ++i) {
+    delete receipts[i];
+    receipts[i] = 0;
+  }
+#endif
 }
 
 void WebWorkerProxy::OnPostConsoleMessageToWorkerObject(
       const WorkerHostMsg_PostConsoleMessageToWorkerObject_Params& params) {
   client_->postConsoleMessageToWorkerObject(params.source_identifier,
       params.message_type, params.message_level,
       params.message, params.line_number, params.source_url);
 }