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 #include "base/callback.h" 6 #include "base/basictypes.h" 7 #include "base/memory/scoped_ptr.h" 8 #include "base/memory/weak_ptr.h" 9 #include "ppapi/c/pp_instance.h" 10 #include "ppapi/proxy/connection.h" 11 #include "ppapi/proxy/resource_message_params.h" 12 13 namespace IPC { 14 class Message; 15 class MessageReplyDeserializer; 16 } // namespace 17 18 namespace content { 19 20 class RendererPpapiHostImpl; 21 22 // This class fakes an IPC channel so that we can take the new resources with 23 // IPC backends and run them in-process. 24 // 25 // (See pepper_in_process_resource_creation.h for more background.) 26 // 27 // This class just provides the fake routing for in-process plugins. 28 // Asynchronous messages are converted into an asynchronous execution of the 29 // message receiver on the opposite end. Synchronous messages just call right 30 // through. 31 // 32 // The resources in ppapi/proxy assume that there is an IPC connection to 33 // both the renderer and the browser processes. They take a connection object 34 // that includes both of these channels. However, in-process plugins don't 35 // have a BrowserPpapiHost on the browser side to receive these messages. 36 // 37 // As a result, we can't support resources that rely on sending messages to the 38 // browser process. Since this class is a stopgap until all interfaces are 39 // converted and all plugins are run out-of-procss, we just choose not to 40 // support faking IPC channels for resources that send messages directly to the 41 // browser process. These resources will just have to use the "old" in-process 42 // implementation until the conversion is complete and all this code can be 43 // deleted. 44 // 45 // To keep things consistent, we provide an IPC::Sender for the browser channel 46 // in the connection object supplied to resources. This dummy browser channel 47 // will just assert and delete the message if anything is ever sent over it. 48 // 49 // There are two restrictions for in-process resource calls: 50 // Sync messages can only be sent from the plugin to the host. 51 // The host must handle sync messages synchronously. 52 class PepperInProcessRouter { 53 public: 54 // The given host parameter owns this class and must outlive us. 55 PepperInProcessRouter(RendererPpapiHostImpl* host_impl); 56 ~PepperInProcessRouter(); 57 58 // Returns the dummy sender for the cooresponding end of the in-process 59 // emulated channel. 60 IPC::Sender* GetPluginToRendererSender(); 61 IPC::Sender* GetRendererToPluginSender(); 62 63 // Returns a connection pair for use by a resource proxy. This includes 64 // the plugin->renderer sender as well as a dummy sender to the browser 65 // process. See the class comment above about the dummy sender. 66 ppapi::proxy::Connection GetPluginConnection(PP_Instance instance); 67 68 // Handles resource reply messages from the host. 69 static bool OnPluginMsgReceived(const IPC::Message& msg); 70 71 private: 72 bool SendToHost(IPC::Message *msg); 73 bool SendToPlugin(IPC::Message *msg); 74 void DispatchHostMsg(IPC::Message* msg); 75 void DispatchPluginMsg(IPC::Message* msg); 76 bool SendToBrowser(IPC::Message *msg); 77 78 RendererPpapiHostImpl* host_impl_; 79 80 class Channel; 81 scoped_ptr<Channel> browser_channel_; 82 83 // Renderer -> plugin channel. 84 scoped_ptr<Channel> host_to_plugin_router_; 85 86 // Plugin -> renderer channel. 87 scoped_ptr<Channel> plugin_to_host_router_; 88 89 // Pending sync message id. 90 int pending_message_id_; 91 92 // Reply deserializer of the pending sync message. 93 scoped_ptr<IPC::MessageReplyDeserializer> reply_deserializer_; 94 95 // Reply result of the pending sync message. 96 bool reply_result_; 97 98 base::WeakPtrFactory<PepperInProcessRouter> weak_factory_; 99 100 DISALLOW_COPY_AND_ASSIGN(PepperInProcessRouter); 101 }; 102 103 } // namespace content 104