Flush out initial [un]registerServiceWorker roundtrip

content/child/service_worker/service_worker_message_filter.h

Index: content/child/service_worker/service_worker_message_filter.h
diff --git a/content/child/quota_message_filter.h b/content/child/service_worker/service_worker_message_filter.h
similarity index 59%
copy from content/child/quota_message_filter.h
copy to content/child/service_worker/service_worker_message_filter.h
index 5e90c6ccc83a1a61930010ea31d5a07e600d7d22..7dc2bb5eda0043fd40b6ade9ac71c9e5285451fc 100644
--- a/content/child/quota_message_filter.h
+++ b/content/child/service_worker/service_worker_message_filter.h
@@ -1,28 +1,23 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// 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.
 
-#ifndef CONTENT_CHILD_QUOTA_MESSAGE_FILTER_H_
-#define CONTENT_CHILD_QUOTA_MESSAGE_FILTER_H_
+#ifndef CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_MESSAGE_FILTER_H_
+#define CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_MESSAGE_FILTER_H_
 
 #include <map>
 
-#include "base/synchronization/lock.h"
 #include "ipc/ipc_channel_proxy.h"
 
-namespace base {
-class MessageLoopProxy;
-}
-
 namespace content {
-
 class ThreadSafeSender;
+class MessageLoopProxy;
 
-class QuotaMessageFilter : public IPC::ChannelProxy::MessageFilter {
+class ServiceWorkerMessageFilter : public IPC::ChannelProxy::MessageFilter {
  public:
-  explicit QuotaMessageFilter(ThreadSafeSender* thread_safe_sender);
+  explicit ServiceWorkerMessageFilter(ThreadSafeSender* thread_safe_sender);
 
-  // IPC::Listener implementation.
+  // IPC::Listener implementation
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 
   // Registers { request_id, thread_id } map to the message filter.
@@ -30,22 +25,20 @@ class QuotaMessageFilter : public IPC::ChannelProxy::MessageFilter {
   void RegisterRequestID(int request_id, int thread_id);
 
  protected:
-  virtual ~QuotaMessageFilter();
+  virtual ~ServiceWorkerMessageFilter();
 
  private:
   typedef std::map<int, int> RequestIdToThreadId;
+  base::Lock request_id_map_lock_;
+  RequestIdToThreadId request_id_map_;

[michaeln, 2013/09/30 23:41:27]

There's a leak here. Upon worker shutdown, pending requests that map to that
thread should be deleted from this collection.

In what ways is having this mapping better than having the threadid being sent
round trip and not needing the mapping? With the mapping, we need locks and
extra logic to maintain the collection.

[kinuko, 2013/10/01 05:28:09]

I believe this part's designed after quota code, so let me write something about
this... In short I don't really feel either way is particularly better than the
other way. Sending thread_id to the browser process where the info is not needed
at all feels unfortunate while keeping a locked map isn't great either. The
former approach is simpler but taint wider code base. For quota case we already
had browser-side code and we didn't want to change it, so we took the locked map
approach. (Btw I'll need to fix the leak in quota code too)

 
   void DispatchMessage(const IPC::Message& msg);
-
   scoped_refptr<base::MessageLoopProxy> main_thread_loop_proxy_;
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
 
-  base::Lock request_id_map_lock_;
-  RequestIdToThreadId request_id_map_;
-
-  DISALLOW_COPY_AND_ASSIGN(QuotaMessageFilter);
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerMessageFilter);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_CHILD_QUOTA_MESSAGE_FILTER_H_
+#endif  // CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_MESSAGE_FILTER_H_