ppapi/proxy/plugin_globals.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_PROXY_PLUGIN_GLOBALS_H_
   6 #define PPAPI_PROXY_PLUGIN_GLOBALS_H_
   7
   8 #include <string>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/threading/thread_local_storage.h"
  13 #include "ppapi/proxy/connection.h"
  14 #include "ppapi/proxy/plugin_resource_tracker.h"
  15 #include "ppapi/proxy/plugin_var_tracker.h"
  16 #include "ppapi/proxy/ppapi_proxy_export.h"
  17 #include "ppapi/shared_impl/callback_tracker.h"
  18 #include "ppapi/shared_impl/ppapi_globals.h"
  19
  20 namespace base {
  21 class Thread;
  22 }
  23 namespace IPC {
  24 class Sender;
  25 }
  26
  27 struct PP_BrowserFont_Trusted_Description;
  28
  29 namespace ppapi {
  30
  31 struct Preferences;
  32
  33 namespace proxy {
  34
  35 class MessageLoopResource;
  36 class PluginProxyDelegate;
  37 class ResourceReplyThreadRegistrar;
  38
  39 class PPAPI_PROXY_EXPORT PluginGlobals : public PpapiGlobals {
  40  public:
  41   PluginGlobals();
  42   explicit PluginGlobals(PpapiGlobals::PerThreadForTest);
  43   virtual ~PluginGlobals();
  44
  45   // Getter for the global singleton. Generally, you should use
  46   // PpapiGlobals::Get() when possible. Use this only when you need some
  47   // plugin-specific functionality.
  48   inline static PluginGlobals* Get() {
  49     // Explicitly crash if this is the wrong process type, we want to get
  50     // crash reports.
  51     CHECK(PpapiGlobals::Get()->IsPluginGlobals());
  52     return static_cast<PluginGlobals*>(PpapiGlobals::Get());
  53   }
  54
  55   // PpapiGlobals implementation.
  56   virtual ResourceTracker* GetResourceTracker() OVERRIDE;
  57   virtual VarTracker* GetVarTracker() OVERRIDE;
  58   virtual CallbackTracker* GetCallbackTrackerForInstance(
  59       PP_Instance instance) OVERRIDE;
  60   virtual thunk::PPB_Instance_API* GetInstanceAPI(
  61       PP_Instance instance) OVERRIDE;
  62   virtual thunk::ResourceCreationAPI* GetResourceCreationAPI(
  63       PP_Instance instance) OVERRIDE;
  64   virtual PP_Module GetModuleForInstance(PP_Instance instance) OVERRIDE;
  65   virtual std::string GetCmdLine() OVERRIDE;
  66   virtual void PreCacheFontForFlash(const void* logfontw) OVERRIDE;
  67   virtual void LogWithSource(PP_Instance instance,
  68                              PP_LogLevel level,
  69                              const std::string& source,
  70                              const std::string& value) OVERRIDE;
  71   virtual void BroadcastLogWithSource(PP_Module module,
  72                                       PP_LogLevel level,
  73                                       const std::string& source,
  74                                       const std::string& value) OVERRIDE;
  75   virtual MessageLoopShared* GetCurrentMessageLoop() OVERRIDE;
  76   base::TaskRunner* GetFileTaskRunner() OVERRIDE;
  77   virtual void MarkPluginIsActive() OVERRIDE;
  78
  79   // Returns the channel for sending to the browser.
  80   IPC::Sender* GetBrowserSender();
  81
  82   // Returns the language code of the current UI language.
  83   std::string GetUILanguage();
  84
  85   // Sets the active url which is reported by breakpad.
  86   void SetActiveURL(const std::string& url);
  87
  88   PP_Resource CreateBrowserFont(
  89       Connection connection,
  90       PP_Instance instance,
  91       const PP_BrowserFont_Trusted_Description& desc,
  92       const Preferences& prefs);
  93
  94   // Getters for the plugin-specific versions.
  95   PluginResourceTracker* plugin_resource_tracker() {
  96     return &plugin_resource_tracker_;
  97   }
  98   PluginVarTracker* plugin_var_tracker() {
  99     return &plugin_var_tracker_;
 100   }
 101
 102   // The embedder should call set_proxy_delegate during startup.
 103   void set_plugin_proxy_delegate(PluginProxyDelegate* d) {
 104     plugin_proxy_delegate_ = d;
 105   }
 106
 107   // Returns the TLS slot that holds the message loop TLS.
 108   //
 109   // If we end up needing more TLS storage for more stuff, we should probably
 110   // have a struct in here for the different items.
 111   base::ThreadLocalStorage::Slot* msg_loop_slot() {
 112     return msg_loop_slot_.get();
 113   }
 114
 115   // Sets the message loop slot, takes ownership of the given heap-alloated
 116   // pointer.
 117   void set_msg_loop_slot(base::ThreadLocalStorage::Slot* slot) {
 118     msg_loop_slot_.reset(slot);
 119   }
 120
 121   // Return the special Resource that represents the MessageLoop for the main
 122   // thread. This Resource is not associated with any instance, and lives as
 123   // long as the plugin.
 124   MessageLoopResource* loop_for_main_thread();
 125
 126   // The embedder should call this function when the name of the plugin module
 127   // is known. This will be used for error logging.
 128   void set_plugin_name(const std::string& name) { plugin_name_ = name; }
 129
 130   // The embedder should call this function when the command line is known.
 131   void set_command_line(const std::string& c) { command_line_ = c; }
 132
 133   ResourceReplyThreadRegistrar* resource_reply_thread_registrar() {
 134     return resource_reply_thread_registrar_.get();
 135   }
 136
 137   // Interval to limit how many IPC messages are sent indicating that the plugin
 138   // is active and should be kept alive. The value must be smaller than any
 139   // threshold used to kill inactive plugins by the embedder host.
 140   void set_keepalive_throttle_interval_milliseconds(unsigned i);
 141
 142  private:
 143   class BrowserSender;
 144
 145   // PpapiGlobals overrides.
 146   virtual bool IsPluginGlobals() const OVERRIDE;
 147
 148   // Locks the proxy lock and releases the throttle on keepalive IPC messages.
 149   void OnReleaseKeepaliveThrottle();
 150
 151   static PluginGlobals* plugin_globals_;
 152
 153   PluginProxyDelegate* plugin_proxy_delegate_;
 154   PluginResourceTracker plugin_resource_tracker_;
 155   PluginVarTracker plugin_var_tracker_;
 156   scoped_refptr<CallbackTracker> callback_tracker_;
 157
 158   scoped_ptr<base::ThreadLocalStorage::Slot> msg_loop_slot_;
 159   // Note that loop_for_main_thread's constructor sets msg_loop_slot_, so it
 160   // must be initialized after msg_loop_slot_ (hence the order here).
 161   scoped_refptr<MessageLoopResource> loop_for_main_thread_;
 162
 163   // Name of the plugin used for error logging. This will be empty until
 164   // set_plugin_name is called.
 165   std::string plugin_name_;
 166
 167   // Command line for the plugin. This will be empty until set_command_line is
 168   // called.
 169   std::string command_line_;
 170
 171   scoped_ptr<BrowserSender> browser_sender_;
 172
 173   // Thread for performing potentially blocking file operations. It's created
 174   // lazily, since it might not be needed.
 175   scoped_ptr<base::Thread> file_thread_;
 176
 177   scoped_refptr<ResourceReplyThreadRegistrar> resource_reply_thread_registrar_;
 178
 179   // Indicates activity by the plugin. Used to monitor when a plugin can be
 180   // shutdown due to idleness. Current needs do not require differentiating
 181   // between idle state between multiple instances, if any are active they are
 182   // all considered active.
 183   bool plugin_recently_active_;
 184
 185   unsigned keepalive_throttle_interval_milliseconds_;
 186
 187   // Member variables should appear before the WeakPtrFactory, see weak_ptr.h.
 188   base::WeakPtrFactory<PluginGlobals> weak_factory_;
 189
 190   DISALLOW_COPY_AND_ASSIGN(PluginGlobals);
 191 };
 192
 193 }  // namespace proxy
 194 }  // namespace ppapi
 195
 196 #endif   // PPAPI_PROXY_PLUGIN_GLOBALS_H_