Flush out initial [un]registerServiceWorker roundtrip

content/browser/service_worker/service_worker_dispatcher_host.cc

 // Copyright 2013 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/browser/service_worker/service_worker_dispatcher_host.h"
 
 #include "content/browser/service_worker/service_worker_context.h"
 #include "content/common/service_worker_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "url/gurl.h"
 
 namespace content {
 
 ServiceWorkerDispatcherHost::ServiceWorkerDispatcherHost(
     ServiceWorkerContext* context)
     : context_(context) {}
 
 ServiceWorkerDispatcherHost::~ServiceWorkerDispatcherHost() {}
 
 bool ServiceWorkerDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                     bool* message_was_ok) {
-
   if (IPC_MESSAGE_CLASS(message) != ServiceWorkerMsgStart)
     return false;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(
     ServiceWorkerDispatcherHost, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_RegisterServiceWorker,
                         OnRegisterServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_UnregisterServiceWorker,
                         OnUnregisterServiceWorker)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-void ServiceWorkerDispatcherHost::OnRegisterServiceWorker(int32 registry_id,
-                                                       const string16& scope,
-                                                       const GURL& script_url) {
+// TODO(alecflett): Store the worker_id keyed by (domain+pattern,
+// script) so we don't always return a new service worker id.
+static int32 NextWorkerId() {

[michaeln, 2013/10/04 01:26:07]

i think we usually prefer 'int' where int will do

[alecflett, 2013/10/07 18:33:58]

cpplint will warn/complain if you use native types - besides, these are being
sent through messages, which need to have a fixed size.  In any case this is
just a temporary until I hook up the map in a followup CL.

+  static int32 worker_id = 0;
+  return worker_id++;
+}
+
+void ServiceWorkerDispatcherHost::OnRegisterServiceWorker(
+    int32 request_id,
+    const string16& scope,
+    const GURL& script_url) {
   // TODO(alecflett): Enforce that script_url must have the same
   // origin as the registering document.

[michaeln, 2013/10/04 01:26:07]

I'd vote to put in place scaffolding/structure that we believe will allow us to
do what this comment suggests. As coded logic in this method body doesn't have
any chance of doing that because it's got nothing to go on about where this call
to register something is coming from.

[alecflett, 2013/10/07 18:33:58]

OK

+  Send(
+      new ServiceWorkerMsg_ServiceWorkerRegistered(request_id, NextWorkerId()));
 }
 
 void ServiceWorkerDispatcherHost::OnUnregisterServiceWorker(
-    int32 registry_id,
-    const string16& scope) {}
+    int32 request_id,
+    const string16& scope) {
+  Send(new ServiceWorkerMsg_ServiceWorkerUnregistered(request_id,
+                                                      NextWorkerId()));
+}
 
 }  // namespace content