Make AppCache support for SharedWorker in a renderer process.

content/renderer/shared_worker/embedded_shared_worker_stub.cc

 // Copyright 2014 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/renderer/shared_worker/embedded_shared_worker_stub.h"
 
 #include "base/message_loop/message_loop_proxy.h"
+#include "content/child/appcache/appcache_dispatcher.h"
+#include "content/child/appcache/web_application_cache_host_impl.h"
 #include "content/child/scoped_child_process_reference.h"
 #include "content/child/shared_worker_devtools_agent.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/web/WebSharedWorker.h"
 #include "third_party/WebKit/public/web/WebSharedWorkerClient.h"
 
 namespace content {
 
+namespace {
+
+class SharedWorkerWebApplicationCacheHostImpl
+    : public WebApplicationCacheHostImpl {
+ public:
+  SharedWorkerWebApplicationCacheHostImpl(
+      blink::WebApplicationCacheHostClient* client)
+      : WebApplicationCacheHostImpl(client,
+                                    RenderThreadImpl::current()
+                                        ->appcache_dispatcher()
+                                        ->backend_proxy()) {}
+
+  // Main resource loading is different for workers. The main resource is
+  // loaded by the worker using WorkerScriptLoader.
+  // These overrides are stubbed out.
+  virtual void willStartMainResourceRequest(
+      blink::WebURLRequest&,
+      const blink::WebApplicationCacheHost*) {}
+  virtual void didReceiveResponseForMainResource(const blink::WebURLResponse&) {
+  }
+  virtual void didReceiveDataForMainResource(const char* data, int len) {}
+  virtual void didFinishLoadingMainResource(bool success) {}
+
+  // Cache selection is also different for workers. We know at construction
+  // time what cache to select and do so then.
+  // These overrides are stubbed out.
+  virtual void selectCacheWithoutManifest() {}
+  virtual bool selectCacheWithManifest(const blink::WebURL& manifestURL) {
+    return true;
+  }
+};
+}
+
 EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub(
     const GURL& url,
     const base::string16& name,
     const base::string16& content_security_policy,
     blink::WebContentSecurityPolicyType security_policy_type,
     int route_id)
     : route_id_(route_id),
       name_(name),
       runing_(false),
       url_(url) {
@@ skipping 53 matching lines @@
 
 void EmbeddedSharedWorkerStub::workerContextClosed() {
   Send(new WorkerHostMsg_WorkerContextClosed(route_id_));
 }
 
 void EmbeddedSharedWorkerStub::workerContextDestroyed() {
   Send(new WorkerHostMsg_WorkerContextDestroyed(route_id_));
   Shutdown();
 }
 
-void EmbeddedSharedWorkerStub::selectAppCacheID(long long) {
-  // TODO(horo): implement this.
+void EmbeddedSharedWorkerStub::selectAppCacheID(long long app_cache_id) {
+  if (app_cache_host_) {
+    // app_cache_host_ could become stale as it's owned by blink's
+    // DocumentLoader. This method is assumed to be called while it's valid.
+    app_cache_host_->backend()->SelectCacheForSharedWorker(
+        app_cache_host_->host_id(), app_cache_id);
+  }
 }
 
 blink::WebNotificationPresenter*
 EmbeddedSharedWorkerStub::notificationPresenter() {
   // TODO(horo): delete this method if we have no plan to implement this.
   NOTREACHED();
   return NULL;
 }
 
 blink::WebApplicationCacheHost*
-    EmbeddedSharedWorkerStub::createApplicationCacheHost(
-        blink::WebApplicationCacheHostClient*) {
-  // TODO(horo): implement this.
-  return NULL;
+EmbeddedSharedWorkerStub::createApplicationCacheHost(
+    blink::WebApplicationCacheHostClient* client) {
+  app_cache_host_ = new SharedWorkerWebApplicationCacheHostImpl(client);
+  return app_cache_host_;
 }
 
 blink::WebWorkerPermissionClientProxy*
     EmbeddedSharedWorkerStub::createWorkerPermissionClientProxy(
     const blink::WebSecurityOrigin& origin) {
   // TODO(horo): implement this.
   return NULL;
 }
 
 void EmbeddedSharedWorkerStub::dispatchDevToolsMessage(
@@ skipping 37 matching lines @@
     pending_channels_.push_back(channel);
   }
 }
 
 void EmbeddedSharedWorkerStub::OnTerminateWorkerContext() {
   runing_ = false;
   impl_->terminateWorkerContext();
 }
 
 }  // namespace content