src/mojo/examples/pepper_container_app/mojo_ppapi_globals.cc

   1 // Copyright 2014 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 #include "mojo/examples/pepper_container_app/mojo_ppapi_globals.h"
   6
   7 #include "base/logging.h"
   8 #include "base/message_loop/message_loop_proxy.h"
   9 #include "base/time/time.h"
  10 #include "mojo/examples/pepper_container_app/plugin_instance.h"
  11 #include "ppapi/c/pp_errors.h"
  12 #include "ppapi/shared_impl/ppb_message_loop_shared.h"
  13
  14 namespace mojo {
  15 namespace examples {
  16
  17 namespace {
  18
  19 const PP_Instance kInstanceId = 1;
  20
  21 }  // namespace
  22
  23 // A non-abstract subclass of ppapi::MessageLoopShared that represents the
  24 // message loop of the main thread.
  25 // TODO(yzshen): Build a more general ppapi::MessageLoopShared subclass to fully
  26 // support PPB_MessageLoop.
  27 class MojoPpapiGlobals::MainThreadMessageLoopResource
  28     : public ppapi::MessageLoopShared {
  29  public:
  30   explicit MainThreadMessageLoopResource(
  31       base::MessageLoopProxy* main_thread_message_loop)
  32       : MessageLoopShared(ForMainThread()),
  33         main_thread_message_loop_(main_thread_message_loop) {}
  34
  35   // ppapi::MessageLoopShared implementation.
  36   virtual void PostClosure(const tracked_objects::Location& from_here,
  37                            const base::Closure& closure,
  38                            int64 delay_ms) OVERRIDE {
  39     main_thread_message_loop_->PostDelayedTask(
  40         from_here, closure, base::TimeDelta::FromMilliseconds(delay_ms));
  41   }
  42
  43   virtual base::MessageLoopProxy* GetMessageLoopProxy() OVERRIDE {
  44     return main_thread_message_loop_.get();
  45   }
  46
  47   virtual bool CurrentlyHandlingBlockingMessage() OVERRIDE {
  48     return false;
  49   }
  50
  51   // ppapi::thunk::PPB_MessageLoop_API implementation.
  52   virtual int32_t AttachToCurrentThread() OVERRIDE {
  53     NOTIMPLEMENTED();
  54     return PP_ERROR_FAILED;
  55   }
  56
  57   virtual int32_t Run() OVERRIDE {
  58     NOTIMPLEMENTED();
  59     return PP_ERROR_FAILED;
  60   }
  61
  62   virtual int32_t PostWork(PP_CompletionCallback callback,
  63                            int64_t delay_ms) OVERRIDE {
  64     NOTIMPLEMENTED();
  65     return PP_ERROR_FAILED;
  66   }
  67
  68   virtual int32_t PostQuit(PP_Bool should_destroy) OVERRIDE {
  69     NOTIMPLEMENTED();
  70     return PP_ERROR_FAILED;
  71   }
  72
  73  private:
  74   virtual ~MainThreadMessageLoopResource() {}
  75
  76   scoped_refptr<base::MessageLoopProxy> main_thread_message_loop_;
  77   DISALLOW_COPY_AND_ASSIGN(MainThreadMessageLoopResource);
  78 };
  79
  80 MojoPpapiGlobals::MojoPpapiGlobals(Delegate* delegate)
  81     : delegate_(delegate),
  82       plugin_instance_(NULL),
  83       resource_tracker_(ppapi::ResourceTracker::THREAD_SAFE) {}
  84
  85 MojoPpapiGlobals::~MojoPpapiGlobals() {}
  86
  87 PP_Instance MojoPpapiGlobals::AddInstance(PluginInstance* instance) {
  88   DCHECK(!plugin_instance_);
  89   plugin_instance_ = instance;
  90   resource_tracker_.DidCreateInstance(kInstanceId);
  91   return kInstanceId;
  92 }
  93
  94 void MojoPpapiGlobals::InstanceDeleted(PP_Instance instance) {
  95   DCHECK_EQ(instance, kInstanceId);
  96   DCHECK(plugin_instance_);
  97   resource_tracker_.DidDeleteInstance(instance);
  98   plugin_instance_ = NULL;
  99 }
 100
 101 PluginInstance* MojoPpapiGlobals::GetInstance(PP_Instance instance) {
 102   if (instance == kInstanceId)
 103     return plugin_instance_;
 104   return NULL;
 105 }
 106
 107 ScopedMessagePipeHandle MojoPpapiGlobals::CreateGLES2Context() {
 108   return delegate_->CreateGLES2Context();
 109 }
 110
 111 ppapi::ResourceTracker* MojoPpapiGlobals::GetResourceTracker() {
 112   return &resource_tracker_;
 113 }
 114
 115 ppapi::VarTracker* MojoPpapiGlobals::GetVarTracker() {
 116   NOTIMPLEMENTED();
 117   return NULL;
 118 }
 119
 120 ppapi::CallbackTracker* MojoPpapiGlobals::GetCallbackTrackerForInstance(
 121     PP_Instance instance) {
 122   if (instance == kInstanceId && plugin_instance_)
 123     return plugin_instance_->plugin_module()->callback_tracker();
 124   return NULL;
 125 }
 126
 127 void MojoPpapiGlobals::LogWithSource(PP_Instance instance,
 128                                      PP_LogLevel level,
 129                                      const std::string& source,
 130                                      const std::string& value) {
 131   NOTIMPLEMENTED();
 132 }
 133
 134 void MojoPpapiGlobals::BroadcastLogWithSource(PP_Module module,
 135                                               PP_LogLevel level,
 136                                               const std::string& source,
 137                                               const std::string& value) {
 138   NOTIMPLEMENTED();
 139 }
 140
 141 ppapi::thunk::PPB_Instance_API* MojoPpapiGlobals::GetInstanceAPI(
 142     PP_Instance instance) {
 143   if (instance == kInstanceId && plugin_instance_)
 144     return plugin_instance_;
 145   return NULL;
 146 }
 147
 148 ppapi::thunk::ResourceCreationAPI* MojoPpapiGlobals::GetResourceCreationAPI(
 149     PP_Instance instance) {
 150   if (instance == kInstanceId && plugin_instance_)
 151     return plugin_instance_->resource_creation();
 152   return NULL;
 153 }
 154
 155 PP_Module MojoPpapiGlobals::GetModuleForInstance(PP_Instance instance) {
 156   NOTIMPLEMENTED();
 157   return 0;
 158 }
 159
 160 ppapi::MessageLoopShared* MojoPpapiGlobals::GetCurrentMessageLoop() {
 161   if (base::MessageLoopProxy::current().get() == GetMainThreadMessageLoop()) {
 162     if (!main_thread_message_loop_resource_.get()) {
 163       main_thread_message_loop_resource_ = new MainThreadMessageLoopResource(
 164           GetMainThreadMessageLoop());
 165     }
 166     return main_thread_message_loop_resource_.get();
 167   }
 168
 169   NOTIMPLEMENTED();
 170   return NULL;
 171 }
 172
 173 base::TaskRunner* MojoPpapiGlobals::GetFileTaskRunner() {
 174   NOTIMPLEMENTED();
 175   return NULL;
 176 }
 177
 178 std::string MojoPpapiGlobals::GetCmdLine() {
 179   NOTIMPLEMENTED();
 180   return std::string();
 181 }
 182
 183 void MojoPpapiGlobals::PreCacheFontForFlash(const void* logfontw) {
 184   NOTIMPLEMENTED();
 185 }
 186
 187 }  // namespace examples
 188 }  // namespace mojo