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 PPAPI_HOST_PPAPI_HOST_H_ 6 #define PPAPI_HOST_PPAPI_HOST_H_ 7 8 #include <map> 9 10 #include "base/compiler_specific.h" 11 #include "base/memory/linked_ptr.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/memory/scoped_vector.h" 14 #include "base/observer_list.h" 15 #include "ipc/ipc_listener.h" 16 #include "ipc/ipc_sender.h" 17 #include "ppapi/c/pp_instance.h" 18 #include "ppapi/c/pp_resource.h" 19 #include "ppapi/host/ppapi_host_export.h" 20 #include "ppapi/shared_impl/ppapi_permissions.h" 21 22 namespace ppapi { 23 24 namespace proxy { 25 class ResourceMessageCallParams; 26 class ResourceMessageReplyParams; 27 } 28 29 namespace host { 30 31 class HostFactory; 32 struct HostMessageContext; 33 class InstanceMessageFilter; 34 struct ReplyMessageContext; 35 class ResourceHost; 36 37 // The host provides routing and tracking for resource message calls that 38 // come from the plugin to the host (browser or renderer), and the 39 // corresponding replies. 40 class PPAPI_HOST_EXPORT PpapiHost : public IPC::Sender, public IPC::Listener { 41 public: 42 // The sender is the channel to the plugin for outgoing messages. 43 // Normally the creator will add filters for resource creation messages 44 // (AddHostFactoryFilter) and instance messages (AddInstanceMessageFilter) 45 // after construction. 46 PpapiHost(IPC::Sender* sender, const PpapiPermissions& perms); 47 virtual ~PpapiHost(); 48 permissions()49 const PpapiPermissions& permissions() const { return permissions_; } 50 51 // Sender implementation. Forwards to the sender_. 52 virtual bool Send(IPC::Message* msg) OVERRIDE; 53 54 // Listener implementation. 55 virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE; 56 57 // Sends the given reply message to the plugin. 58 void SendReply(const ReplyMessageContext& context, 59 const IPC::Message& msg); 60 61 // Sends the given unsolicited reply message to the plugin. 62 void SendUnsolicitedReply(PP_Resource resource, const IPC::Message& msg); 63 64 // Create a ResourceHost with the given |nested_msg|. 65 scoped_ptr<ResourceHost> CreateResourceHost( 66 const proxy::ResourceMessageCallParams& params, 67 PP_Instance instance, 68 const IPC::Message& nested_msg); 69 70 // Adds the given host resource as a pending one (with no corresponding 71 // PluginResource object and no PP_Resource ID yet). The pending resource ID 72 // is returned. See PpapiHostMsg_AttachToPendingHost. 73 int AddPendingResourceHost(scoped_ptr<ResourceHost> resource_host); 74 75 // Adds the given host factory filter to the host. The PpapiHost will take 76 // ownership of the pointer. 77 void AddHostFactoryFilter(scoped_ptr<HostFactory> filter); 78 79 // Adds the given message filter to the host. The PpapiHost will take 80 // ownership of the pointer. 81 void AddInstanceMessageFilter(scoped_ptr<InstanceMessageFilter> filter); 82 83 // Returns null if the resource doesn't exist. 84 host::ResourceHost* GetResourceHost(PP_Resource resource) const; 85 86 private: 87 friend class InstanceMessageFilter; 88 89 void HandleResourceCall( 90 const proxy::ResourceMessageCallParams& params, 91 const IPC::Message& nested_msg, 92 HostMessageContext* context); 93 94 // Message handlers. 95 void OnHostMsgResourceCall(const proxy::ResourceMessageCallParams& params, 96 const IPC::Message& nested_msg); 97 void OnHostMsgInProcessResourceCall( 98 int routing_id, 99 const proxy::ResourceMessageCallParams& params, 100 const IPC::Message& nested_msg); 101 void OnHostMsgResourceSyncCall( 102 const proxy::ResourceMessageCallParams& params, 103 const IPC::Message& nested_msg, 104 IPC::Message* reply_msg); 105 void OnHostMsgResourceCreated(const proxy::ResourceMessageCallParams& param, 106 PP_Instance instance, 107 const IPC::Message& nested_msg); 108 void OnHostMsgAttachToPendingHost(PP_Resource resource, int pending_host_id); 109 void OnHostMsgResourceDestroyed(PP_Resource resource); 110 111 // Non-owning pointer. 112 IPC::Sender* sender_; 113 114 PpapiPermissions permissions_; 115 116 // Filters for resource creation messages. Note that since we don't support 117 // deleting these dynamically we don't need to worry about modifications 118 // during iteration. If we add that capability, this should be replaced with 119 // an ObserverList. 120 ScopedVector<HostFactory> host_factory_filters_; 121 122 // Filters for instance messages. Note that since we don't support deleting 123 // these dynamically we don't need to worry about modifications during 124 // iteration. If we add that capability, this should be replaced with an 125 // ObserverList. 126 ScopedVector<InstanceMessageFilter> instance_message_filters_; 127 128 typedef std::map<PP_Resource, linked_ptr<ResourceHost> > ResourceMap; 129 ResourceMap resources_; 130 131 // Resources that have been created in the host and have not yet had the 132 // corresponding PluginResource associated with them. 133 // See PpapiHostMsg_AttachToPendingHost. 134 typedef std::map<int, linked_ptr<ResourceHost> > PendingHostResourceMap; 135 PendingHostResourceMap pending_resource_hosts_; 136 int next_pending_resource_host_id_; 137 138 DISALLOW_COPY_AND_ASSIGN(PpapiHost); 139 }; 140 141 } // namespace host 142 } // namespace ppapi 143 144 #endif // PPAPI_HOST_PPAPIE_HOST_H_ 145