content/browser/service_worker/service_worker_process_manager.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROCESS_MANAGER_H_
   6 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROCESS_MANAGER_H_
   7
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/callback.h"
  12 #include "base/gtest_prod_util.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "content/common/service_worker/service_worker_status_code.h"
  16
  17 class GURL;
  18
  19 namespace content {
  20
  21 class BrowserContext;
  22 class SiteInstance;
  23
  24 // Interacts with the UI thread to keep RenderProcessHosts alive while the
  25 // ServiceWorker system is using them. It also tracks candidate processes
  26 // for each pattern. Each instance of ServiceWorkerProcessManager is destroyed
  27 // on the UI thread shortly after its ServiceWorkerContextWrapper is destroyed.
  28 class CONTENT_EXPORT ServiceWorkerProcessManager {
  29  public:
  30   // |*this| must be owned by a ServiceWorkerContextWrapper in a
  31   // StoragePartition within |browser_context|.
  32   explicit ServiceWorkerProcessManager(BrowserContext* browser_context);
  33
  34   // Shutdown must be called before the ProcessManager is destroyed.
  35   ~ServiceWorkerProcessManager();
  36
  37   // Synchronously prevents new processes from being allocated
  38   // and drops references to RenderProcessHosts.
  39   void Shutdown();
  40
  41   // Returns a reference to a running process suitable for starting the Service
  42   // Worker at |script_url|. Posts |callback| to the IO thread to indicate
  43   // whether creation succeeded and the process ID that has a new reference.
  44   //
  45   // Allocation can fail with SERVICE_WORKER_PROCESS_NOT_FOUND if
  46   // RenderProcessHost::Init fails.
  47   void AllocateWorkerProcess(
  48       int embedded_worker_id,
  49       const GURL& pattern,
  50       const GURL& script_url,
  51       const base::Callback<void(ServiceWorkerStatusCode,
  52                                 int process_id,
  53                                 bool is_new_process)>& callback);
  54
  55   // Drops a reference to a process that was running a Service Worker, and its
  56   // SiteInstance.  This must match a call to AllocateWorkerProcess.
  57   void ReleaseWorkerProcess(int embedded_worker_id);
  58
  59   // Sets a single process ID that will be used for all embedded workers.  This
  60   // bypasses the work of creating a process and managing its worker refcount so
  61   // that unittests can run without a BrowserContext.  The test is in charge of
  62   // making sure this is only called on the same thread as runs the UI message
  63   // loop.
  64   void SetProcessIdForTest(int process_id) {
  65     process_id_for_test_ = process_id;
  66   }
  67
  68   // Adds/removes process reference for the |pattern|, the process with highest
  69   // references count will be chosen to start a worker.
  70   void AddProcessReferenceToPattern(const GURL& pattern, int process_id);
  71   void RemoveProcessReferenceFromPattern(const GURL& pattern, int process_id);
  72
  73   // Returns true if the |pattern| has at least one process to run.
  74   bool PatternHasProcessToRun(const GURL& pattern) const;
  75
  76  private:
  77   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerProcessManagerTest, SortProcess);
  78
  79   // Information about the process for an EmbeddedWorkerInstance.
  80   struct ProcessInfo {
  81     explicit ProcessInfo(const scoped_refptr<SiteInstance>& site_instance);
  82     explicit ProcessInfo(int process_id);
  83     ~ProcessInfo();
  84
  85     // Stores the SiteInstance the Worker lives inside. This needs to outlive
  86     // the instance's use of its RPH to uphold assumptions in the
  87     // ContentBrowserClient interface.
  88     scoped_refptr<SiteInstance> site_instance;
  89
  90     // In case the process was allocated without using a SiteInstance, we need
  91     // to store a process ID to decrement a worker reference on shutdown.
  92     // TODO(jyasskin): Implement http://crbug.com/372045 or thread a frame_id in
  93     // so all processes can be allocated with a SiteInstance.
  94     int process_id;
  95   };
  96
  97   // Maps the process ID to its reference count.
  98   typedef std::map<int, int> ProcessRefMap;
  99
 100   // Maps registration scope pattern to ProcessRefMap.
 101   typedef std::map<const GURL, ProcessRefMap> PatternProcessRefMap;
 102
 103   // Returns a process vector sorted by the reference count for the |pattern|.
 104   std::vector<int> SortProcessesForPattern(const GURL& pattern) const;
 105
 106   // These fields are only accessed on the UI thread.
 107   BrowserContext* browser_context_;
 108
 109   // Maps the ID of a running EmbeddedWorkerInstance to information about the
 110   // process it's running inside. Since the Instances themselves live on the IO
 111   // thread, this can be slightly out of date:
 112   //  * instance_info_ is populated while an Instance is STARTING and before
 113   //    it's RUNNING.
 114   //  * instance_info_ is depopulated in a message sent as the Instance becomes
 115   //    STOPPED.
 116   std::map<int, ProcessInfo> instance_info_;
 117
 118   // In unit tests, this will be returned as the process for all
 119   // EmbeddedWorkerInstances.
 120   int process_id_for_test_;
 121
 122   // Candidate processes info for each pattern, should be accessed on the
 123   // UI thread.
 124   PatternProcessRefMap pattern_processes_;
 125
 126   // Used to double-check that we don't access *this after it's destroyed.
 127   base::WeakPtr<ServiceWorkerProcessManager> weak_this_;
 128   base::WeakPtrFactory<ServiceWorkerProcessManager> weak_this_factory_;
 129 };
 130
 131 }  // namespace content
 132
 133 namespace base {
 134 // Specialized to post the deletion to the UI thread.
 135 template <>
 136 struct CONTENT_EXPORT DefaultDeleter<content::ServiceWorkerProcessManager> {
 137   void operator()(content::ServiceWorkerProcessManager* ptr) const;
 138 };
 139 }  // namespace base
 140
 141 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_PROCESS_MANAGER_H_