content/renderer/websharedworker_proxy.h

   1 // Copyright (c) 2012 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_RENDERER_WEBSHAREDWORKER_PROXY_H_
   6 #define CONTENT_RENDERER_WEBSHAREDWORKER_PROXY_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "ipc/ipc_listener.h"
  14 #include "third_party/WebKit/public/web/WebSharedWorker.h"
  15 #include "url/gurl.h"
  16
  17 namespace content {
  18
  19 class ChildThread;
  20
  21 // Implementation of the WebSharedWorker APIs. This object is intended to only
  22 // live long enough to allow the caller to send a "connect" event to the worker
  23 // thread. Once the connect event has been sent, all future communication will
  24 // happen via the WebMessagePortChannel, and the WebSharedWorker instance will
  25 // be freed.
  26 class WebSharedWorkerProxy : public WebKit::WebSharedWorker,
  27                              private IPC::Listener {
  28  public:
  29   // If the worker not loaded yet, route_id == MSG_ROUTING_NONE
  30   WebSharedWorkerProxy(ChildThread* child_thread,
  31                        unsigned long long document_id,
  32                        bool exists,
  33                        int route_id,
  34                        int render_view_route_id);
  35   virtual ~WebSharedWorkerProxy();
  36
  37   // Implementations of WebSharedWorker APIs
  38   virtual bool isStarted();
  39   virtual void connect(WebKit::WebMessagePortChannel* channel,
  40                        ConnectListener* listener);
  41
  42   virtual void startWorkerContext(
  43       const WebKit::WebURL& script_url,
  44       const WebKit::WebString& name,
  45       const WebKit::WebString& user_agent,
  46       const WebKit::WebString& source_code,
  47       const WebKit::WebString& content_security_policy,
  48       WebKit::WebContentSecurityPolicyType policy_type,
  49       long long script_resource_appcache_id);
  50
  51   virtual void terminateWorkerContext();
  52   virtual void clientDestroyed();
  53
  54  private:
  55   // IPC::Listener implementation.
  56   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
  57
  58   // Returns true if the worker is running (can send messages to it).
  59   bool IsStarted();
  60
  61   // Disconnects the worker (stops listening for incoming messages).
  62   void Disconnect();
  63
  64   // Sends a message to the worker thread (forwarded via the RenderViewHost).
  65   // If WorkerStarted() has not yet been called, message is queued.
  66   bool Send(IPC::Message*);
  67
  68   // Returns true if there are queued messages.
  69   bool HasQueuedMessages() { return !queued_messages_.empty(); }
  70
  71   // Sends any messages currently in the queue.
  72   void SendQueuedMessages();
  73
  74   void CreateWorkerContext(const GURL& script_url,
  75                            bool is_shared,
  76                            const string16& name,
  77                            const string16& user_agent,
  78                            const string16& source_code,
  79                            const string16& content_security_policy,
  80                            WebKit::WebContentSecurityPolicyType policy_type,
  81                            int pending_route_id,
  82                            int64 script_resource_appcache_id);
  83   void OnWorkerCreated();
  84
  85
  86   // Routing id associated with this worker - used to receive messages from the
  87   // worker, and also to route messages to the worker (WorkerService contains
  88   // a map that maps between these renderer-side route IDs and worker-side
  89   // routing ids).
  90   int route_id_;
  91
  92   // The routing id for the RenderView that created this worker.
  93   int render_view_route_id_;
  94
  95   ChildThread* child_thread_;
  96
  97   // ID of our parent document (used to shutdown workers when the parent
  98   // document is detached).
  99   unsigned long long document_id_;
 100
 101   // Stores messages that were sent before the StartWorkerContext message.
 102   std::vector<IPC::Message*> queued_messages_;
 103
 104   // The id for the placeholder worker instance we've stored on the
 105   // browser process (we need to pass this same route id back in when creating
 106   // the worker).
 107   int pending_route_id_;
 108   ConnectListener* connect_listener_;
 109
 110   DISALLOW_COPY_AND_ASSIGN(WebSharedWorkerProxy);
 111 };
 112
 113 }  // namespace content
 114
 115 #endif  // CONTENT_RENDERER_WEBSHAREDWORKER_PROXY_H_