// 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_