Move the worker script loading code to the worker process (phase:2/5)

content/worker/websharedworkerclient_proxy.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/websharedworkerclient_proxy.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "content/child/webmessageportchannel_impl.h"
@@ skipping 24 matching lines @@
 
 // How long to wait for worker to finish after it's been told to terminate.
 #define kMaxTimeForRunawayWorkerSeconds 3
 
 WebSharedWorkerClientProxy::WebSharedWorkerClientProxy(
     int route_id, WebSharedWorkerStub* stub)
     : route_id_(route_id),
       appcache_host_id_(0),
       stub_(stub),
       weak_factory_(this),
-      devtools_agent_(NULL) {
+      devtools_agent_(NULL),
+      app_cache_host_(NULL) {
 }
 
 WebSharedWorkerClientProxy::~WebSharedWorkerClientProxy() {
 }
 
 void WebSharedWorkerClientProxy::workerContextClosed() {
   Send(new WorkerHostMsg_WorkerContextClosed(route_id_));
 }
 
 void WebSharedWorkerClientProxy::workerContextDestroyed() {
   Send(new WorkerHostMsg_WorkerContextDestroyed(route_id_));
   // Tell the stub that the worker has shutdown - frees this object.
   if (stub_)
     stub_->Shutdown();
 }
 
+void WebSharedWorkerClientProxy::workerScriptLoaded() {
+  if (stub_)
+    stub_->WorkerScriptLoaded();
+}
+
+void WebSharedWorkerClientProxy::workerScriptLoadFailed() {
+  if (stub_)
+    stub_->WorkerScriptLoadFailed();
+}
+
+void WebSharedWorkerClientProxy::selectAppCacheID(long long app_cache_id) {
+  if (app_cache_host_) {
+    // app_cache_host_ could become stale as it's owned by blink's
+    // DocumentLoader. So we have to call selectAppCacheID while it's valid.

[kinuko, 2013/12/20 08:23:21]

nit: 'So we have to call selectAppCacheID' -> 'This method is assumed to be
called' as it's called by blink code?

[horo, 2013/12/20 08:48:15]

Done.
It will be called from WebSharedWorkerImpl in didReceiveResponse of the script
loading.

+    app_cache_host_->backend()->SelectCacheForSharedWorker(
+        app_cache_host_->host_id(),
+        app_cache_id);
+  }
+}
+
 blink::WebNotificationPresenter*
 WebSharedWorkerClientProxy::notificationPresenter() {
   // TODO(johnnyg): Notifications are not yet hooked up to workers.
   // Coming soon.
   NOTREACHED();
   return NULL;
 }
 
 WebApplicationCacheHost* WebSharedWorkerClientProxy::createApplicationCacheHost(
     blink::WebApplicationCacheHostClient* client) {
-  WorkerWebApplicationCacheHostImpl* host =
+  DCHECK(!app_cache_host_);
+  app_cache_host_ =
       new WorkerWebApplicationCacheHostImpl(stub_->appcache_init_info(),
                                             client);
   // Remember the id of the instance we create so we have access to that
   // value when creating nested dedicated workers in createWorker.
-  appcache_host_id_ = host->host_id();
-  return host;
+  appcache_host_id_ = app_cache_host_->host_id();
+  return app_cache_host_;
 }
 
 blink::WebWorkerPermissionClientProxy*
 WebSharedWorkerClientProxy::createWorkerPermissionClientProxy(
     const blink::WebSecurityOrigin& origin) {
   return new SharedWorkerPermissionClientProxy(
       GURL(origin.toString()), origin.isUnique(), route_id_,
       ChildThread::current()->thread_safe_sender());
 }
 
@@ skipping 35 matching lines @@
   // page. It's ok to post several of theese, because the first executed task
   // will exit the message loop and subsequent ones won't be executed.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&WebSharedWorkerClientProxy::workerContextDestroyed,
                  weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kMaxTimeForRunawayWorkerSeconds));
 }
 
 }  // namespace content