Move webworker{client}_impl.{h,cc} into webkit/api/src

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 "DedicatedWorkerContext.h"
-#include "DedicatedWorkerThread.h"
-#include "GenericWorkerTask.h"
-#include "KURL.h"
-#include "MessageEvent.h"
-#include "MessagePort.h"
-#include "MessagePortChannel.h"
-#include "ScriptExecutionContext.h"
-#include "SecurityOrigin.h"
-#include "SerializedScriptValue.h"
-#include "SubstituteData.h"
-#include <wtf/MainThread.h>
-#include <wtf/Threading.h>
-
-#undef LOG
-
-#include "webkit/api/public/WebFrameClient.h"
-#include "webkit/api/public/WebMessagePortChannel.h"
-#include "webkit/api/public/WebScreenInfo.h"
-#include "webkit/api/public/WebString.h"
-#include "webkit/api/public/WebURL.h"
-#include "webkit/api/public/WebView.h"
-#include "webkit/api/public/WebWorkerClient.h"
-#include "webkit/api/src/PlatformMessagePortChannel.h"
-#include "webkit/api/src/WebDataSourceImpl.h"
-#include "webkit/glue/empty_webframeclient.h"
-#include "webkit/glue/glue_util.h"
-#include "webkit/glue/webframe_impl.h"
-#include "webkit/glue/webpreferences.h"
-#include "webkit/glue/webworker_impl.h"
-
-using WebKit::WebCursorInfo;
-using WebKit::WebDataSource;
-using WebKit::WebDataSourceImpl;
-using WebKit::WebFrame;
-using WebKit::WebFrameClient;
-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;
-using WebKit::WebView;
-
-#if ENABLE(WORKERS)
-
-// Dummy WebViewDelegate - we only need it in Worker process to load a
-// 'shadow page' which will initialize WebCore loader.
-class WorkerWebFrameClient : public webkit_glue::EmptyWebFrameClient {
- public:
-  // Tell the loader to load the data into the 'shadow page' synchronously,
-  // so we can grab the resulting Document right after load.
-  virtual void didCreateDataSource(WebFrame* frame, WebDataSource* ds) {
-    static_cast<WebDataSourceImpl*>(ds)->setDeferMainResourceDataLoad(false);
-  }
-
-  // Lazy allocate and leak this instance.
-  static WorkerWebFrameClient* GetSharedInstance() {
-    static WorkerWebFrameClient client;
-    return &client;
-  }
-
- private:
-  WorkerWebFrameClient() {}
-};
-
-namespace WebKit {
-
-WebWorker* WebWorker::create(WebWorkerClient* client) {
-  return new WebWorkerImpl(client);
-}
-
-}
-
-// This function is called on the main thread to force to initialize some static
-// values used in WebKit before any worker thread is started. This is because in
-// our worker processs, we do not run any WebKit code in main thread and thus
-// when multiple workers try to start at the same time, we might hit crash due
-// to contention for initializing static values.
-void InitializeWebKitStaticValues() {
-  static bool initialized = false;
-  if (!initialized) {
-    initialized= true;
-    // Note that we have to pass a URL with valid protocol in order to follow
-    // the path to do static value initializations.
-    WTF::RefPtr<WebCore::SecurityOrigin> origin =
-        WebCore::SecurityOrigin::create(WebCore::KURL(WebCore::ParsedURLString,
-                                                      "http://localhost"));
-    origin.release();
-  }
-}
-
-WebWorkerImpl::WebWorkerImpl(WebWorkerClient* client)
- : client_(client),
-   web_view_(NULL),
-   asked_to_terminate_(false) {
-  InitializeWebKitStaticValues();
-}
-
-WebWorkerImpl::~WebWorkerImpl() {
-  web_view_->close();
-}
-
-void WebWorkerImpl::PostMessageToWorkerContextTask(
-    WebCore::ScriptExecutionContext* context,
-    WebWorkerImpl* this_ptr,
-    const WebCore::String& message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
-  ASSERT(context->isWorkerContext());
-  WebCore::DedicatedWorkerContext* worker_context =
-      static_cast<WebCore::DedicatedWorkerContext*>(context);
-
-  WTF::OwnPtr<WebCore::MessagePortArray> ports =
-      WebCore::MessagePort::entanglePorts(*context, channels.release());
-  WTF::RefPtr<WebCore::SerializedScriptValue> serialized_message =
-      WebCore::SerializedScriptValue::create(message);
-  worker_context->dispatchEvent(
-      WebCore::MessageEvent::create(ports.release(),
-                                    serialized_message.release()));
-
-  this_ptr->confirmMessageFromWorkerObject(
-      worker_context->hasPendingActivity());
-}
-
-// WebWorker -------------------------------------------------------------------
-
-void WebWorkerImpl::startWorkerContext(const WebURL& script_url,
-                                       const WebString& user_agent,
-                                       const WebString& source_code) {
-  // Create 'shadow page'. This page is never displayed, it is used to proxy the
-  // loading requests from the worker context to the rest of WebKit and Chromium
-  // infrastructure.
-  ASSERT(!web_view_);
-  web_view_ = WebView::create(NULL);
-  WebPreferences().Apply(web_view_);
-  web_view_->initializeMainFrame(WorkerWebFrameClient::GetSharedInstance());
-
-  WebFrameImpl* web_frame = static_cast<WebFrameImpl*>(web_view_->mainFrame());
-
-  // Construct substitute data source for the 'shadow page'. We only need it
-  // to have same origin as the worker so the loading checks work correctly.
-  WebCore::CString content("");
-  int len = static_cast<int>(content.length());
-  RefPtr<WebCore::SharedBuffer> buf(
-      WebCore::SharedBuffer::create(content.data(), len));
-  WebCore::SubstituteData subst_data(buf,
-                                     WebCore::String("text/html"),
-                                     WebCore::String("UTF-8"),
-                                     WebCore::KURL());
-  WebCore::ResourceRequest request(webkit_glue::GURLToKURL(script_url),
-                                   WebCore::CString());
-  web_frame->frame()->loader()->load(request, subst_data, false);
-
-  // This document will be used as 'loading context' for the worker.
-  loading_document_ = web_frame->frame()->document();
-
-  worker_thread_ = WebCore::DedicatedWorkerThread::create(
-      webkit_glue::WebURLToKURL(script_url),
-      webkit_glue::WebStringToString(user_agent),
-      webkit_glue::WebStringToString(source_code),
-      *this,
-      *this);
-
-  // Worker initialization means a pending activity.
-  reportPendingActivity(true);
-
-  worker_thread_->start();
-}
-
-void WebWorkerImpl::terminateWorkerContext() {
-  if (asked_to_terminate_)
-    return;
-  asked_to_terminate_ = true;
-
-  if (worker_thread_)
-    worker_thread_->stop();
-}
-
-void WebWorkerImpl::postMessageToWorkerContext(
-    const WebString& message,
-    const WebMessagePortChannelArray& webchannels) {
-
-  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),
-      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::clientDestroyed() {
-  client_ = NULL;
-}
-
-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(
-    WTF::PassRefPtr<WebCore::SerializedScriptValue> message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
-  DispatchTaskToMainThread(WebCore::createCallbackTask(
-      &PostMessageTask,
-      this,
-      message->toString(),
-      channels));
-}
-
-void WebWorkerImpl::PostMessageTask(
-    WebCore::ScriptExecutionContext* context,
-    WebWorkerImpl* this_ptr,
-    WebCore::String message,
-    WTF::PassOwnPtr<WebCore::MessagePortChannelArray> channels) {
-  if (!this_ptr->client_)
-    return;
-
-  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), 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,
-      line_number,
-      source_url));
-}
-
-void WebWorkerImpl::PostExceptionTask(
-      WebCore::ScriptExecutionContext* context,
-      WebWorkerImpl* this_ptr,
-      const WebCore::String& error_message,
-      int line_number,
-      const WebCore::String& source_url) {
-  if (!this_ptr->client_)
-    return;
-
-  this_ptr->client_->postExceptionToWorkerObject(
-      webkit_glue::StringToWebString(error_message),
-      line_number,
-      webkit_glue::StringToWebString(source_url));
-}
-
-void WebWorkerImpl::postConsoleMessageToWorkerObject(
-    WebCore::MessageDestination destination,
-    WebCore::MessageSource source,
-    WebCore::MessageType type,
-    WebCore::MessageLevel level,
-    const WebCore::String& message,
-    int line_number,
-    const WebCore::String& source_url) {
-  DispatchTaskToMainThread(WebCore::createCallbackTask(
-      &PostConsoleMessageTask,
-      this,
-      static_cast<int>(destination),
-      static_cast<int>(source),
-      static_cast<int>(type),
-      static_cast<int>(level),
-      message,
-      line_number,
-      source_url));
-}
-
-void WebWorkerImpl::PostConsoleMessageTask(
-    WebCore::ScriptExecutionContext* context,
-    WebWorkerImpl* this_ptr,
-    int destination,
-    int source,
-    int type,
-    int level,
-    const WebCore::String& message,
-    int line_number,
-    const WebCore::String& source_url) {
-  if (!this_ptr->client_)
-    return;
-
-  this_ptr->client_->postConsoleMessageToWorkerObject(
-      destination,
-      source,
-      type,
-      level,
-      webkit_glue::StringToWebString(message),
-      line_number,
-      webkit_glue::StringToWebString(source_url));
-}
-
-void WebWorkerImpl::confirmMessageFromWorkerObject(bool has_pending_activity) {
-  DispatchTaskToMainThread(WebCore::createCallbackTask(
-      &ConfirmMessageTask,
-      this,
-      has_pending_activity));
-}
-
-void WebWorkerImpl::ConfirmMessageTask(
-    WebCore::ScriptExecutionContext* context,
-    WebWorkerImpl* this_ptr,
-    bool has_pending_activity) {
-  if (!this_ptr->client_)
-    return;
-
-  this_ptr->client_->confirmMessageFromWorkerObject(has_pending_activity);
-}
-
-void WebWorkerImpl::reportPendingActivity(bool has_pending_activity) {
-  DispatchTaskToMainThread(WebCore::createCallbackTask(
-      &ReportPendingActivityTask,
-      this,
-      has_pending_activity));
-}
-
-void WebWorkerImpl::ReportPendingActivityTask(
-    WebCore::ScriptExecutionContext* context,
-    WebWorkerImpl* this_ptr,
-    bool has_pending_activity) {
-  if (!this_ptr->client_)
-    return;
-
-  this_ptr->client_->reportPendingActivity(has_pending_activity);
-}
-
-void WebWorkerImpl::workerContextDestroyed() {
-  DispatchTaskToMainThread(WebCore::createCallbackTask(
-      &WorkerContextDestroyedTask,
-      this));
-}
-
-// WorkerLoaderProxy -----------------------------------------------------------
-
-void WebWorkerImpl::postTaskToLoader(
-    PassRefPtr<WebCore::ScriptExecutionContext::Task> task) {
-  ASSERT(loading_document_->isDocument());
-  loading_document_->postTask(task);
-}
-
-void WebWorkerImpl::postTaskForModeToWorkerContext(
-    PassRefPtr<WebCore::ScriptExecutionContext::Task> task,
-    const WebCore::String& mode) {
-  worker_thread_->runLoop().postTaskForMode(task, mode);
-}
-
-void WebWorkerImpl::WorkerContextDestroyedTask(
-    WebCore::ScriptExecutionContext* context,
-    WebWorkerImpl* this_ptr) {
-  if (this_ptr->client_)
-    this_ptr->client_->workerContextDestroyed();
-
-  // The lifetime of this proxy is controlled by the worker context.
-  delete this_ptr;
-}
-
-#else
-
-namespace WebKit {
-
-WebWorker* WebWorker::create(WebWorkerClient* client) {
-  return NULL;
-}
-
-}
-
-#endif