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/WebSharedWorkerConnector.h" 15 #include "url/gurl.h" 16 17 namespace content { 18 19 class MessageRouter; 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 blink::WebSharedWorkerConnector, 27 private IPC::Listener { 28 public: 29 // If the worker not loaded yet, route_id == MSG_ROUTING_NONE 30 WebSharedWorkerProxy(MessageRouter* router, 31 unsigned long long document_id, 32 int route_id, 33 int render_frame_route_id); 34 virtual ~WebSharedWorkerProxy(); 35 36 // Implementations of WebSharedWorkerConnector APIs 37 virtual void connect(blink::WebMessagePortChannel* channel, 38 ConnectListener* listener); 39 40 private: 41 // IPC::Listener implementation. 42 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; 43 44 // Disconnects the worker (stops listening for incoming messages). 45 void Disconnect(); 46 47 // Sends a message to the worker thread (forwarded via the RenderViewHost). 48 // If WorkerStarted() has not yet been called, message is queued. 49 bool Send(IPC::Message*); 50 51 // Returns true if there are queued messages. HasQueuedMessages()52 bool HasQueuedMessages() { return !queued_messages_.empty(); } 53 54 // Sends any messages currently in the queue. 55 void SendQueuedMessages(); 56 57 void OnWorkerCreated(); 58 void OnWorkerScriptLoadFailed(); 59 void OnWorkerConnected(); 60 61 // Routing id associated with this worker - used to receive messages from the 62 // worker, and also to route messages to the worker (WorkerService contains 63 // a map that maps between these renderer-side route IDs and worker-side 64 // routing ids). 65 int route_id_; 66 67 // The routing id for the RenderFrame that created this worker. 68 int render_frame_route_id_; 69 70 MessageRouter* const router_; 71 72 // ID of our parent document (used to shutdown workers when the parent 73 // document is detached). 74 unsigned long long document_id_; 75 76 // Stores messages that were sent before the StartWorkerContext message. 77 std::vector<IPC::Message*> queued_messages_; 78 79 // The id for the placeholder worker instance we've stored on the 80 // browser process (we need to pass this same route id back in when creating 81 // the worker). 82 int pending_route_id_; 83 ConnectListener* connect_listener_; 84 bool created_; 85 86 DISALLOW_COPY_AND_ASSIGN(WebSharedWorkerProxy); 87 }; 88 89 } // namespace content 90 91 #endif // CONTENT_RENDERER_WEBSHAREDWORKER_PROXY_H_ 92