ServiceWorker: Expose registration within ServiceWorkerGlobalScope [2/3]

content/child/service_worker/service_worker_provider_context.h

 // 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.
 
 #ifndef CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_CONTEXT_H_
 #define CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_CONTEXT_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 10 matching lines @@
 class Message;
 }
 
 namespace content {
 
 class ServiceWorkerHandleReference;
 class ServiceWorkerRegistrationHandleReference;
 struct ServiceWorkerProviderContextDeleter;
 class ThreadSafeSender;
 
-// An instance of this class holds document-related information (e.g.
-// .controller). Created and destructed on the main thread.
-// TODO(kinuko): To support navigator.serviceWorker in dedicated workers
-// this needs to be RefCountedThreadSafe and .controller info needs to be
-// handled in a thread-safe manner (e.g. by a lock etc).
+// An instance of this class holds information related to Document/Worker.
+// Created and destructed on the main thread. Some functions can be called
+// on the worker thread (eg. GetVersionAttributes).
 class ServiceWorkerProviderContext
-    : public base::RefCounted<ServiceWorkerProviderContext> {
+    : public base::RefCountedThreadSafe<ServiceWorkerProviderContext,
+                                        ServiceWorkerProviderContextDeleter> {
  public:
   explicit ServiceWorkerProviderContext(int provider_id);
 
   // Called from ServiceWorkerDispatcher.
   void OnAssociateRegistration(const ServiceWorkerRegistrationObjectInfo& info,
                                const ServiceWorkerVersionAttributes& attrs);
   void OnDisassociateRegistration();
   void OnServiceWorkerStateChanged(int handle_id,
                                    blink::WebServiceWorkerState state);
   void OnSetControllerServiceWorker(const ServiceWorkerObjectInfo& info);
@@ skipping 26 matching lines @@
   // kInvalidServiceWorkerHandleId if the provider is not controlled
   // by a Service Worker.
   int controller_handle_id() const;
 
   // Gets the handle ID of the associated registration, or
   // kInvalidRegistrationHandleId if the provider is not associated with any
   // registration.
   int registration_handle_id() const;
 
  private:
-  friend class base::RefCounted<ServiceWorkerProviderContext>;
+  friend class base::DeleteHelper<ServiceWorkerProviderContext>;
+  friend class base::RefCountedThreadSafe<ServiceWorkerProviderContext,
+                                          ServiceWorkerProviderContextDeleter>;
+  friend struct ServiceWorkerProviderContextDeleter;
+
   ~ServiceWorkerProviderContext();
+  void DestructOnMainThread() const;
 
   const int provider_id_;
   scoped_refptr<base::MessageLoopProxy> main_thread_loop_proxy_;
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
+
+  // Protects (installing, waiting, active) worker and registration references.
+  base::Lock lock_;

[kinuko, 2015/01/22 08:05:44]

It's unfortunate that we still need a lock while the fields aren't really racy
any more... I really hoped there could be a point where we can simply hand over
the context from main thread to worker thread.

[nhiroki, 2015/01/22 09:09:16]

Piggyback on StartWorker message could be a solution (see my other comment).
I'll try it later.

+
+  // Used on both the main thread and the worker thread.
   scoped_ptr<ServiceWorkerHandleReference> installing_;
   scoped_ptr<ServiceWorkerHandleReference> waiting_;
   scoped_ptr<ServiceWorkerHandleReference> active_;
-  scoped_ptr<ServiceWorkerHandleReference> controller_;
   scoped_ptr<ServiceWorkerRegistrationHandleReference> registration_;
 
+  // Used only on the main thread.
+  scoped_ptr<ServiceWorkerHandleReference> controller_;
+
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerProviderContext);
 };
 
+struct ServiceWorkerProviderContextDeleter {
+  static void Destruct(const ServiceWorkerProviderContext* context) {
+    context->DestructOnMainThread();
+  }
+};
+
 }  // namespace content
 
 #endif  // CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_PROVIDER_CONTEXT_H_