Updating Worker.postMessage(), DOMWindow.postMessage(), and...

webkit/glue/webworker_impl.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 "config.h"
 
 #include "base/compiler_specific.h"
 
 #include "DedicatedWorkerContext.h"
 #include "DedicatedWorkerThread.h"
@@ skipping 20 matching lines @@
 #include "webkit/glue/webdatasource_impl.h"
 #include "webkit/glue/webframe_impl.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/glue/webview.h"
 #include "webkit/glue/webview_delegate.h"
 #include "webkit/glue/webworker_impl.h"
 
 using WebKit::WebCursorInfo;
 using WebKit::WebFrame;
 using WebKit::WebMessagePortChannel;
+using WebKit::WebMessagePortChannelArray;
 using WebKit::WebNavigationPolicy;
 using WebKit::WebRect;
 using WebKit::WebScreenInfo;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebWorker;
 using WebKit::WebWorkerClient;
 
 #if ENABLE(WORKERS)
 
@@ skipping 66 matching lines @@
 }
 
 WebWorkerImpl::~WebWorkerImpl() {
   web_view_->close();
 }
 
 void WebWorkerImpl::PostMessageToWorkerContextTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerImpl* this_ptr,
     const WebCore::String& message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannel> channel) {
+    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
   DCHECK(context->isWorkerContext());
   WebCore::DedicatedWorkerContext* worker_context =
       static_cast<WebCore::DedicatedWorkerContext*>(context);
 
-  WTF::RefPtr<WebCore::MessagePort> port;
-  if (channel) {
-    port = WebCore::MessagePort::create(*context);
-    port->entangle(channel.release());
-  }
-  worker_context->dispatchMessage(message, port.release());
+  WTF::OwnPtr<WebCore::MessagePortArray> ports =
+      WebCore::MessagePort::entanglePorts(*context, channels.release());
+  worker_context->dispatchMessage(message, ports.release());
 
   this_ptr->confirmMessageFromWorkerObject(
       worker_context->hasPendingActivity());
 }
 
 // WebWorker -------------------------------------------------------------------
 
 void WebWorkerImpl::startWorkerContext(const WebURL& script_url,
                                        const WebString& user_agent,
                                        const WebString& source_code) {
@@ skipping 42 matching lines @@
   if (asked_to_terminate_)
     return;
   asked_to_terminate_ = true;
 
   if (worker_thread_)
     worker_thread_->stop();
 }
 
 void WebWorkerImpl::postMessageToWorkerContext(
     const WebString& message,
-    WebMessagePortChannel* webchannel) {
+    const WebMessagePortChannelArray& webchannels) {
 
-  OwnPtr<WebCore::MessagePortChannel> channel;
-  if (webchannel) {
-    RefPtr<WebCore::PlatformMessagePortChannel> platform_channel =
-        WebCore::PlatformMessagePortChannel::create(webchannel);
-    webchannel->setClient(platform_channel.get());
-    channel = WebCore::MessagePortChannel::create(platform_channel);
+  WTF::OwnPtr<WebCore::MessagePortChannelArray> channels;
+  if (webchannels.size()) {
+    channels = new WebCore::MessagePortChannelArray(webchannels.size());
+    for (size_t i = 0; i < webchannels.size(); ++i) {
+      RefPtr<WebCore::PlatformMessagePortChannel> platform_channel =
+          WebCore::PlatformMessagePortChannel::create(webchannels[i]);
+      webchannels[i]->setClient(platform_channel.get());
+      (*channels)[i] = WebCore::MessagePortChannel::create(platform_channel);
+    }
   }
 
   worker_thread_->runLoop().postTask(WebCore::createCallbackTask(
       &PostMessageToWorkerContextTask,
       this,
       webkit_glue::WebStringToString(message),
-      channel.release()));
+      channels.release()));
 }
 
 void WebWorkerImpl::workerObjectDestroyed() {
   // Worker object in the renderer was destroyed, perhaps a result of GC.
   // For us, it's a signal to start terminating the WorkerContext too.
   // TODO(dimich): when 'kill a worker' html5 spec algorithm is implemented, it
   // should be used here instead of 'terminate a worker'.
   terminateWorkerContext();
 }
 
 void WebWorkerImpl::DispatchTaskToMainThread(
     PassRefPtr<WebCore::ScriptExecutionContext::Task> task) {
   return WTF::callOnMainThread(InvokeTaskMethod, task.releaseRef());
 }
 
 void WebWorkerImpl::InvokeTaskMethod(void* param) {
   WebCore::ScriptExecutionContext::Task* task =
       static_cast<WebCore::ScriptExecutionContext::Task*>(param);
   task->performTask(NULL);
   task->deref();
 }
 
 // WorkerObjectProxy -----------------------------------------------------------
 
 void WebWorkerImpl::postMessageToWorkerObject(
     const WebCore::String& message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannel> channel) {
+    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
   DispatchTaskToMainThread(WebCore::createCallbackTask(
       &PostMessageTask,
       this,
       message,
-      channel));
+      channels));
 }
 
 void WebWorkerImpl::PostMessageTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerImpl* this_ptr,
     WebCore::String message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannel> channel) {
-  WebMessagePortChannel* webChannel = NULL;
-  if (channel.get()) {
-    webChannel = channel->channel()->webChannelRelease();
-    webChannel->setClient(0);
+    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
+  WebMessagePortChannelArray web_channels(
+      channels.get() ? channels->size() : 0);
+  for (size_t i = 0; i < web_channels.size(); ++i) {
+    web_channels[i] = (*channels)[i]->channel()->webChannelRelease();
+    web_channels[i]->setClient(0);
   }
 
   this_ptr->client_->postMessageToWorkerObject(
-      webkit_glue::StringToWebString(message), webChannel);
+      webkit_glue::StringToWebString(message), web_channels);
 }
 
 void WebWorkerImpl::postExceptionToWorkerObject(
     const WebCore::String& error_message,
     int line_number,
     const WebCore::String& source_url) {
   DispatchTaskToMainThread(WebCore::createCallbackTask(
       &PostExceptionTask,
       this,
       error_message,
@@ skipping 114 matching lines @@
 
 namespace WebKit {
 
 WebWorker* WebWorker::create(WebWorkerClient* client) {
   return NULL;
 }
 
 }
 
 #endif