Make DevTools support for the embedded SharedWorker.

content/browser/devtools/shared_worker_devtools_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_POWER_PROFILER_POWER_PROFILER_SERVICE_H_
-#define CONTENT_BROWSER_POWER_PROFILER_POWER_PROFILER_SERVICE_H_
+#ifndef CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
+#define CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_
 
 #include "base/basictypes.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/gtest_prod_util.h"
+#include "base/memory/scoped_vector.h"
 #include "base/memory/singleton.h"
-#include "base/observer_list.h"
-#include "base/task_runner.h"
-#include "base/timer/timer.h"
-#include "content/browser/power_profiler/power_data_provider.h"
-#include "content/browser/power_profiler/power_profiler_observer.h"
+#include "base/strings/string16.h"
+#include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/common/content_export.h"
 
+class GURL;
+
 namespace content {
+class DevToolsAgentHost;
 
-// A class used to query power information and notify the observers.
-class CONTENT_EXPORT PowerProfilerService {
+// SharedWorkerDevToolsManager is used instead of WorkerDevToolsManager when
+// "enable-embedded-shared-worker" flag is set.
+// This class lives on UI thread.
+class CONTENT_EXPORT SharedWorkerDevToolsManager {
  public:
-  static PowerProfilerService* GetInstance();
+  typedef std::pair<int, int> WorkerId;
+  class SharedWorkerDevToolsAgentHost;
 
-  // Add and remove an observer.
-  void AddObserver(PowerProfilerObserver* observer);
-  void RemoveObserver(PowerProfilerObserver* observer);
+  // Returns the SharedWorkerDevToolsManager singleton.
+  static SharedWorkerDevToolsManager* GetInstance();
 
-  bool IsAvailable();
+  DevToolsAgentHost* GetDevToolsAgentHostForWorker(int worker_process_id,
+                                                   int worker_route_id);
 
-  virtual ~PowerProfilerService();
+  // Returns true when the worker must be paused on start.
+  bool WorkerCreated(int worker_process_id,
+                     int worker_route_id,
+                     const SharedWorkerInstance& instance);
+  void WorkerDestroyed(int worker_process_id, int worker_route_id);
+  void WorkerContextStarted(int worker_process_id, int worker_route_id);
 
  private:
-  enum Status {
-    UNINITIALIZED,
-    INITIALIZED,  // Initialized, profiling has not started.
-    PROFILING
+  friend struct DefaultSingletonTraits<SharedWorkerDevToolsManager>;
+  friend class SharedWorkerDevToolsManagerTest;
+  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, BasicTest);
+  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, AttachTest);
+
+  enum WorkerState {
+    WORKER_UNINSPECTED,
+    WORKER_INSPECTED,
+    WORKER_TERMINATED,
+    WORKER_PAUSED,
   };
 
-  friend struct DefaultSingletonTraits<PowerProfilerService>;
-  friend class PowerProfilerServiceTest;
+  class WorkerInfo {
+   public:
+    explicit WorkerInfo(const SharedWorkerInstance& instance)
+        : instance_(instance), state_(WORKER_UNINSPECTED), agent_host_(NULL) {}
 
-  PowerProfilerService();
+    const SharedWorkerInstance& instance() const { return instance_; }
+    WorkerState state() { return state_; }
+    void set_state(WorkerState new_state) { state_ = new_state; }
+    SharedWorkerDevToolsAgentHost* agent_host() { return agent_host_; }
+    void set_agent_host(SharedWorkerDevToolsAgentHost* agent_host) {
+      agent_host_ = agent_host;
+    }
 
-  PowerProfilerService(scoped_ptr<PowerDataProvider> provider,
-                       scoped_refptr<base::TaskRunner> task_runner,
-                       const base::TimeDelta& sample_period);
+   private:
+    const SharedWorkerInstance instance_;
+    WorkerState state_;
+    SharedWorkerDevToolsAgentHost* agent_host_;
+  };
 
-  void Start();
-  void Stop();
+  typedef base::ScopedPtrHashMap<WorkerId, WorkerInfo> WorkerInfoMap;
 
-  // Query power data from PowerDataProvider, executes on the WorkerPool thread.
-  void QueryDataOnTaskRunner();
+  SharedWorkerDevToolsManager();
+  virtual ~SharedWorkerDevToolsManager();
 
-  // Initiate the query on the UI thread, the task is delegated to
-  // QueryDataOnTaskRunner.
-  void QueryData();
+  void RemoveInspectedWorkerData(SharedWorkerDevToolsAgentHost* agent_host);
 
-  // Executes on the UI thread.
-  void Notify(const PowerEventVector&);
+  WorkerInfoMap::iterator FindExistingWorkerInfo(
+      const SharedWorkerInstance& instance);
 
-  base::RepeatingTimer<PowerProfilerService> query_power_timer_;
-  scoped_refptr<base::TaskRunner> task_runner_;
+  // Resets to its initial state as if newly created.
+  void ResetForTesting();
 
-  Status status_;
+  WorkerInfoMap workers_;
 
-  // Sampling period of power data measurement.
-  const base::TimeDelta sample_period_;
-  ObserverList<PowerProfilerObserver> observers_;
-
-  scoped_ptr<PowerDataProvider> data_provider_;
-
-  DISALLOW_COPY_AND_ASSIGN(PowerProfilerService);
+  DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsManager);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_POWER_PROFILER_POWER_PROFILER_SERVICE_H_
+#endif  // CONTENT_BROWSER_DEVTOOLS_SHARED_WORKER_DEVTOOLS_MANAGER_H_