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_PROXY_DISPATCHER_H_ 6#define PPAPI_PROXY_DISPATCHER_H_ 7 8#include <set> 9#include <string> 10#include <vector> 11 12#include "base/callback_forward.h" 13#include "base/compiler_specific.h" 14#include "base/memory/ref_counted.h" 15#include "base/tracked_objects.h" 16#include "ipc/message_filter.h" 17#include "ppapi/c/pp_instance.h" 18#include "ppapi/c/pp_module.h" 19#include "ppapi/c/ppp.h" 20#include "ppapi/proxy/proxy_channel.h" 21#include "ppapi/proxy/interface_list.h" 22#include "ppapi/proxy/interface_proxy.h" 23#include "ppapi/proxy/plugin_var_tracker.h" 24#include "ppapi/shared_impl/api_id.h" 25 26namespace IPC { 27class MessageFilter; 28} 29 30namespace ppapi { 31namespace proxy { 32 33class VarSerializationRules; 34 35// An interface proxy can represent either end of a cross-process interface 36// call. The "source" side is where the call is invoked, and the "target" side 37// is where the call ends up being executed. 38// 39// Plugin side | Browser side 40// -------------------------------------|-------------------------------------- 41// | 42// "Source" | "Target" 43// InterfaceProxy ----------------------> InterfaceProxy 44// | 45// | 46// "Target" | "Source" 47// InterfaceProxy <---------------------- InterfaceProxy 48// | 49class PPAPI_PROXY_EXPORT Dispatcher : public ProxyChannel { 50 public: 51 virtual ~Dispatcher(); 52 53 // Returns true if the dispatcher is on the plugin side, or false if it's the 54 // browser side. 55 virtual bool IsPlugin() const = 0; 56 57 VarSerializationRules* serialization_rules() const { 58 return serialization_rules_.get(); 59 } 60 61 // Returns a non-owning pointer to the interface proxy for the given ID, or 62 // NULL if the ID isn't found. This will create the proxy if it hasn't been 63 // created so far. 64 InterfaceProxy* GetInterfaceProxy(ApiID id); 65 66 // Adds the given filter to the IO thread. 67 void AddIOThreadMessageFilter(scoped_refptr<IPC::MessageFilter> filter); 68 69 // IPC::Listener implementation. 70 virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE; 71 72 PP_GetInterface_Func local_get_interface() const { 73 return local_get_interface_; 74 } 75 76 const PpapiPermissions& permissions() const { return permissions_; } 77 78 protected: 79 explicit Dispatcher(PP_GetInterface_Func local_get_interface, 80 const PpapiPermissions& permissions); 81 82 // Setter for the derived classes to set the appropriate var serialization. 83 // Takes one reference of the given pointer, which must be on the heap. 84 void SetSerializationRules(VarSerializationRules* var_serialization_rules); 85 86 // Called when an invalid message is received from the remote site. The 87 // default implementation does nothing, derived classes can override. 88 virtual void OnInvalidMessageReceived(); 89 90 private: 91 friend class PluginDispatcherTest; 92 93 // Lists all lazily-created interface proxies. 94 scoped_ptr<InterfaceProxy> proxies_[API_ID_COUNT]; 95 96 PP_GetInterface_Func local_get_interface_; 97 98 scoped_refptr<VarSerializationRules> serialization_rules_; 99 100 PpapiPermissions permissions_; 101 102 DISALLOW_COPY_AND_ASSIGN(Dispatcher); 103}; 104 105} // namespace proxy 106} // namespace ppapi 107 108#endif // PPAPI_PROXY_DISPATCHER_H_ 109