| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/callback.h" |
| #include "base/basictypes.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/memory/weak_ptr.h" |
| #include "ppapi/c/pp_instance.h" |
| #include "ppapi/proxy/connection.h" |
| #include "ppapi/proxy/resource_message_params.h" |
| |
| namespace IPC { |
| class Message; |
| class MessageReplyDeserializer; |
| } // namespace |
| |
| namespace content { |
| |
| class RendererPpapiHostImpl; |
| |
| // This class fakes an IPC channel so that we can take the new resources with |
| // IPC backends and run them in-process. |
| // |
| // (See pepper_in_process_resource_creation.h for more background.) |
| // |
| // This class just provides the fake routing for in-process plugins. |
| // Asynchronous messages are converted into an asynchronous execution of the |
| // message receiver on the opposite end. Synchronous messages just call right |
| // through. |
| // |
| // The resources in ppapi/proxy assume that there is an IPC connection to |
| // both the renderer and the browser processes. They take a connection object |
| // that includes both of these channels. However, in-process plugins don't |
| // have a BrowserPpapiHost on the browser side to receive these messages. |
| // |
| // As a result, we can't support resources that rely on sending messages to the |
| // browser process. Since this class is a stopgap until all interfaces are |
| // converted and all plugins are run out-of-procss, we just choose not to |
| // support faking IPC channels for resources that send messages directly to the |
| // browser process. These resources will just have to use the "old" in-process |
| // implementation until the conversion is complete and all this code can be |
| // deleted. |
| // |
| // To keep things consistent, we provide an IPC::Sender for the browser channel |
| // in the connection object supplied to resources. This dummy browser channel |
| // will just assert and delete the message if anything is ever sent over it. |
| // |
| // There are two restrictions for in-process resource calls: |
| // Sync messages can only be sent from the plugin to the host. |
| // The host must handle sync messages synchronously. |
| class PepperInProcessRouter { |
| public: |
| // The given host parameter owns this class and must outlive us. |
| PepperInProcessRouter(RendererPpapiHostImpl* host_impl); |
| ~PepperInProcessRouter(); |
| |
| // Returns the dummy sender for the cooresponding end of the in-process |
| // emulated channel. |
| IPC::Sender* GetPluginToRendererSender(); |
| IPC::Sender* GetRendererToPluginSender(); |
| |
| // Returns a connection pair for use by a resource proxy. This includes |
| // the plugin->renderer sender as well as a dummy sender to the browser |
| // process. See the class comment above about the dummy sender. |
| ppapi::proxy::Connection GetPluginConnection(PP_Instance instance); |
| |
| // Handles resource reply messages from the host. |
| static bool OnPluginMsgReceived(const IPC::Message& msg); |
| |
| private: |
| bool SendToHost(IPC::Message* msg); |
| bool SendToPlugin(IPC::Message* msg); |
| void DispatchHostMsg(IPC::Message* msg); |
| void DispatchPluginMsg(IPC::Message* msg); |
| bool SendToBrowser(IPC::Message* msg); |
| |
| RendererPpapiHostImpl* host_impl_; |
| |
| class Channel; |
| scoped_ptr<Channel> browser_channel_; |
| |
| // Renderer -> plugin channel. |
| scoped_ptr<Channel> host_to_plugin_router_; |
| |
| // Plugin -> renderer channel. |
| scoped_ptr<Channel> plugin_to_host_router_; |
| |
| // Pending sync message id. |
| int pending_message_id_; |
| |
| // Reply deserializer of the pending sync message. |
| scoped_ptr<IPC::MessageReplyDeserializer> reply_deserializer_; |
| |
| // Reply result of the pending sync message. |
| bool reply_result_; |
| |
| base::WeakPtrFactory<PepperInProcessRouter> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(PepperInProcessRouter); |
| }; |
| |
| } // namespace content |