Make DevTools support for the embedded SharedWorker.

content/browser/shared_worker/shared_worker_host.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_SHARED_WORKER_SHARED_WORKER_HOST_H_
 #define CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_HOST_H_
 
 #include <list>
 #include <vector>
 
@@ skipping 10 matching lines @@
 }
 
 namespace content {
 class SharedWorkerMessageFilter;
 class SharedWorkerInstance;
 
 // The SharedWorkerHost is the interface that represents the browser side of
 // the browser <-> worker communication channel.
 class SharedWorkerHost {
  public:
-  explicit SharedWorkerHost(SharedWorkerInstance* instance);
+  SharedWorkerHost(SharedWorkerInstance* instance,
+                   SharedWorkerMessageFilter* filter);
   ~SharedWorkerHost();
 
   // Sends |message| to the SharedWorker.
   bool Send(IPC::Message* message);
 
   // Starts the SharedWorker in the renderer process which is associated with
-  // |filter|.
-  void Init(SharedWorkerMessageFilter* filter);
+  // |filter_|.
+  void Start(bool pause_on_start);
 
   // Returns true iff the given message from a renderer process was forwarded to
   // the worker.
   bool FilterMessage(const IPC::Message& message,
                      SharedWorkerMessageFilter* filter);
 
   // Handles the shutdown of the filter. If the worker has no other client,
   // sends TerminateWorkerContext message to shut it down.
   void FilterShutdown(SharedWorkerMessageFilter* filter);
 
@@ skipping 22 matching lines @@
 
   void AddFilter(SharedWorkerMessageFilter* filter, int route_id);
 
   SharedWorkerInstance* instance() { return instance_.get(); }
   WorkerDocumentSet* worker_document_set() const {
     return worker_document_set_.get();
   }
   SharedWorkerMessageFilter* container_render_filter() const {
     return container_render_filter_;
   }
-  int process_id() const {
-    return container_render_filter_->render_process_id();
-  }
+  int process_id() const { return worker_process_id_; }
   int worker_route_id() const { return worker_route_id_; }
   bool load_failed() const { return load_failed_; }
   bool closed() const { return closed_; }
 
  private:
   // Unique identifier for a worker client.
   class FilterInfo {
    public:
     FilterInfo(SharedWorkerMessageFilter* filter, int route_id)
         : filter_(filter), route_id_(route_id), message_port_id_(0) {}
@@ skipping 21 matching lines @@
   void RemoveFilters(SharedWorkerMessageFilter* filter);
   bool HasFilter(SharedWorkerMessageFilter* filter, int route_id) const;
   void SetMessagePortID(SharedWorkerMessageFilter* filter,
                         int route_id,
                         int message_port_id);
 
   scoped_ptr<SharedWorkerInstance> instance_;
   scoped_refptr<WorkerDocumentSet> worker_document_set_;
   FilterList filters_;
   SharedWorkerMessageFilter* container_render_filter_;
+  int worker_process_id_;
   int worker_route_id_;
   bool load_failed_;
   bool closed_;
   const base::TimeTicks creation_time_;
   DISALLOW_COPY_AND_ASSIGN(SharedWorkerHost);
 };
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_HOST_H_