Service worker registration error support

content/child/service_worker/service_worker_dispatcher.cc

Index: content/child/service_worker/service_worker_dispatcher.cc
diff --git a/content/child/service_worker/service_worker_dispatcher.cc b/content/child/service_worker/service_worker_dispatcher.cc
index 866b25e5870ef90254f7b5537be765fd32b7715b..c4f0795fe0dd506fe204d03439eba8f6008bf9c9 100644
--- a/content/child/service_worker/service_worker_dispatcher.cc
+++ b/content/child/service_worker/service_worker_dispatcher.cc
@@ -11,6 +11,7 @@
 #include "content/common/service_worker_messages.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 
+using WebKit::WebServiceWorkerError;
 using WebKit::WebServiceWorkerProvider;
 using base::ThreadLocalPointer;
 using webkit_glue::WorkerTaskRunner;
@@ -44,10 +45,11 @@ ServiceWorkerDispatcher::~ServiceWorkerDispatcher() {
 void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered,
-                        OnServiceWorkerRegistered)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered, OnRegistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered,
-                        OnServiceWorkerUnregistered)
+                        OnUnregistered)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistrationError,
+                        OnRegistrationError)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
@@ -92,7 +94,7 @@ ServiceWorkerDispatcher* ServiceWorkerDispatcher::ThreadSpecificInstance(
   return dispatcher;
 }
 
-void ServiceWorkerDispatcher::OnServiceWorkerRegistered(
+void ServiceWorkerDispatcher::OnRegistered(
     int32 thread_id,
     int32 request_id,
     int64 service_worker_id) {
@@ -114,7 +116,7 @@ void ServiceWorkerDispatcher::OnServiceWorkerRegistered(
   pending_callbacks_.Remove(request_id);
 }
 
-void ServiceWorkerDispatcher::OnServiceWorkerUnregistered(
+void ServiceWorkerDispatcher::OnUnregistered(
     int32 thread_id,
     int32 request_id) {
   WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
@@ -127,6 +129,23 @@ void ServiceWorkerDispatcher::OnServiceWorkerUnregistered(
   pending_callbacks_.Remove(request_id);
 }
 
+void ServiceWorkerDispatcher::OnRegistrationError(
+    int32 thread_id,
+    int32 request_id,
+    WebServiceWorkerError::ErrorType error_type,
+    string16 message) {
+  WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
+      pending_callbacks_.Lookup(request_id);
+  DCHECK(callbacks);
+  if (!callbacks)

[michaeln, 2013/10/25 21:41:25]

do we need the test for !callback?

[alecflett, 2013/10/25 23:41:56]

We've needed to do this for security reasons in IDB - error checking on the IPC
boundary.

[michaeln, 2013/10/26 00:41:01]

that makes good sense to me in the browser process, but less so in child
processes, i think we can trust completely ipc params going from browser->child,
and be very wary of param values going from child->browser

[alecflett, 2013/10/28 17:03:14]

Agreed that it's certainly much safer in the browser->child case, but I don't
think we can trust it completely.

But actually trust is just one issue: Going back and looking at IDB history I'm
also remembering that there were shutdown ordering issues that resulted in this
check: Some more details in http://crbug.com/104492

Long explanation: occasionally if a tab was closed while a transaction was
finishing, the renderer-side dispatcher could get cleaned up before the callback
finished. In certain cases, the IPC transaction-cancel message would get sent
from the renderer but wouldn't be serviced by the browser in time to avoid the
attempted callback. End result was a renderer crash.

I think that this addresses the same situation. 

+    return;
+
+  scoped_ptr<WebServiceWorkerError>  error(
+      new WebServiceWorkerError(error_type, message));
+  callbacks->onError(error.release());
+  pending_callbacks_.Remove(request_id);
+}
+
 void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() { delete this; }
 
 }  // namespace content