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 17namespace content { 18 19class 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. 26class 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_ 116