service worker: Avoid starting up for activation during shutdown

content/browser/service_worker/service_worker_process_manager.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_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROCESS_MANAGER_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROCESS_MANAGER_H_
 
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/weak_ptr.h"
+#include "base/synchronization/lock.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 
 class GURL;
 
 namespace content {
 
 class BrowserContext;
 struct EmbeddedWorkerSettings;
 class SiteInstance;
 
 // Interacts with the UI thread to keep RenderProcessHosts alive while the
 // ServiceWorker system is using them. It also tracks candidate processes
 // for each pattern. Each instance of ServiceWorkerProcessManager is destroyed
 // on the UI thread shortly after its ServiceWorkerContextWrapper is destroyed.
 class CONTENT_EXPORT ServiceWorkerProcessManager {
  public:
   // |*this| must be owned by a ServiceWorkerContextWrapper in a
   // StoragePartition within |browser_context|.
   explicit ServiceWorkerProcessManager(BrowserContext* browser_context);
 
   // Shutdown must be called before the ProcessManager is destroyed.
   ~ServiceWorkerProcessManager();
 
   // Synchronously prevents new processes from being allocated
-  // and drops references to RenderProcessHosts.
+  // and drops references to RenderProcessHosts. Called on the UI thread.
   void Shutdown();
 
+  // Returns true if Shutdown() has been called. May be called by any thread.
+  bool IsShutdown();
+
   // Returns a reference to a running process suitable for starting the Service
   // Worker at |script_url|. Posts |callback| to the IO thread to indicate
   // whether creation succeeded and the process ID that has a new reference.
   //
   // Allocation can fail with SERVICE_WORKER_PROCESS_NOT_FOUND if
   // RenderProcessHost::Init fails.
   void AllocateWorkerProcess(
       int embedded_worker_id,
       const GURL& pattern,
       const GURL& script_url,
@@ skipping 50 matching lines @@
     // ContentBrowserClient interface.
     scoped_refptr<SiteInstance> site_instance;
 
     // In case the process was allocated without using a SiteInstance, we need
     // to store a process ID to decrement a worker reference on shutdown.
     // TODO(jyasskin): Implement http://crbug.com/372045 or thread a frame_id in
     // so all processes can be allocated with a SiteInstance.
     int process_id;
   };
 
-  // Returns true if Shutdown() has been called.
-  bool IsShutdown() const { return !browser_context_; }
-
   // Maps the process ID to its reference count.
   typedef std::map<int, int> ProcessRefMap;
 
   // Maps registration scope pattern to ProcessRefMap.
   typedef std::map<const GURL, ProcessRefMap> PatternProcessRefMap;
 
   // Returns a process vector sorted by the reference count for the |pattern|.
   std::vector<int> SortProcessesForPattern(const GURL& pattern) const;
 
   // Returns the id of an available process for this pattern, or
   // ChildProcessHost::kInvalidUniqueID if there is none.
   int FindAvailableProcess(const GURL& pattern);
 
-  // These fields are only accessed on the UI thread.
+  // Guarded by |browser_context_lock_|.
+  // Written only on the UI thread, so the UI thread doesn't need to acquire the
+  // lock when reading. Can be read from other threads with the lock.
   BrowserContext* browser_context_;
 
+  // Protects |browser_context_|.
+  base::Lock browser_context_lock_;
+
+  // All fields below are only accessed on the UI thread.
+
   // Maps the ID of a running EmbeddedWorkerInstance to information about the
   // process it's running inside. Since the Instances themselves live on the IO
   // thread, this can be slightly out of date:
   //  * instance_info_ is populated while an Instance is STARTING and before
   //    it's RUNNING.
   //  * instance_info_ is depopulated in a message sent as the Instance becomes
   //    STOPPED.
   std::map<int, ProcessInfo> instance_info_;
 
   // In unit tests, this will be returned as the process for all
@@ skipping 14 matching lines @@
 
 namespace std {
 // Specialized to post the deletion to the UI thread.
 template <>
 struct CONTENT_EXPORT default_delete<content::ServiceWorkerProcessManager> {
   void operator()(content::ServiceWorkerProcessManager* ptr) const;
 };
 }  // namespace std
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROCESS_MANAGER_H_