NavigationController prototype

content/worker/websharedworker_stub.cc

 // Copyright (c) 2012 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/worker/websharedworker_stub.h"
 
 #include "base/compiler_specific.h"
+#include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/child/child_thread.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
 #include "content/worker/shared_worker_devtools_agent.h"
 #include "content/worker/worker_thread.h"
 #include "third_party/WebKit/public/web/WebSharedWorker.h"
+#include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
+#include "content/common/appcache_messages.h"
+
+using WebKit::WebController;
 
 namespace content {
 
 WebSharedWorkerStub::WebSharedWorkerStub(
     const string16& name,
     int route_id,
     const WorkerAppCacheInitInfo& appcache_init_info)
     : route_id_(route_id),
       appcache_init_info_(appcache_init_info),
       client_(route_id, this),
       name_(name),
-      started_(false) {
+      started_(false),
+      is_embedded_worker_(false) {
 
   WorkerThread* worker_thread = WorkerThread::current();
   DCHECK(worker_thread);
   worker_thread->AddWorkerStub(this);
   // Start processing incoming IPCs for this worker.
   worker_thread->AddRoute(route_id_, this);
   ChildProcess::current()->AddRefProcess();
 
   // TODO(atwilson): Add support for NaCl when they support MessagePorts.
   impl_ = WebKit::WebSharedWorker::create(client());
@@ skipping 19 matching lines @@
   client_.EnsureWorkerContextTerminates();
 }
 
 bool WebSharedWorkerStub::OnMessageReceived(const IPC::Message& message) {
   if (worker_devtools_agent_->OnMessageReceived(message))
     return true;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebSharedWorkerStub, message)
     IPC_MESSAGE_HANDLER(WorkerMsg_StartWorkerContext, OnStartWorkerContext)
+    IPC_MESSAGE_HANDLER(WorkerMsg_StartEmbeddedWorkerContext,
+                        OnStartEmbeddedWorkerContext);
     IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext,
                         OnTerminateWorkerContext)
     IPC_MESSAGE_HANDLER(WorkerMsg_Connect, OnConnect)
+    IPC_MESSAGE_HANDLER(AppCacheMsg_FetchEvent, OnFetchEvent)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WebSharedWorkerStub::OnChannelError() {
     OnTerminateWorkerContext();
 }
 
 const GURL& WebSharedWorkerStub::url() {
   return url_;
 }
 
 void WebSharedWorkerStub::OnStartWorkerContext(
     const GURL& url, const string16& user_agent, const string16& source_code,
     const string16& content_security_policy,
     WebKit::WebContentSecurityPolicyType policy_type) {
   // Ignore multiple attempts to start this worker (can happen if two pages
   // try to start it simultaneously).
+  DCHECK(!is_embedded_worker_);
   if (started_)
     return;
 
   impl_->startWorkerContext(url, name_, user_agent, source_code,
-                            content_security_policy, policy_type, 0);
+                            content_security_policy, policy_type, 0, false);
   started_ = true;
   url_ = url;
 
   // Process any pending connections.
   for (PendingConnectInfoList::const_iterator iter = pending_connects_.begin();
        iter != pending_connects_.end();
        ++iter) {
     OnConnect(iter->first, iter->second);
   }
   pending_connects_.clear();
 }
 
+void WebSharedWorkerStub::OnStartEmbeddedWorkerContext(
+    const GURL& url, const std::string& raw_source_code) {
+  DCHECK(!started_);
+
+  is_embedded_worker_ = true;
+
+  // TODO: plug some values in here.
+  string16 user_agent;
+  string16 content_security_policy;
+  WebKit::WebContentSecurityPolicyType policy_type = WebKit::WebContentSecurityPolicyType(0);
+  WebKit::WebString source_code =
+      WebKit::WebString::fromUTF8(raw_source_code.data(),
+                                  raw_source_code.length());
+  impl_->startWorkerContext(url, name_, user_agent, source_code,
+                            content_security_policy, policy_type, 0, true);
+  started_ = true;
+  url_ = url;
+}
+
 void WebSharedWorkerStub::OnConnect(int sent_message_port_id, int routing_id) {
   if (started_) {
     WebKit::WebMessagePortChannel* channel =
         new WebMessagePortChannelImpl(routing_id,
                                       sent_message_port_id,
                                       base::MessageLoopProxy::current().get());
     impl_->connect(channel, NULL);
   } else {
     // If two documents try to load a SharedWorker at the same time, the
     // WorkerMsg_Connect for one of the documents can come in before the
     // worker is started. Just queue up the connect and deliver it once the
     // worker starts.
     PendingConnectInfo pending_connect(sent_message_port_id, routing_id);
     pending_connects_.push_back(pending_connect);
   }
 }
 
+void WebSharedWorkerStub::OnFetchEvent(
+    int request_id,
+    const appcache::AppCacheExecutableHandler::Request& request) {
+  CHECK(started_);
+  // TODO: there are more data members here then we really support atm
+  // and some of them look questionable as to whether they're really needed.
+  // We should prune this to be more minimalistic and reflective of what is
+  // actuall supported atm.
+  //
+  // ANOTHER TODO: this struct is not composed of thread safe string types
+  // yet it's being posted across threads :( We need to avoid using
+  // WebKit defined classes and interfaces for marshalling data around.
+  // fyi: WebString and WebCore::String are landmines.
+  // The response plumbing has the same problem with WebControllerResponse
+  // structs.
+  WebController::Request* webRequest = new WebController::Request();
+  webRequest->url = request.url;
+  webRequest->method = ASCIIToUTF16(request.method);
+  webRequest->referrer = ASCIIToUTF16(request.referrer); // ??? this is a url
+  for (std::map<std::string, std::string>::const_iterator iter = request.headers.begin();
+       iter != request.headers.end();
+       ++iter) {
+    webRequest->headers.push_back(std::make_pair(
+        WebKit::WebString(UTF8ToUTF16(iter->first)),
+        WebKit::WebString(UTF8ToUTF16(iter->second))));
+  }
+
+  impl_->dispatchFetchEvent(request_id, webRequest);
+}
+
+void WebSharedWorkerStub::OnInstallEvent(int host_id) {
+  CHECK(false);
+}
+
 void WebSharedWorkerStub::OnTerminateWorkerContext() {
   impl_->terminateWorkerContext();
 
   // Call the client to make sure context exits.
   EnsureWorkerContextTerminates();
   started_ = false;
 }
 
 }  // namespace content