Hook up WebFrameClient, replacing many WebViewDelegate methods....

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"
 
 #include "DedicatedWorkerThread.h"
 #include "Frame.h"
 #include "FrameLoaderClient.h"
 #include "GenericWorkerTask.h"
 #include "MessagePort.h"
 #include "MessagePortChannel.h"
 #include "ScriptExecutionContext.h"
 #include "WorkerContextExecutionProxy.h"
 #include "WorkerMessagingProxy.h"
 #include "Worker.h"
 #include "WorkerContext.h"
 #include <wtf/Threading.h>
 
 #undef LOG
 
 #include "webkit/glue/webworkerclient_impl.h"
 
 #include "base/command_line.h"
+#include "webkit/api/public/WebFrameClient.h"
 #include "webkit/api/public/WebKit.h"
 #include "webkit/api/public/WebKitClient.h"
 #include "webkit/api/public/WebMessagePortChannel.h"
 #include "webkit/api/public/WebString.h"
 #include "webkit/api/public/WebURL.h"
 #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::WebFrameClient;
 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
 // talks to WebCore::Worker* using WorkerObjectProxy, which we implement on
 // WebWorkerClientImpl.
 //
 // Note that if we're running each worker in a separate process, then nested
 // workers end up using the same codepath as the renderer process.
 WebCore::WorkerContextProxy* WebCore::WorkerContextProxy::create(
     WebCore::Worker* worker) {
   if (!worker->scriptExecutionContext()->isDocument() &&
       CommandLine::ForCurrentProcess()->HasSwitch(
             L"web-worker-share-processes")) {
     return new WebCore::WorkerMessagingProxy(worker);
   }
 
   WebWorker* webworker = NULL;
   WebWorkerClientImpl* proxy = new WebWorkerClientImpl(worker);
 
   if (worker->scriptExecutionContext()->isDocument()) {
-    // Get to the RenderView, so that we can tell the browser to create a
-    // worker process if necessary.
     WebCore::Document* document = static_cast<WebCore::Document*>(
         worker->scriptExecutionContext());
-    WebFrameLoaderClient* frame_loader_client =
-        static_cast<WebFrameLoaderClient*>(
-            document->frame()->loader()->client());
-    WebViewDelegate* webview_delegate =
-        frame_loader_client->webframe()->GetWebViewImpl()->delegate();
-    webworker = webview_delegate->CreateWebWorker(proxy);
+    WebFrameImpl* webframe = WebFrameImpl::FromFrame(document->frame());
+    webworker = webframe->client()->createWorker(webframe, proxy);
   } else {
     WebCore::WorkerContextExecutionProxy* current_context =
         WebCore::WorkerContextExecutionProxy::retrieve();
     if (!current_context) {
       NOTREACHED();
       return NULL;
     }
 
     WebCore::DedicatedWorkerThread* thread =
         static_cast<WebCore::DedicatedWorkerThread*>(
@@ skipping 304 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