content/browser/devtools/embedded_worker_devtools_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_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
   6 #define CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/containers/scoped_ptr_hash_map.h"
  10 #include "base/gtest_prod_util.h"
  11 #include "base/memory/scoped_vector.h"
  12 #include "base/memory/singleton.h"
  13 #include "base/strings/string16.h"
  14 #include "content/browser/shared_worker/shared_worker_instance.h"
  15 #include "content/common/content_export.h"
  16
  17 namespace content {
  18
  19 class DevToolsAgentHost;
  20 class ServiceWorkerContextCore;
  21
  22 // EmbeddedWorkerDevToolsManager is used instead of WorkerDevToolsManager when
  23 // "enable-embedded-shared-worker" flag is set.
  24 // This class lives on UI thread.
  25 class CONTENT_EXPORT EmbeddedWorkerDevToolsManager {
  26  public:
  27   typedef std::pair<int, int> WorkerId;
  28   class EmbeddedWorkerDevToolsAgentHost;
  29
  30   class ServiceWorkerIdentifier {
  31    public:
  32     ServiceWorkerIdentifier(
  33         const ServiceWorkerContextCore* const service_worker_context,
  34         int64 service_worker_version_id);
  35     explicit ServiceWorkerIdentifier(const ServiceWorkerIdentifier& other);
  36     ~ServiceWorkerIdentifier() {}
  37
  38     bool Matches(const ServiceWorkerIdentifier& other) const;
  39
  40    private:
  41     const ServiceWorkerContextCore* const service_worker_context_;
  42     const int64 service_worker_version_id_;
  43   };
  44
  45   // Returns the EmbeddedWorkerDevToolsManager singleton.
  46   static EmbeddedWorkerDevToolsManager* GetInstance();
  47
  48   DevToolsAgentHost* GetDevToolsAgentHostForWorker(int worker_process_id,
  49                                                    int worker_route_id);
  50   DevToolsAgentHost* GetDevToolsAgentHostForServiceWorker(
  51       const ServiceWorkerIdentifier& service_worker_id);
  52
  53   // Returns true when the worker must be paused on start because a DevTool
  54   // window for the same former SharedWorkerInstance is still opened.
  55   bool SharedWorkerCreated(int worker_process_id,
  56                            int worker_route_id,
  57                            const SharedWorkerInstance& instance);
  58   // Returns true when the worker must be paused on start because a DevTool
  59   // window for the same former ServiceWorkerIdentifier is still opened or
  60   // debug-on-start is enabled in chrome://serviceworker-internals.
  61   bool ServiceWorkerCreated(int worker_process_id,
  62                             int worker_route_id,
  63                             const ServiceWorkerIdentifier& service_worker_id);
  64   void WorkerContextStarted(int worker_process_id, int worker_route_id);
  65   void WorkerDestroyed(int worker_process_id, int worker_route_id);
  66
  67   void set_debug_service_worker_on_start(bool debug_on_start) {
  68     debug_service_worker_on_start_ = debug_on_start;
  69   }
  70   bool debug_service_worker_on_start() const {
  71     return debug_service_worker_on_start_;
  72   }
  73
  74  private:
  75   friend struct DefaultSingletonTraits<EmbeddedWorkerDevToolsManager>;
  76   friend class EmbeddedWorkerDevToolsManagerTest;
  77   FRIEND_TEST_ALL_PREFIXES(EmbeddedWorkerDevToolsManagerTest, BasicTest);
  78   FRIEND_TEST_ALL_PREFIXES(EmbeddedWorkerDevToolsManagerTest, AttachTest);
  79
  80   enum WorkerState {
  81     WORKER_UNINSPECTED,
  82     WORKER_INSPECTED,
  83     WORKER_TERMINATED,
  84     WORKER_PAUSED_FOR_DEBUG_ON_START,
  85     WORKER_PAUSED_FOR_REATTACH,
  86   };
  87
  88   class WorkerInfo {
  89    public:
  90     // Creates WorkerInfo for SharedWorker.
  91     explicit WorkerInfo(const SharedWorkerInstance& instance);
  92     // Creates WorkerInfo for ServiceWorker.
  93     explicit WorkerInfo(const ServiceWorkerIdentifier& service_worker_id);
  94     ~WorkerInfo();
  95
  96     WorkerState state() { return state_; }
  97     void set_state(WorkerState new_state) { state_ = new_state; }
  98     EmbeddedWorkerDevToolsAgentHost* agent_host() { return agent_host_; }
  99     void set_agent_host(EmbeddedWorkerDevToolsAgentHost* agent_host) {
 100       agent_host_ = agent_host;
 101     }
 102     bool Matches(const SharedWorkerInstance& other);
 103     bool Matches(const ServiceWorkerIdentifier& other);
 104
 105    private:
 106     scoped_ptr<SharedWorkerInstance> shared_worker_instance_;
 107     scoped_ptr<ServiceWorkerIdentifier> service_worker_id_;
 108     WorkerState state_;
 109     EmbeddedWorkerDevToolsAgentHost* agent_host_;
 110   };
 111
 112   typedef base::ScopedPtrHashMap<WorkerId, WorkerInfo> WorkerInfoMap;
 113
 114   EmbeddedWorkerDevToolsManager();
 115   virtual ~EmbeddedWorkerDevToolsManager();
 116
 117   void RemoveInspectedWorkerData(EmbeddedWorkerDevToolsAgentHost* agent_host);
 118
 119   WorkerInfoMap::iterator FindExistingSharedWorkerInfo(
 120       const SharedWorkerInstance& instance);
 121   WorkerInfoMap::iterator FindExistingServiceWorkerInfo(
 122       const ServiceWorkerIdentifier& service_worker_id);
 123
 124   void MoveToPausedState(const WorkerId& id, const WorkerInfoMap::iterator& it);
 125
 126   // Resets to its initial state as if newly created.
 127   void ResetForTesting();
 128
 129   WorkerInfoMap workers_;
 130
 131   bool debug_service_worker_on_start_;
 132
 133   DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerDevToolsManager);
 134 };
 135
 136 }  // namespace content
 137
 138 #endif  // CONTENT_BROWSER_DEVTOOLS_EMBEDDED_WORKER_DEVTOOLS_MANAGER_H_