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_BROWSER_PLUGIN_PROCESS_HOST_H_ 6#define CONTENT_BROWSER_PLUGIN_PROCESS_HOST_H_ 7 8#include "build/build_config.h" 9 10#include <list> 11#include <set> 12#include <string> 13#include <vector> 14 15#include "base/basictypes.h" 16#include "base/compiler_specific.h" 17#include "base/memory/ref_counted.h" 18#include "content/common/content_export.h" 19#include "content/public/browser/browser_child_process_host_delegate.h" 20#include "content/public/browser/browser_child_process_host_iterator.h" 21#include "content/public/common/process_type.h" 22#include "content/public/common/webplugininfo.h" 23#include "ipc/ipc_channel_proxy.h" 24#include "ui/gfx/native_widget_types.h" 25 26namespace gfx { 27class Rect; 28} 29 30namespace IPC { 31struct ChannelHandle; 32} 33 34namespace content { 35class BrowserChildProcessHostImpl; 36class ResourceContext; 37 38// Represents the browser side of the browser <--> plugin communication 39// channel. Different plugins run in their own process, but multiple instances 40// of the same plugin run in the same process. There will be one 41// PluginProcessHost per plugin process, matched with a corresponding 42// PluginProcess running in the plugin process. The browser is responsible for 43// starting the plugin process when a plugin is created that doesn't already 44// have a process. After that, most of the communication is directly between 45// the renderer and plugin processes. 46class CONTENT_EXPORT PluginProcessHost : public BrowserChildProcessHostDelegate, 47 public IPC::Sender { 48 public: 49 class Client { 50 public: 51 // Returns an opaque unique identifier for the process requesting 52 // the channel. 53 virtual int ID() = 0; 54 // Returns the resource context for the renderer requesting the channel. 55 virtual ResourceContext* GetResourceContext() = 0; 56 virtual bool OffTheRecord() = 0; 57 virtual void SetPluginInfo(const WebPluginInfo& info) = 0; 58 virtual void OnFoundPluginProcessHost(PluginProcessHost* host) = 0; 59 virtual void OnSentPluginChannelRequest() = 0; 60 // The client should delete itself when one of these methods is called. 61 virtual void OnChannelOpened(const IPC::ChannelHandle& handle) = 0; 62 virtual void OnError() = 0; 63 64 protected: 65 virtual ~Client() {} 66 }; 67 68 PluginProcessHost(); 69 virtual ~PluginProcessHost(); 70 71 // IPC::Sender implementation: 72 virtual bool Send(IPC::Message* message) OVERRIDE; 73 74 // Initialize the new plugin process, returning true on success. This must 75 // be called before the object can be used. 76 bool Init(const WebPluginInfo& info); 77 78 // Force the plugin process to shutdown (cleanly). 79 void ForceShutdown(); 80 81 virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE; 82 virtual void OnChannelConnected(int32 peer_pid) OVERRIDE; 83 virtual void OnChannelError() OVERRIDE; 84 85 // Tells the plugin process to create a new channel for communication with a 86 // renderer. When the plugin process responds with the channel name, 87 // OnChannelOpened in the client is called. 88 void OpenChannelToPlugin(Client* client); 89 90 // Cancels all pending channel requests for the given resource context. 91 static void CancelPendingRequestsForResourceContext(ResourceContext* context); 92 93 // This function is called to cancel pending requests to open new channels. 94 void CancelPendingRequest(Client* client); 95 96 // This function is called to cancel sent requests to open new channels. 97 void CancelSentRequest(Client* client); 98 99 // This function is called on the IO thread once we receive a reply from the 100 // modal HTML dialog (in the form of a JSON string). This function forwards 101 // that reply back to the plugin that requested the dialog. 102 void OnModalDialogResponse(const std::string& json_retval, 103 IPC::Message* sync_result); 104 105#if defined(OS_MACOSX) 106 // This function is called on the IO thread when the browser becomes the 107 // active application. 108 void OnAppActivation(); 109#endif 110 111 const WebPluginInfo& info() const { return info_; } 112 113#if defined(OS_WIN) 114 // Tracks plugin parent windows created on the browser UI thread. 115 void AddWindow(HWND window); 116#endif 117 118 // Adds an IPC message filter. A reference will be kept to the filter. 119 void AddFilter(IPC::ChannelProxy::MessageFilter* filter); 120 121 private: 122 // Sends a message to the plugin process to request creation of a new channel 123 // for the given mime type. 124 void RequestPluginChannel(Client* client); 125 126 // Message handlers. 127 void OnChannelCreated(const IPC::ChannelHandle& channel_handle); 128 129#if defined(OS_WIN) 130 void OnPluginWindowDestroyed(HWND window, HWND parent); 131#endif 132 133#if defined(USE_X11) 134 void OnMapNativeViewId(gfx::NativeViewId id, gfx::PluginWindowHandle* output); 135#endif 136 137#if defined(OS_MACOSX) 138 void OnPluginSelectWindow(uint32 window_id, gfx::Rect window_rect, 139 bool modal); 140 void OnPluginShowWindow(uint32 window_id, gfx::Rect window_rect, 141 bool modal); 142 void OnPluginHideWindow(uint32 window_id, gfx::Rect window_rect); 143 void OnPluginSetCursorVisibility(bool visible); 144#endif 145 146 virtual bool CanShutdown() OVERRIDE; 147 virtual void OnProcessCrashed(int exit_code) OVERRIDE; 148 149 void CancelRequests(); 150 151 // These are channel requests that we are waiting to send to the 152 // plugin process once the channel is opened. 153 std::vector<Client*> pending_requests_; 154 155 // These are the channel requests that we have already sent to 156 // the plugin process, but haven't heard back about yet. 157 std::list<Client*> sent_requests_; 158 159 // Information about the plugin. 160 WebPluginInfo info_; 161 162#if defined(OS_WIN) 163 // Tracks plugin parent windows created on the UI thread. 164 std::set<HWND> plugin_parent_windows_set_; 165#endif 166#if defined(OS_MACOSX) 167 // Tracks plugin windows currently visible. 168 std::set<uint32> plugin_visible_windows_set_; 169 // Tracks full screen windows currently visible. 170 std::set<uint32> plugin_fullscreen_windows_set_; 171 // Tracks modal windows currently visible. 172 std::set<uint32> plugin_modal_windows_set_; 173 // Tracks the current visibility of the cursor. 174 bool plugin_cursor_visible_; 175#endif 176 177 scoped_ptr<BrowserChildProcessHostImpl> process_; 178 179 DISALLOW_COPY_AND_ASSIGN(PluginProcessHost); 180}; 181 182class PluginProcessHostIterator 183 : public BrowserChildProcessHostTypeIterator<PluginProcessHost> { 184 public: 185 PluginProcessHostIterator() 186 : BrowserChildProcessHostTypeIterator<PluginProcessHost>( 187 PROCESS_TYPE_PLUGIN) {} 188}; 189 190} // namespace content 191 192#endif // CONTENT_BROWSER_PLUGIN_PROCESS_HOST_H_ 193