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_PPAPI_PLUGIN_PROCESS_HOST_H_
6#define CONTENT_BROWSER_PPAPI_PLUGIN_PROCESS_HOST_H_
7
8#include <queue>
9#include <vector>
10
11#include "base/basictypes.h"
12#include "base/files/file_path.h"
13#include "base/memory/ref_counted.h"
14#include "base/memory/scoped_ptr.h"
15#include "base/process/process.h"
16#include "base/strings/string16.h"
17#include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
18#include "content/browser/renderer_host/pepper/pepper_message_filter.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 "ipc/ipc_sender.h"
22#include "ppapi/shared_impl/ppapi_permissions.h"
23
24namespace net {
25class HostResolver;
26}
27
28namespace content {
29class BrowserChildProcessHostImpl;
30class ResourceContext;
31struct PepperPluginInfo;
32
33// Process host for PPAPI plugin and broker processes.
34// When used for the broker, interpret all references to "plugin" with "broker".
35class PpapiPluginProcessHost : public BrowserChildProcessHostDelegate,
36                               public IPC::Sender {
37 public:
38  class Client {
39   public:
40    // Gets the information about the renderer that's requesting the channel.
41    virtual void GetPpapiChannelInfo(base::ProcessHandle* renderer_handle,
42                                     int* renderer_id) = 0;
43
44    // Called when the channel is asynchronously opened to the plugin or on
45    // error. On error, the parameters should be:
46    //   base::kNullProcessHandle
47    //   IPC::ChannelHandle(),
48    //   0
49    virtual void OnPpapiChannelOpened(
50        const IPC::ChannelHandle& channel_handle,
51        base::ProcessId plugin_pid,
52        int plugin_child_id) = 0;
53
54    // Returns true if the current connection is off-the-record.
55    virtual bool OffTheRecord() = 0;
56
57   protected:
58    virtual ~Client() {}
59  };
60
61  class PluginClient : public Client {
62   public:
63    // Returns the resource context for the renderer requesting the channel.
64    virtual ResourceContext* GetResourceContext() = 0;
65
66   protected:
67    virtual ~PluginClient() {}
68  };
69
70  class BrokerClient : public Client {
71   protected:
72    virtual ~BrokerClient() {}
73  };
74
75  virtual ~PpapiPluginProcessHost();
76
77  static PpapiPluginProcessHost* CreatePluginHost(
78      const PepperPluginInfo& info,
79      const base::FilePath& profile_data_directory,
80      net::HostResolver* host_resolver);
81  static PpapiPluginProcessHost* CreateBrokerHost(
82      const PepperPluginInfo& info);
83
84  // Notification that a PP_Instance has been created and the associated
85  // renderer related data including the RenderView/Process pair for the given
86  // plugin. This is necessary so that when the plugin calls us with a
87  // PP_Instance we can find the RenderView associated with it without trusting
88  // the plugin.
89  static void DidCreateOutOfProcessInstance(
90      int plugin_process_id,
91      int32 pp_instance,
92      const PepperRendererInstanceData& instance_data);
93
94  // The opposite of DIdCreate... above.
95  static void DidDeleteOutOfProcessInstance(int plugin_process_id,
96                                            int32 pp_instance);
97
98  // Returns the instances that match the specified process name.
99  // It can only be called on the IO thread.
100  static void FindByName(const string16& name,
101                         std::vector<PpapiPluginProcessHost*>* hosts);
102
103  // IPC::Sender implementation:
104  virtual bool Send(IPC::Message* message) OVERRIDE;
105
106  // Opens a new channel to the plugin. The client will be notified when the
107  // channel is ready or if there's an error.
108  void OpenChannelToPlugin(Client* client);
109
110  BrowserPpapiHostImpl* host_impl() { return host_impl_.get(); }
111  const BrowserChildProcessHostImpl* process() { return process_.get(); }
112  const base::FilePath& plugin_path() const { return plugin_path_; }
113  const base::FilePath& profile_data_directory() const {
114    return profile_data_directory_;
115  }
116
117  // The client pointer must remain valid until its callback is issued.
118
119 private:
120  class PluginNetworkObserver;
121
122  // Constructors for plugin and broker process hosts, respectively.
123  // You must call Init before doing anything else.
124  PpapiPluginProcessHost(const PepperPluginInfo& info,
125                         const base::FilePath& profile_data_directory,
126                         net::HostResolver* host_resolver);
127  PpapiPluginProcessHost();
128
129  // Actually launches the process with the given plugin info. Returns true
130  // on success (the process was spawned).
131  bool Init(const PepperPluginInfo& info);
132
133  void RequestPluginChannel(Client* client);
134
135  virtual void OnProcessLaunched() OVERRIDE;
136
137  virtual void OnProcessCrashed(int exit_code) OVERRIDE;
138  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
139  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
140  virtual void OnChannelError() OVERRIDE;
141
142  void CancelRequests();
143
144  // IPC message handlers.
145  void OnRendererPluginChannelCreated(const IPC::ChannelHandle& handle);
146
147  // Handles most requests from the plugin. May be NULL.
148  scoped_refptr<PepperMessageFilter> filter_;
149
150  ppapi::PpapiPermissions permissions_;
151  scoped_ptr<BrowserPpapiHostImpl> host_impl_;
152
153  // Observes network changes. May be NULL.
154  scoped_ptr<PluginNetworkObserver> network_observer_;
155
156  // Channel requests that we are waiting to send to the plugin process once
157  // the channel is opened.
158  std::vector<Client*> pending_requests_;
159
160  // Channel requests that we have already sent to the plugin process, but
161  // haven't heard back about yet.
162  std::queue<Client*> sent_requests_;
163
164  // Path to the plugin library.
165  base::FilePath plugin_path_;
166
167  // Path to the top-level plugin data directory (differs based upon profile).
168  base::FilePath profile_data_directory_;
169
170  const bool is_broker_;
171
172  scoped_ptr<BrowserChildProcessHostImpl> process_;
173
174  DISALLOW_COPY_AND_ASSIGN(PpapiPluginProcessHost);
175};
176
177class PpapiPluginProcessHostIterator
178    : public BrowserChildProcessHostTypeIterator<
179          PpapiPluginProcessHost> {
180 public:
181  PpapiPluginProcessHostIterator()
182      : BrowserChildProcessHostTypeIterator<
183          PpapiPluginProcessHost>(PROCESS_TYPE_PPAPI_PLUGIN) {}
184};
185
186class PpapiBrokerProcessHostIterator
187    : public BrowserChildProcessHostTypeIterator<
188          PpapiPluginProcessHost> {
189 public:
190  PpapiBrokerProcessHostIterator()
191      : BrowserChildProcessHostTypeIterator<
192          PpapiPluginProcessHost>(PROCESS_TYPE_PPAPI_BROKER) {}
193};
194
195}  // namespace content
196
197#endif  // CONTENT_BROWSER_PPAPI_PLUGIN_PROCESS_HOST_H_
198
199