content/renderer/pepper/pepper_broker.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 CONTENT_RENDERER_PEPPER_PEPPER_BROKER_H_
   6 #define CONTENT_RENDERER_PEPPER_PEPPER_BROKER_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/process/process.h"
  10 #include "base/sync_socket.h"
  11 #include "content/common/content_export.h"
  12 #include "content/renderer/pepper/ppb_broker_impl.h"
  13 #include "ppapi/proxy/proxy_channel.h"
  14
  15 namespace IPC {
  16 struct ChannelHandle;
  17 }
  18
  19 namespace ppapi {
  20 namespace proxy {
  21 class BrokerDispatcher;
  22 }
  23 }
  24
  25 namespace content {
  26
  27 class PluginModule;
  28
  29 // This object is NOT thread-safe.
  30 class CONTENT_EXPORT PepperBrokerDispatcherWrapper {
  31  public:
  32   PepperBrokerDispatcherWrapper();
  33   ~PepperBrokerDispatcherWrapper();
  34
  35   bool Init(base::ProcessId broker_pid,
  36             const IPC::ChannelHandle& channel_handle);
  37
  38   int32_t SendHandleToBroker(PP_Instance instance,
  39                              base::SyncSocket::Handle handle);
  40
  41  private:
  42   scoped_ptr<ppapi::proxy::BrokerDispatcher> dispatcher_;
  43   scoped_ptr<ppapi::proxy::ProxyChannel::Delegate> dispatcher_delegate_;
  44 };
  45
  46 class PepperBroker : public base::RefCountedThreadSafe<PepperBroker>{
  47  public:
  48   explicit PepperBroker(PluginModule* plugin_module);
  49
  50   // Decrements the references to the broker.
  51   // When there are no more references, this renderer's dispatcher is
  52   // destroyed, allowing the broker to shutdown if appropriate.
  53   // Callers should not reference this object after calling Disconnect().
  54   void Disconnect(PPB_Broker_Impl* client);
  55
  56   // Adds a pending connection to the broker. Balances out Disconnect() calls.
  57   void AddPendingConnect(PPB_Broker_Impl* client);
  58
  59   // Called when the channel to the broker has been established.
  60   void OnBrokerChannelConnected(base::ProcessId broker_pid,
  61                                 const IPC::ChannelHandle& channel_handle);
  62
  63   // Called when we know whether permission to access the PPAPI broker was
  64   // granted.
  65   void OnBrokerPermissionResult(PPB_Broker_Impl* client,
  66                                 bool result);
  67
  68  private:
  69   friend class base::RefCountedThreadSafe<PepperBroker>;
  70
  71   struct PendingConnection {
  72     PendingConnection();
  73     ~PendingConnection();
  74
  75     bool is_authorized;
  76     base::WeakPtr<PPB_Broker_Impl> client;
  77   };
  78
  79   virtual ~PepperBroker();
  80
  81   // Reports failure to all clients that had pending operations.
  82   void ReportFailureToClients(int error_code);
  83
  84   // Connects the plugin to the broker via a pipe.
  85   void ConnectPluginToBroker(PPB_Broker_Impl* client);
  86
  87   scoped_ptr<PepperBrokerDispatcherWrapper> dispatcher_;
  88
  89   // A map of pointers to objects that have requested a connection to the weak
  90   // pointer we can use to reference them. The mapping is needed so we can clean
  91   // up entries for objects that may have been deleted.
  92   typedef std::map<PPB_Broker_Impl*, PendingConnection> ClientMap;
  93   ClientMap pending_connects_;
  94
  95   // Pointer to the associated plugin module.
  96   // Always set and cleared at the same time as the module's pointer to this.
  97   PluginModule* plugin_module_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(PepperBroker);
 100 };
 101
 102 }  // namespace content
 103
 104 #endif  // CONTENT_RENDERER_PEPPER_PEPPER_BROKER_H_