ppapi/host/ppapi_host.h

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