ppapi/proxy/ppb_graphics_3d_proxy.cc

   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 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
   6
   7 #include "gpu/command_buffer/client/gles2_implementation.h"
   8 #include "gpu/command_buffer/common/command_buffer.h"
   9 #include "ppapi/c/pp_errors.h"
  10 #include "ppapi/proxy/enter_proxy.h"
  11 #include "ppapi/proxy/plugin_dispatcher.h"
  12 #include "ppapi/proxy/ppapi_command_buffer_proxy.h"
  13 #include "ppapi/proxy/ppapi_messages.h"
  14 #include "ppapi/shared_impl/ppapi_globals.h"
  15 #include "ppapi/shared_impl/proxy_lock.h"
  16 #include "ppapi/thunk/enter.h"
  17 #include "ppapi/thunk/resource_creation_api.h"
  18 #include "ppapi/thunk/thunk.h"
  19
  20 using ppapi::thunk::EnterResourceNoLock;
  21 using ppapi::thunk::PPB_Graphics3D_API;
  22 using ppapi::thunk::ResourceCreationAPI;
  23
  24 namespace ppapi {
  25 namespace proxy {
  26
  27 namespace {
  28
  29 const int32 kCommandBufferSize = 1024 * 1024;
  30 const int32 kTransferBufferSize = 1024 * 1024;
  31
  32 base::SharedMemoryHandle TransportSHMHandleFromInt(Dispatcher* dispatcher,
  33                                                    int shm_handle) {
  34   // TODO(piman): Change trusted interface to return a PP_FileHandle, those
  35   // casts are ugly.
  36   base::PlatformFile source =
  37 #if defined(OS_WIN)
  38       reinterpret_cast<HANDLE>(static_cast<intptr_t>(shm_handle));
  39 #elif defined(OS_POSIX)
  40       shm_handle;
  41 #else
  42   #error Not implemented.
  43 #endif
  44   // Don't close the handle, it doesn't belong to us.
  45   return dispatcher->ShareHandleWithRemote(source, false);
  46 }
  47
  48 gpu::CommandBuffer::State GetErrorState() {
  49   gpu::CommandBuffer::State error_state;
  50   error_state.error = gpu::error::kGenericError;
  51   return error_state;
  52 }
  53
  54 }  // namespace
  55
  56 // This class just wraps a CommandBuffer and optionally locks around every
  57 // method. This is used to ensure that we have the Proxy lock any time we enter
  58 // PpapiCommandBufferProxy.
  59 //
  60 // Note, for performance reasons, most of this code is not truly thread
  61 // safe in the sense of multiple threads concurrently rendering to the same
  62 // Graphics3D context; this isn't allowed, and will likely either crash or
  63 // result in undefined behavior.  It is assumed that the thread which creates
  64 // the Graphics3D context will be the thread on which subsequent gl rendering
  65 // will be done.
  66 //
  67 // TODO(nfullagar): At some point, allow multiple threads to concurrently render
  68 // each to its own context.  First step is to allow a single thread (either main
  69 // thread or background thread) to render to a single Graphics3D context.
  70 class Graphics3D::LockingCommandBuffer : public gpu::CommandBuffer {
  71  public:
  72   explicit LockingCommandBuffer(gpu::CommandBuffer* gpu_command_buffer)
  73       : gpu_command_buffer_(gpu_command_buffer), need_to_lock_(true) {
  74   }
  75   virtual ~LockingCommandBuffer() {
  76   }
  77   void set_need_to_lock(bool need_to_lock) { need_to_lock_ = need_to_lock; }
  78   bool need_to_lock() const { return need_to_lock_; }
  79
  80  private:
  81   // MaybeLock acquires the proxy lock on construction if and only if
  82   // need_to_lock is true. If it acquired the lock, it releases it on
  83   // destruction. If need_to_lock is false, then the lock must already be held.
  84   struct MaybeLock {
  85     explicit MaybeLock(bool need_to_lock) : locked_(need_to_lock) {
  86       if (need_to_lock)
  87         ppapi::ProxyLock::Acquire();
  88       else
  89         ppapi::ProxyLock::AssertAcquired();
  90     }
  91     ~MaybeLock() {
  92       if (locked_)
  93         ppapi::ProxyLock::Release();
  94     }
  95    private:
  96     bool locked_;
  97   };
  98
  99   // gpu::CommandBuffer implementation:
 100   virtual bool Initialize() OVERRIDE {
 101     MaybeLock lock(need_to_lock_);
 102     return gpu_command_buffer_->Initialize();
 103   }
 104   virtual State GetState() OVERRIDE {
 105     MaybeLock lock(need_to_lock_);
 106     return gpu_command_buffer_->GetState();
 107   }
 108   virtual State GetLastState() OVERRIDE {
 109     // During a normal scene, the vast majority of calls are to GetLastState().
 110     // We don't allow multi-threaded rendering on the same contex, so for
 111     // performance reasons, avoid the global lock for this entry point.  We can
 112     // get away with this here because the underlying implementation of
 113     // GetLastState() is trivial and does not involve global or shared state
 114     // between other contexts.
 115     // TODO(nfullagar): We can probably skip MaybeLock for other methods, but
 116     // the performance gain may not be worth it.
 117     //
 118     // MaybeLock lock(need_to_lock_);
 119     return gpu_command_buffer_->GetLastState();
 120   }
 121   virtual int32 GetLastToken() OVERRIDE {
 122     return GetLastState().token;
 123   }
 124   virtual void Flush(int32 put_offset) OVERRIDE {
 125     MaybeLock lock(need_to_lock_);
 126     gpu_command_buffer_->Flush(put_offset);
 127   }
 128   virtual State FlushSync(int32 put_offset, int32 last_known_get) OVERRIDE {
 129     MaybeLock lock(need_to_lock_);
 130     return gpu_command_buffer_->FlushSync(put_offset, last_known_get);
 131   }
 132   virtual void SetGetBuffer(int32 transfer_buffer_id) OVERRIDE {
 133     MaybeLock lock(need_to_lock_);
 134     gpu_command_buffer_->SetGetBuffer(transfer_buffer_id);
 135   }
 136   virtual void SetGetOffset(int32 get_offset) OVERRIDE {
 137     MaybeLock lock(need_to_lock_);
 138     gpu_command_buffer_->SetGetOffset(get_offset);
 139   }
 140   virtual gpu::Buffer CreateTransferBuffer(size_t size,
 141                                            int32* id) OVERRIDE {
 142     MaybeLock lock(need_to_lock_);
 143     return gpu_command_buffer_->CreateTransferBuffer(size, id);
 144   }
 145   virtual void DestroyTransferBuffer(int32 id) OVERRIDE {
 146     MaybeLock lock(need_to_lock_);
 147     gpu_command_buffer_->DestroyTransferBuffer(id);
 148   }
 149   virtual gpu::Buffer GetTransferBuffer(int32 id) OVERRIDE {
 150     MaybeLock lock(need_to_lock_);
 151     return gpu_command_buffer_->GetTransferBuffer(id);
 152   }
 153   virtual void SetToken(int32 token) OVERRIDE {
 154     MaybeLock lock(need_to_lock_);
 155     gpu_command_buffer_->SetToken(token);
 156   }
 157   virtual void SetParseError(gpu::error::Error error) OVERRIDE {
 158     MaybeLock lock(need_to_lock_);
 159     gpu_command_buffer_->SetParseError(error);
 160   }
 161   virtual void SetContextLostReason(
 162       gpu::error::ContextLostReason reason) OVERRIDE {
 163     MaybeLock lock(need_to_lock_);
 164     gpu_command_buffer_->SetContextLostReason(reason);
 165   }
 166   virtual uint32 InsertSyncPoint() OVERRIDE {
 167     MaybeLock lock(need_to_lock_);
 168     return gpu_command_buffer_->InsertSyncPoint();
 169   }
 170
 171   // Weak pointer - see class Graphics3D for the scopted_ptr.
 172   gpu::CommandBuffer* gpu_command_buffer_;
 173
 174   bool need_to_lock_;
 175 };
 176
 177 Graphics3D::Graphics3D(const HostResource& resource)
 178     : PPB_Graphics3D_Shared(resource),
 179       num_already_locked_calls_(0) {
 180 }
 181
 182 Graphics3D::~Graphics3D() {
 183   DestroyGLES2Impl();
 184 }
 185
 186 bool Graphics3D::Init(gpu::gles2::GLES2Implementation* share_gles2) {
 187   PluginDispatcher* dispatcher = PluginDispatcher::GetForResource(this);
 188   if (!dispatcher)
 189     return false;
 190
 191   command_buffer_.reset(
 192       new PpapiCommandBufferProxy(host_resource(), dispatcher));
 193   locking_command_buffer_.reset(
 194       new LockingCommandBuffer(command_buffer_.get()));
 195
 196   ScopedNoLocking already_locked(this);
 197   return CreateGLES2Impl(kCommandBufferSize, kTransferBufferSize,
 198                          share_gles2);
 199 }
 200
 201 PP_Bool Graphics3D::SetGetBuffer(int32_t /* transfer_buffer_id */) {
 202   return PP_FALSE;
 203 }
 204
 205 gpu::CommandBuffer::State Graphics3D::GetState() {
 206   return GetErrorState();
 207 }
 208
 209 PP_Bool Graphics3D::Flush(int32_t put_offset) {
 210   return PP_FALSE;
 211 }
 212
 213 gpu::CommandBuffer::State Graphics3D::FlushSync(int32_t put_offset) {
 214   return GetErrorState();
 215 }
 216
 217 int32_t Graphics3D::CreateTransferBuffer(uint32_t size) {
 218   return PP_FALSE;
 219 }
 220
 221 PP_Bool Graphics3D::DestroyTransferBuffer(int32_t id) {
 222   return PP_FALSE;
 223 }
 224
 225 PP_Bool Graphics3D::GetTransferBuffer(int32_t id,
 226                                       int* shm_handle,
 227                                       uint32_t* shm_size) {
 228   return PP_FALSE;
 229 }
 230
 231 gpu::CommandBuffer::State Graphics3D::FlushSyncFast(int32_t put_offset,
 232                                                     int32_t last_known_get) {
 233   return GetErrorState();
 234 }
 235
 236 uint32_t Graphics3D::InsertSyncPoint() {
 237   NOTREACHED();
 238   return 0;
 239 }
 240
 241 gpu::CommandBuffer* Graphics3D::GetCommandBuffer() {
 242   return locking_command_buffer_.get();
 243 }
 244
 245 int32 Graphics3D::DoSwapBuffers() {
 246   // gles2_impl()->SwapBuffers() results in CommandBuffer calls, and we already
 247   // have the proxy lock.
 248   ScopedNoLocking already_locked(this);
 249
 250   gles2_impl()->SwapBuffers();
 251   IPC::Message* msg = new PpapiHostMsg_PPBGraphics3D_SwapBuffers(
 252       API_ID_PPB_GRAPHICS_3D, host_resource());
 253   msg->set_unblock(true);
 254   PluginDispatcher::GetForResource(this)->Send(msg);
 255
 256   return PP_OK_COMPLETIONPENDING;
 257 }
 258
 259 void Graphics3D::PushAlreadyLocked() {
 260   ppapi::ProxyLock::AssertAcquired();
 261   if (num_already_locked_calls_ == 0)
 262     locking_command_buffer_->set_need_to_lock(false);
 263   ++num_already_locked_calls_;
 264 }
 265
 266 void Graphics3D::PopAlreadyLocked() {
 267   // We must have Pushed before we can Pop.
 268   DCHECK(!locking_command_buffer_->need_to_lock());
 269   DCHECK_GT(num_already_locked_calls_, 0);
 270   ppapi::ProxyLock::AssertAcquired();
 271   --num_already_locked_calls_;
 272   if (num_already_locked_calls_ == 0)
 273     locking_command_buffer_->set_need_to_lock(true);
 274 }
 275
 276 PPB_Graphics3D_Proxy::PPB_Graphics3D_Proxy(Dispatcher* dispatcher)
 277     : InterfaceProxy(dispatcher),
 278       callback_factory_(this) {
 279 }
 280
 281 PPB_Graphics3D_Proxy::~PPB_Graphics3D_Proxy() {
 282 }
 283
 284 // static
 285 PP_Resource PPB_Graphics3D_Proxy::CreateProxyResource(
 286     PP_Instance instance,
 287     PP_Resource share_context,
 288     const int32_t* attrib_list) {
 289   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
 290   if (!dispatcher)
 291     return PP_ERROR_BADARGUMENT;
 292
 293   HostResource share_host;
 294   gpu::gles2::GLES2Implementation* share_gles2 = NULL;
 295   if (share_context != 0) {
 296     EnterResourceNoLock<PPB_Graphics3D_API> enter(share_context, true);
 297     if (enter.failed())
 298       return PP_ERROR_BADARGUMENT;
 299
 300     PPB_Graphics3D_Shared* share_graphics =
 301         static_cast<PPB_Graphics3D_Shared*>(enter.object());
 302     share_host = share_graphics->host_resource();
 303     share_gles2 = share_graphics->gles2_impl();
 304   }
 305
 306   std::vector<int32_t> attribs;
 307   if (attrib_list) {
 308     for (const int32_t* attr = attrib_list;
 309          attr[0] != PP_GRAPHICS3DATTRIB_NONE;
 310          attr += 2) {
 311       attribs.push_back(attr[0]);
 312       attribs.push_back(attr[1]);
 313     }
 314   }
 315   attribs.push_back(PP_GRAPHICS3DATTRIB_NONE);
 316
 317   HostResource result;
 318   dispatcher->Send(new PpapiHostMsg_PPBGraphics3D_Create(
 319       API_ID_PPB_GRAPHICS_3D, instance, share_host, attribs, &result));
 320   if (result.is_null())
 321     return 0;
 322
 323   scoped_refptr<Graphics3D> graphics_3d(new Graphics3D(result));
 324   if (!graphics_3d->Init(share_gles2))
 325     return 0;
 326   return graphics_3d->GetReference();
 327 }
 328
 329 bool PPB_Graphics3D_Proxy::OnMessageReceived(const IPC::Message& msg) {
 330   bool handled = true;
 331   IPC_BEGIN_MESSAGE_MAP(PPB_Graphics3D_Proxy, msg)
 332 #if !defined(OS_NACL)
 333     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_Create,
 334                         OnMsgCreate)
 335     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_SetGetBuffer,
 336                         OnMsgSetGetBuffer)
 337     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_GetState,
 338                         OnMsgGetState)
 339     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_Flush,
 340                         OnMsgFlush)
 341     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_AsyncFlush,
 342                         OnMsgAsyncFlush)
 343     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer,
 344                         OnMsgCreateTransferBuffer)
 345     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_DestroyTransferBuffer,
 346                         OnMsgDestroyTransferBuffer)
 347     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_GetTransferBuffer,
 348                         OnMsgGetTransferBuffer)
 349     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_SwapBuffers,
 350                         OnMsgSwapBuffers)
 351     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_InsertSyncPoint,
 352                         OnMsgInsertSyncPoint)
 353 #endif  // !defined(OS_NACL)
 354
 355     IPC_MESSAGE_HANDLER(PpapiMsg_PPBGraphics3D_SwapBuffersACK,
 356                         OnMsgSwapBuffersACK)
 357     IPC_MESSAGE_UNHANDLED(handled = false)
 358
 359   IPC_END_MESSAGE_MAP()
 360   // FIXME(brettw) handle bad messages!
 361   return handled;
 362 }
 363
 364 #if !defined(OS_NACL)
 365 void PPB_Graphics3D_Proxy::OnMsgCreate(PP_Instance instance,
 366                                        HostResource share_context,
 367                                        const std::vector<int32_t>& attribs,
 368                                        HostResource* result) {
 369   if (attribs.empty() ||
 370       attribs.back() != PP_GRAPHICS3DATTRIB_NONE ||
 371       !(attribs.size() & 1))
 372     return;  // Bad message.
 373
 374   thunk::EnterResourceCreation enter(instance);
 375
 376   if (enter.succeeded()) {
 377     result->SetHostResource(
 378       instance,
 379       enter.functions()->CreateGraphics3DRaw(instance,
 380                                              share_context.host_resource(),
 381                                              &attribs.front()));
 382   }
 383 }
 384
 385 void PPB_Graphics3D_Proxy::OnMsgSetGetBuffer(
 386     const HostResource& context,
 387     int32 transfer_buffer_id) {
 388   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 389   if (enter.succeeded())
 390     enter.object()->SetGetBuffer(transfer_buffer_id);
 391 }
 392
 393 void PPB_Graphics3D_Proxy::OnMsgGetState(const HostResource& context,
 394                                          gpu::CommandBuffer::State* state,
 395                                          bool* success) {
 396   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 397   if (enter.failed()) {
 398     *success = false;
 399     return;
 400   }
 401   *state = enter.object()->GetState();
 402   *success = true;
 403 }
 404
 405 void PPB_Graphics3D_Proxy::OnMsgFlush(const HostResource& context,
 406                                       int32 put_offset,
 407                                       int32 last_known_get,
 408                                       gpu::CommandBuffer::State* state,
 409                                       bool* success) {
 410   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 411   if (enter.failed()) {
 412     *success = false;
 413     return;
 414   }
 415   *state = enter.object()->FlushSyncFast(put_offset, last_known_get);
 416   *success = true;
 417 }
 418
 419 void PPB_Graphics3D_Proxy::OnMsgAsyncFlush(const HostResource& context,
 420                                            int32 put_offset) {
 421   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 422   if (enter.succeeded())
 423     enter.object()->Flush(put_offset);
 424 }
 425
 426 void PPB_Graphics3D_Proxy::OnMsgCreateTransferBuffer(
 427     const HostResource& context,
 428     uint32 size,
 429     int32* id) {
 430   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 431   if (enter.succeeded())
 432     *id = enter.object()->CreateTransferBuffer(size);
 433   else
 434     *id = -1;
 435 }
 436
 437 void PPB_Graphics3D_Proxy::OnMsgDestroyTransferBuffer(
 438     const HostResource& context,
 439     int32 id) {
 440   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 441   if (enter.succeeded())
 442     enter.object()->DestroyTransferBuffer(id);
 443 }
 444
 445 void PPB_Graphics3D_Proxy::OnMsgGetTransferBuffer(
 446     const HostResource& context,
 447     int32 id,
 448     ppapi::proxy::SerializedHandle* transfer_buffer) {
 449   transfer_buffer->set_null_shmem();
 450
 451   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 452   int shm_handle = 0;
 453   uint32_t shm_size = 0;
 454   if (enter.succeeded() &&
 455       enter.object()->GetTransferBuffer(id, &shm_handle, &shm_size)) {
 456     transfer_buffer->set_shmem(
 457         TransportSHMHandleFromInt(dispatcher(), shm_handle),
 458         shm_size);
 459   }
 460 }
 461
 462 void PPB_Graphics3D_Proxy::OnMsgSwapBuffers(const HostResource& context) {
 463   EnterHostFromHostResourceForceCallback<PPB_Graphics3D_API> enter(
 464       context, callback_factory_,
 465       &PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin, context);
 466   if (enter.succeeded())
 467     enter.SetResult(enter.object()->SwapBuffers(enter.callback()));
 468 }
 469
 470 void PPB_Graphics3D_Proxy::OnMsgInsertSyncPoint(const HostResource& context,
 471                                                 uint32* sync_point) {
 472   *sync_point = 0;
 473   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
 474   if (enter.succeeded())
 475     *sync_point = enter.object()->InsertSyncPoint();
 476 }
 477 #endif  // !defined(OS_NACL)
 478
 479 void PPB_Graphics3D_Proxy::OnMsgSwapBuffersACK(const HostResource& resource,
 480                                               int32_t pp_error) {
 481   EnterPluginFromHostResource<PPB_Graphics3D_API> enter(resource);
 482   if (enter.succeeded())
 483     static_cast<Graphics3D*>(enter.object())->SwapBuffersACK(pp_error);
 484 }
 485
 486 #if !defined(OS_NACL)
 487 void PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin(
 488     int32_t result,
 489     const HostResource& context) {
 490   dispatcher()->Send(new PpapiMsg_PPBGraphics3D_SwapBuffersACK(
 491       API_ID_PPB_GRAPHICS_3D, context, result));
 492 }
 493 #endif  // !defined(OS_NACL)
 494
 495 }  // namespace proxy
 496 }  // namespace ppapi
 497