Added lifecycle management and sharing support for SharedWorkers. SharedWorkers

chrome/browser/worker_host/worker_process_host.h

 // Copyright (c) 2009 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 CHROME_BROWSER_WORKER_HOST_WORKER_PROCESS_HOST_H_
 #define CHROME_BROWSER_WORKER_HOST_WORKER_PROCESS_HOST_H_
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/task.h"
 #include "chrome/common/child_process_host.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_channel.h"
 
 class WorkerProcessHost : public ChildProcessHost {
  public:
   // Contains information about each worker instance, needed to forward messages
   // between the renderer and worker processes.
-  struct WorkerInstance {
+  class WorkerInstance {

[jam, 2009/11/12 20:11:23]

nit: If this is a class, then it's against the coding guidelines to have all the
member variables public (and without a "_" suffix).  Either keep it as a struct,
or add getters/setters.

+   public:
+    WorkerInstance() : closed(false) {};
+
+    // Checks if this WorkerInstance matches the passed url/name params

[jam, 2009/11/12 20:11:23]

nit: just to make it clear to someone reading the code, can you add a small
comment that the methods below apply only to shared workers?

+    // (per the comparison algorithm in the WebWorkers spec).
+    bool Matches(const GURL& url, const string16& name) const;
+
+    // Adds a document to a shared worker's document set.
+    void AddToDocumentSet(IPC::Message::Sender* parent,
+                          unsigned long long document_id);
+
+    // Checks to see if a document is in the worker's document set.
+    bool IsInDocumentSet(IPC::Message::Sender* parent,
+                         unsigned long long document_id) const;
+
+    // Removes a specific document from the set when that document is detached.
+    void RemoveFromDocumentSet(IPC::Message::Sender* parent,
+                               unsigned long long document_id);
+
+    // Invoked when a render process exits, to remove all associated documents
+    // from the set.
+    void RemoveAllAssociatedDocuments(IPC::Message::Sender* parent);
+
+    // APIs to manage the sender list for a given instance.
+    void AddSender(IPC::Message::Sender* sender, int sender_route_id);
+    void RemoveSender(IPC::Message::Sender* sender, int sender_route_id);
+    void RemoveSenders(IPC::Message::Sender* sender);
+    bool HasSender(IPC::Message::Sender* sender, int sender_route_id) const;
+
+    // Unique identifier for an associated document.
+    typedef std::pair<IPC::Message::Sender*, unsigned long long> DocumentInfo;
+    typedef std::set<DocumentInfo> DocumentSet;
+
+    typedef std::pair<IPC::Message::Sender*, int> SenderInfo;
+    typedef std::set<SenderInfo> SenderList;
+
     GURL url;
     bool is_shared;
+    bool closed;
     string16 name;
     int renderer_id;
     int render_view_route_id;
     int worker_route_id;
-    IPC::Message::Sender* sender;
-    int sender_id;
-    int sender_route_id;
+    SenderList senders;
+    DocumentSet document_set;
   };
 
   WorkerProcessHost(ResourceDispatcherHost* resource_dispatcher_host_);
   ~WorkerProcessHost();
 
   // Starts the process.  Returns true iff it succeeded.
   bool Init();
 
   // Creates a worker object in the process.
   void CreateWorker(const WorkerInstance& instance);
 
   // Returns true iff the given message from a renderer process was forwarded to
   // the worker.
-  bool FilterMessage(const IPC::Message& message, int sender_pid);
+  bool FilterMessage(const IPC::Message& message, IPC::Message::Sender* sender);
 
   void SenderShutdown(IPC::Message::Sender* sender);
 
+  // Shuts down any shared workers that are no longer referenced by active
+  // documents.
+  void DocumentDetached(IPC::Message::Sender* sender,
+                        unsigned long long document_id);
+
  protected:
   friend class WorkerService;
 
   typedef std::list<WorkerInstance> Instances;
   const Instances& instances() const { return instances_; }
+  Instances& mutable_instances() { return instances_; }
 
  private:
   // ResourceDispatcherHost::Receiver implementation:
   virtual URLRequestContext* GetRequestContext(
       uint32 request_id,
       const ViewHostMsg_Resource_Request& request_data);
 
   // Called when a message arrives from the worker process.
   void OnMessageReceived(const IPC::Message& message);
 
+  // Called when the app invokes close() from within worker context.
+  void OnWorkerContextClosed(int worker_route_id);
+
   // Given a Sender, returns the callback that generates a new routing id.
   static CallbackWithReturnValue<int>::Type* GetNextRouteIdCallback(
       IPC::Message::Sender* sender);
 
   // Relays a message to the given endpoint.  Takes care of parsing the message
   // if it contains a message port and sending it a valid route id.
   static void RelayMessage(const IPC::Message& message,
                            IPC::Message::Sender* sender,
                            int route_id,
                            CallbackWithReturnValue<int>::Type* next_route_id);
@@ skipping 13 matching lines @@
 
   Instances instances_;
 
   // A callback to create a routing id for the associated worker process.
   scoped_ptr<CallbackWithReturnValue<int>::Type> next_route_id_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkerProcessHost);
 };
 
 #endif  // CHROME_BROWSER_WORKER_HOST_WORKER_PROCESS_HOST_H_