1// Copyright 2013 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#include "content/browser/renderer_host/pepper/pepper_renderer_connection.h"
6
7#include "base/bind.h"
8#include "base/memory/ref_counted.h"
9#include "content/browser/browser_child_process_host_impl.h"
10#include "content/browser/ppapi_plugin_process_host.h"
11#include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
12#include "content/common/pepper_renderer_instance_data.h"
13#include "content/common/view_messages.h"
14#include "content/browser/renderer_host/pepper/pepper_file_ref_host.h"
15#include "content/browser/renderer_host/pepper/pepper_file_system_browser_host.h"
16#include "content/public/browser/content_browser_client.h"
17#include "content/public/common/content_client.h"
18#include "ipc/ipc_message_macros.h"
19#include "ppapi/host/resource_host.h"
20#include "ppapi/proxy/ppapi_message_utils.h"
21#include "ppapi/proxy/ppapi_messages.h"
22#include "ppapi/proxy/resource_message_params.h"
23
24namespace content {
25
26namespace {
27
28const uint32 kFilteredMessageClasses[] = {PpapiMsgStart, ViewMsgStart, };
29
30// Responsible for creating the pending resource hosts, holding their IDs until
31// all of them have been created for a single message, and sending the reply to
32// say that the hosts have been created.
33class PendingHostCreator : public base::RefCounted<PendingHostCreator> {
34 public:
35  PendingHostCreator(BrowserPpapiHostImpl* host,
36                     BrowserMessageFilter* connection,
37                     int routing_id,
38                     int sequence_id,
39                     size_t nested_msgs_size);
40
41  // Adds the given resource host as a pending one. The host is remembered as
42  // host number |index|, and will ultimately be sent to the plugin to be
43  // attached to a real resource.
44  void AddPendingResourceHost(
45      size_t index,
46      scoped_ptr<ppapi::host::ResourceHost> resource_host);
47
48 private:
49  friend class base::RefCounted<PendingHostCreator>;
50
51  // When the last reference to this class is released, all of the resource
52  // hosts would have been added. This destructor sends the message to the
53  // plugin to tell it to attach real hosts to all of the pending hosts that
54  // have been added by this object.
55  ~PendingHostCreator();
56
57  BrowserPpapiHostImpl* host_;
58  BrowserMessageFilter* connection_;
59  int routing_id_;
60  int sequence_id_;
61  std::vector<int> pending_resource_host_ids_;
62};
63
64PendingHostCreator::PendingHostCreator(BrowserPpapiHostImpl* host,
65                                       BrowserMessageFilter* connection,
66                                       int routing_id,
67                                       int sequence_id,
68                                       size_t nested_msgs_size)
69    : host_(host),
70      connection_(connection),
71      routing_id_(routing_id),
72      sequence_id_(sequence_id),
73      pending_resource_host_ids_(nested_msgs_size, 0) {}
74
75void PendingHostCreator::AddPendingResourceHost(
76    size_t index,
77    scoped_ptr<ppapi::host::ResourceHost> resource_host) {
78  pending_resource_host_ids_[index] =
79      host_->GetPpapiHost()->AddPendingResourceHost(resource_host.Pass());
80}
81
82PendingHostCreator::~PendingHostCreator() {
83  connection_->Send(new PpapiHostMsg_CreateResourceHostsFromHostReply(
84      routing_id_, sequence_id_, pending_resource_host_ids_));
85}
86
87}  // namespace
88
89PepperRendererConnection::PepperRendererConnection(int render_process_id)
90    : BrowserMessageFilter(kFilteredMessageClasses,
91                           arraysize(kFilteredMessageClasses)),
92      render_process_id_(render_process_id) {
93  // Only give the renderer permission for stable APIs.
94  in_process_host_.reset(new BrowserPpapiHostImpl(this,
95                                                  ppapi::PpapiPermissions(),
96                                                  "",
97                                                  base::FilePath(),
98                                                  base::FilePath(),
99                                                  true /* in_process */,
100                                                  false /* external_plugin */));
101}
102
103PepperRendererConnection::~PepperRendererConnection() {}
104
105BrowserPpapiHostImpl* PepperRendererConnection::GetHostForChildProcess(
106    int child_process_id) const {
107  DCHECK_CURRENTLY_ON(BrowserThread::IO);
108
109  // Find the plugin which this message refers to. Check NaCl plugins first.
110  BrowserPpapiHostImpl* host = static_cast<BrowserPpapiHostImpl*>(
111      GetContentClient()->browser()->GetExternalBrowserPpapiHost(
112          child_process_id));
113
114  if (!host) {
115    // Check trusted pepper plugins.
116    for (PpapiPluginProcessHostIterator iter; !iter.Done(); ++iter) {
117      if (iter->process() &&
118          iter->process()->GetData().id == child_process_id) {
119        // Found the plugin.
120        host = iter->host_impl();
121        break;
122      }
123    }
124  }
125
126  // If the message is being sent from an in-process plugin, we own the
127  // BrowserPpapiHost.
128  if (!host && child_process_id == 0) {
129    host = in_process_host_.get();
130  }
131
132  return host;
133}
134
135bool PepperRendererConnection::OnMessageReceived(const IPC::Message& msg) {
136  if (in_process_host_->GetPpapiHost()->OnMessageReceived(msg))
137    return true;
138
139  bool handled = true;
140  IPC_BEGIN_MESSAGE_MAP(PepperRendererConnection, msg)
141    IPC_MESSAGE_HANDLER(PpapiHostMsg_CreateResourceHostsFromHost,
142                        OnMsgCreateResourceHostsFromHost)
143    IPC_MESSAGE_HANDLER(ViewHostMsg_DidCreateInProcessInstance,
144                        OnMsgDidCreateInProcessInstance)
145    IPC_MESSAGE_HANDLER(ViewHostMsg_DidDeleteInProcessInstance,
146                        OnMsgDidDeleteInProcessInstance)
147    IPC_MESSAGE_UNHANDLED(handled = false)
148  IPC_END_MESSAGE_MAP()
149
150  return handled;
151}
152
153void PepperRendererConnection::OnMsgCreateResourceHostsFromHost(
154    int routing_id,
155    int child_process_id,
156    const ppapi::proxy::ResourceMessageCallParams& params,
157    PP_Instance instance,
158    const std::vector<IPC::Message>& nested_msgs) {
159  BrowserPpapiHostImpl* host = GetHostForChildProcess(child_process_id);
160  if (!host) {
161    DLOG(ERROR) << "Invalid plugin process ID.";
162    return;
163  }
164
165  scoped_refptr<PendingHostCreator> creator = new PendingHostCreator(
166      host, this, routing_id, params.sequence(), nested_msgs.size());
167  for (size_t i = 0; i < nested_msgs.size(); ++i) {
168    const IPC::Message& nested_msg = nested_msgs[i];
169    scoped_ptr<ppapi::host::ResourceHost> resource_host;
170    if (host->IsValidInstance(instance)) {
171      if (nested_msg.type() == PpapiHostMsg_FileRef_CreateForRawFS::ID) {
172        // FileRef_CreateForRawFS is only permitted from the renderer. Because
173        // of this, we handle this message here and not in
174        // content_browser_pepper_host_factory.cc.
175        base::FilePath external_path;
176        if (ppapi::UnpackMessage<PpapiHostMsg_FileRef_CreateForRawFS>(
177                nested_msg, &external_path)) {
178          resource_host.reset(new PepperFileRefHost(
179              host, instance, params.pp_resource(), external_path));
180        }
181      } else if (nested_msg.type() ==
182                 PpapiHostMsg_FileSystem_CreateFromRenderer::ID) {
183        // Similarly, FileSystem_CreateFromRenderer is only permitted from the
184        // renderer.
185        std::string root_url;
186        PP_FileSystemType file_system_type;
187        if (ppapi::UnpackMessage<PpapiHostMsg_FileSystem_CreateFromRenderer>(
188                nested_msg, &root_url, &file_system_type)) {
189          PepperFileSystemBrowserHost* browser_host =
190              new PepperFileSystemBrowserHost(
191                  host, instance, params.pp_resource(), file_system_type);
192          resource_host.reset(browser_host);
193          // Open the file system resource host. This is an asynchronous
194          // operation, and we must only add the pending resource host and
195          // send the message once it completes.
196          browser_host->OpenExisting(
197              GURL(root_url),
198              base::Bind(&PendingHostCreator::AddPendingResourceHost,
199                         creator,
200                         i,
201                         base::Passed(&resource_host)));
202          // Do not fall through; the fall-through case adds the pending
203          // resource host to the list. We must do this asynchronously.
204          continue;
205        }
206      }
207    }
208
209    if (!resource_host.get()) {
210      resource_host = host->GetPpapiHost()->CreateResourceHost(
211          params, instance, nested_msg);
212    }
213
214    if (resource_host.get())
215      creator->AddPendingResourceHost(i, resource_host.Pass());
216  }
217
218  // Note: All of the pending host IDs that were added as part of this
219  // operation will automatically be sent to the plugin when |creator| is
220  // released. This may happen immediately, or (if there are asynchronous
221  // requests to create resource hosts), once all of them complete.
222}
223
224void PepperRendererConnection::OnMsgDidCreateInProcessInstance(
225    PP_Instance instance,
226    const PepperRendererInstanceData& instance_data) {
227  PepperRendererInstanceData data = instance_data;
228  data.render_process_id = render_process_id_;
229  in_process_host_->AddInstance(instance, data);
230}
231
232void PepperRendererConnection::OnMsgDidDeleteInProcessInstance(
233    PP_Instance instance) {
234  in_process_host_->DeleteInstance(instance);
235}
236
237}  // namespace content
238