// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef PPAPI_PROXY_PLUGIN_GLOBALS_H_
#define PPAPI_PROXY_PLUGIN_GLOBALS_H_
#include <memory>
#include <string>
#include "base/compiler_specific.h"
#include "base/memory/scoped_refptr.h"
#include "base/threading/thread_local_storage.h"
#include "ppapi/proxy/connection.h"
#include "ppapi/proxy/plugin_resource_tracker.h"
#include "ppapi/proxy/plugin_var_tracker.h"
#include "ppapi/proxy/ppapi_proxy_export.h"
#include "ppapi/shared_impl/callback_tracker.h"
#include "ppapi/shared_impl/ppapi_globals.h"
namespace base {
class SingleThreadTaskRunner;
class TaskRunner;
class Thread;
}
namespace IPC {
class Sender;
}
struct PP_BrowserFont_Trusted_Description;
namespace ppapi {
struct Preferences;
namespace proxy {
class MessageLoopResource;
class PluginMessageFilter;
class PluginProxyDelegate;
class ResourceReplyThreadRegistrar;
class UDPSocketFilter;
class PPAPI_PROXY_EXPORT PluginGlobals : public PpapiGlobals {
public:
explicit PluginGlobals(
const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner);
PluginGlobals(
PpapiGlobals::PerThreadForTest,
const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner);
PluginGlobals(const PluginGlobals&) = delete;
PluginGlobals& operator=(const PluginGlobals&) = delete;
~PluginGlobals() override;
// Getter for the global singleton. Generally, you should use
// PpapiGlobals::Get() when possible. Use this only when you need some
// plugin-specific functionality.
inline static PluginGlobals* Get() {
// Explicitly crash if this is the wrong process type, we want to get
// crash reports.
CHECK(PpapiGlobals::Get()->IsPluginGlobals());
return static_cast<PluginGlobals*>(PpapiGlobals::Get());
}
// PpapiGlobals implementation.
ResourceTracker* GetResourceTracker() override;
VarTracker* GetVarTracker() override;
CallbackTracker* GetCallbackTrackerForInstance(PP_Instance instance) override;
thunk::PPB_Instance_API* GetInstanceAPI(PP_Instance instance) override;
thunk::ResourceCreationAPI* GetResourceCreationAPI(
PP_Instance instance) override;
PP_Module GetModuleForInstance(PP_Instance instance) override;
void LogWithSource(PP_Instance instance,
PP_LogLevel level,
const std::string& source,
const std::string& value) override;
void BroadcastLogWithSource(PP_Module module,
PP_LogLevel level,
const std::string& source,
const std::string& value) override;
MessageLoopShared* GetCurrentMessageLoop() override;
base::TaskRunner* GetFileTaskRunner() override;
// Returns the channel for sending to the browser.
IPC::Sender* GetBrowserSender();
base::SingleThreadTaskRunner* ipc_task_runner() {
return ipc_task_runner_.get();
}
// Returns the language code of the current UI language.
std::string GetUILanguage();
// Sets the active url which is reported by breakpad.
void SetActiveURL(const std::string& url);
PP_Resource CreateBrowserFont(
Connection connection,
PP_Instance instance,
const PP_BrowserFont_Trusted_Description& desc,
const Preferences& prefs);
// Getters for the plugin-specific versions.
PluginResourceTracker* plugin_resource_tracker() {
return &plugin_resource_tracker_;
}
PluginVarTracker* plugin_var_tracker() {
return &plugin_var_tracker_;
}
// The embedder should call SetPluginProxyDelegate during startup.
void SetPluginProxyDelegate(PluginProxyDelegate* d);
// The embedder may choose to call ResetPluginProxyDelegate during shutdown.
// After that point, it's unsafe to call most members of PluginGlobals,
// and GetBrowserSender will return NULL.
void ResetPluginProxyDelegate();
// Returns the TLS slot that holds the message loop TLS.
//
// If we end up needing more TLS storage for more stuff, we should probably
// have a struct in here for the different items.
base::ThreadLocalStorage::Slot* msg_loop_slot() {
return msg_loop_slot_.get();
}
// Sets the message loop slot, takes ownership of the given heap-alloated
// pointer.
void set_msg_loop_slot(base::ThreadLocalStorage::Slot* slot) {
msg_loop_slot_.reset(slot);
}
// Return the special Resource that represents the MessageLoop for the main
// thread. This Resource is not associated with any instance, and lives as
// long as the plugin.
MessageLoopResource* loop_for_main_thread();
// The embedder should call this function when the name of the plugin module
// is known. This will be used for error logging.
void set_plugin_name(const std::string& name) { plugin_name_ = name; }
ResourceReplyThreadRegistrar* resource_reply_thread_registrar() {
return resource_reply_thread_registrar_.get();
}
UDPSocketFilter* udp_socket_filter() const {
return udp_socket_filter_.get();
}
// Add any necessary ResourceMessageFilters to the PluginMessageFilter so
// that they can receive and handle appropriate messages on the IO thread.
void RegisterResourceMessageFilters(
ppapi::proxy::PluginMessageFilter* plugin_filter);
private:
class BrowserSender;
// PpapiGlobals overrides.
bool IsPluginGlobals() const override;
static PluginGlobals* plugin_globals_;
PluginProxyDelegate* plugin_proxy_delegate_;
PluginResourceTracker plugin_resource_tracker_;
PluginVarTracker plugin_var_tracker_;
scoped_refptr<CallbackTracker> callback_tracker_;
std::unique_ptr<base::ThreadLocalStorage::Slot> msg_loop_slot_;
// Note that loop_for_main_thread's constructor sets msg_loop_slot_, so it
// must be initialized after msg_loop_slot_ (hence the order here).
scoped_refptr<MessageLoopResource> loop_for_main_thread_;
// Name of the plugin used for error logging. This will be empty until
// set_plugin_name is called.
std::string plugin_name_;
std::unique_ptr<BrowserSender> browser_sender_;
scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
// Thread for performing potentially blocking file operations. It's created
// lazily, since it might not be needed.
std::unique_ptr<base::Thread> file_thread_;
scoped_refptr<ResourceReplyThreadRegistrar> resource_reply_thread_registrar_;
scoped_refptr<UDPSocketFilter> udp_socket_filter_;
// Member variables should appear before the WeakPtrFactory, see weak_ptr.h.
base::WeakPtrFactory<PluginGlobals> weak_factory_{this};
};
} // namespace proxy
} // namespace ppapi
#endif // PPAPI_PROXY_PLUGIN_GLOBALS_H_
Codebase Browser
chromium