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

webkit/glue/webworkerclient_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"
 
 #if ENABLE(WORKERS)
 
 #include "base/compiler_specific.h"
 
@@ skipping 23 matching lines @@
 #include "webkit/api/public/WebWorker.h"
 #include "webkit/api/src/PlatformMessagePortChannel.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webframeloaderclient_impl.h"
 #include "webkit/glue/webframe_impl.h"
 #include "webkit/glue/webview_delegate.h"
 #include "webkit/glue/webview_impl.h"
 #include "webkit/glue/webworker_impl.h"
 
 using WebKit::WebMessagePortChannel;
+using WebKit::WebMessagePortChannelArray;
 using WebKit::WebString;
 using WebKit::WebWorker;
 using WebKit::WebWorkerClient;
 
 // When WebKit creates a WorkerContextProxy object, we check if we're in the
 // renderer or worker process.  If the latter, then we just use
 // WebCore::WorkerMessagingProxy.
 //
 // If we're in the renderer process, then we need use the glue provided
 // WebWorker object to talk to the worker process over IPC.  The worker process
@@ skipping 93 matching lines @@
     WebWorkerImpl::DispatchTaskToMainThread(
         WebCore::createCallbackTask(&TerminateWorkerContextTask, this));
     return;
   }
 
   webworker_->terminateWorkerContext();
 }
 
 void WebWorkerClientImpl::postMessageToWorkerContext(
     const WebCore::String& message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannel> channel) {
+    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
   // Worker.terminate() could be called from JS before the context is started.
   if (asked_to_terminate_)
     return;
 
   ++unconfirmed_message_count_;
 
   if (!WTF::isMainThread()) {
     WebWorkerImpl::DispatchTaskToMainThread(
         WebCore::createCallbackTask(
-            &PostMessageToWorkerContextTask, this, message, channel));
+            &PostMessageToWorkerContextTask, this, message, channels));
     return;
   }
 
-  WebMessagePortChannel* webchannel = NULL;
-  if (channel.get()) {
-    webchannel = channel->channel()->webChannelRelease();
+  WebMessagePortChannelArray webchannels(channels.get() ? channels->size() : 0);
+
+  for (size_t i = 0; i < webchannels.size(); ++i) {
+    WebMessagePortChannel* webchannel =
+        (*channels)[i]->channel()->webChannelRelease();
     webchannel->setClient(0);
+    webchannels[i] = webchannel;
   }
 
   webworker_->postMessageToWorkerContext(
-      webkit_glue::StringToWebString(message), webchannel);
+      webkit_glue::StringToWebString(message), webchannels);
 }
 
 bool WebWorkerClientImpl::hasPendingActivity() const {
   return !asked_to_terminate_ &&
       (unconfirmed_message_count_ || worker_context_had_pending_activity_);
 }
 
 void WebWorkerClientImpl::workerObjectDestroyed() {
   if (WTF::isMainThread()) {
     webworker_->workerObjectDestroyed();
     worker_ = NULL;
   }
 
   // Even if this is called on the main thread, there could be a queued task for
   // this object, so don't delete it right away.
   WebWorkerImpl::DispatchTaskToMainThread(
       WebCore::createCallbackTask(&WorkerObjectDestroyedTask, this));
 }
 
 void WebWorkerClientImpl::postMessageToWorkerObject(
     const WebString& message,
-    WebMessagePortChannel* channel) {
+    const WebMessagePortChannelArray& channels) {
   WebCore::String message2 = webkit_glue::WebStringToString(message);
-  OwnPtr<WebCore::MessagePortChannel> channel2;
-  if (channel) {
-    RefPtr<WebCore::PlatformMessagePortChannel> platform_channel =
-        WebCore::PlatformMessagePortChannel::create(channel);
-    channel->setClient(platform_channel.get());
-    channel2 = WebCore::MessagePortChannel::create(platform_channel);
+  OwnPtr<WebCore::MessagePortChannelArray> channels2;
+  if (channels.size()) {
+    channels2 = new WebCore::MessagePortChannelArray(channels.size());
+    for (size_t i = 0; i < channels.size(); ++i) {
+      RefPtr<WebCore::PlatformMessagePortChannel> platform_channel =
+          WebCore::PlatformMessagePortChannel::create(channels[i]);
+      channels[i]->setClient(platform_channel.get());
+      (*channels2)[i] = WebCore::MessagePortChannel::create(platform_channel);
+    }
   }
 
   if (WTF::currentThread() != worker_thread_id_) {
     script_execution_context_->postTask(
         WebCore::createCallbackTask(&PostMessageToWorkerObjectTask, this,
-            message2, channel2.release()));
+            message2, channels2.release()));
     return;
   }
 
   PostMessageToWorkerObjectTask(
-      script_execution_context_.get(), this, message2, channel2.release());
+      script_execution_context_.get(), this, message2, channels2.release());
 }
 
 void WebWorkerClientImpl::postExceptionToWorkerObject(
     const WebString& error_message,
     int line_number,
     const WebString& source_url) {
   if (WTF::currentThread() != worker_thread_id_) {
     script_execution_context_->postTask(
         WebCore::createCallbackTask(&PostExceptionToWorkerObjectTask, this,
             webkit_glue::WebStringToString(error_message),
@@ skipping 77 matching lines @@
 void WebWorkerClientImpl::TerminateWorkerContextTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerClientImpl* this_ptr) {
   this_ptr->webworker_->terminateWorkerContext();
 }
 
 void WebWorkerClientImpl::PostMessageToWorkerContextTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerClientImpl* this_ptr,
     const 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->webworker_->postMessageToWorkerContext(
-      webkit_glue::StringToWebString(message), webChannel);
+      webkit_glue::StringToWebString(message), web_channels);
 }
 
 void WebWorkerClientImpl::WorkerObjectDestroyedTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerClientImpl* this_ptr) {
   if (this_ptr->worker_)  // Check we haven't alread called this.
     this_ptr->webworker_->workerObjectDestroyed();
   delete this_ptr;
 }
 
 void WebWorkerClientImpl::PostMessageToWorkerObjectTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerClientImpl* this_ptr,
     const WebCore::String& message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannel> channel) {
+    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
 
   if (this_ptr->worker_) {
-    WTF::RefPtr<WebCore::MessagePort> port;
-    if (channel) {
-      port = WebCore::MessagePort::create(*context);
-      port->entangle(channel.release());
-    }
-
-    this_ptr->worker_->dispatchMessage(message, port.release());
+    WTF::OwnPtr<WebCore::MessagePortArray> ports =
+        WebCore::MessagePort::entanglePorts(*context, channels.release());
+    this_ptr->worker_->dispatchMessage(message, ports.release());
   }
 }
 
 void WebWorkerClientImpl::PostExceptionToWorkerObjectTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerClientImpl* this_ptr,
     const WebCore::String& error_message,
     int line_number,
     const WebCore::String& source_url) {
   bool handled = false;
@@ skipping 32 matching lines @@
 }
 
 void WebWorkerClientImpl::ReportPendingActivityTask(
     WebCore::ScriptExecutionContext* context,
     WebWorkerClientImpl* this_ptr,
     bool has_pending_activity) {
   this_ptr->worker_context_had_pending_activity_ = has_pending_activity;
 }
 
 #endif