ppapi/proxy/ppapi_command_buffer_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/ppapi_command_buffer_proxy.h"
   6
   7 #include "ppapi/proxy/ppapi_messages.h"
   8 #include "ppapi/proxy/proxy_channel.h"
   9 #include "ppapi/shared_impl/api_id.h"
  10 #include "ppapi/shared_impl/host_resource.h"
  11
  12 namespace ppapi {
  13 namespace proxy {
  14
  15 PpapiCommandBufferProxy::PpapiCommandBufferProxy(
  16     const ppapi::HostResource& resource,
  17     ProxyChannel* channel)
  18     : resource_(resource),
  19       channel_(channel) {
  20 }
  21
  22 PpapiCommandBufferProxy::~PpapiCommandBufferProxy() {
  23   // Delete all the locally cached shared memory objects, closing the handle
  24   // in this process.
  25   for (TransferBufferMap::iterator it = transfer_buffers_.begin();
  26        it != transfer_buffers_.end(); ++it) {
  27     delete it->second.shared_memory;
  28     it->second.shared_memory = NULL;
  29   }
  30 }
  31
  32 void PpapiCommandBufferProxy::ReportChannelError() {
  33   if (!channel_error_callback_.is_null()) {
  34     channel_error_callback_.Run();
  35     channel_error_callback_.Reset();
  36   }
  37 }
  38
  39 int PpapiCommandBufferProxy::GetRouteID() const {
  40   NOTIMPLEMENTED();
  41   return 0;
  42 }
  43
  44 bool PpapiCommandBufferProxy::Echo(const base::Closure& callback) {
  45   return false;
  46 }
  47
  48 bool PpapiCommandBufferProxy::SetParent(
  49     CommandBufferProxy* parent_command_buffer,
  50     uint32 parent_texture_id) {
  51   // TODO(fsamuel): Need a proper implementation of this to support offscreen
  52   // contexts in the guest renderer (WebGL, canvas, etc).
  53   NOTIMPLEMENTED();
  54   return false;
  55 }
  56
  57 void PpapiCommandBufferProxy::SetChannelErrorCallback(
  58     const base::Closure& callback) {
  59   channel_error_callback_ = callback;
  60 }
  61
  62 bool PpapiCommandBufferProxy::Initialize() {
  63   return Send(new PpapiHostMsg_PPBGraphics3D_InitCommandBuffer(
  64       ppapi::API_ID_PPB_GRAPHICS_3D, resource_));
  65 }
  66
  67 gpu::CommandBuffer::State PpapiCommandBufferProxy::GetState() {
  68   // Send will flag state with lost context if IPC fails.
  69   if (last_state_.error == gpu::error::kNoError) {
  70     gpu::CommandBuffer::State state;
  71     bool success = false;
  72     if (Send(new PpapiHostMsg_PPBGraphics3D_GetState(
  73              ppapi::API_ID_PPB_GRAPHICS_3D, resource_, &state, &success))) {
  74       UpdateState(state, success);
  75     }
  76   }
  77
  78   return last_state_;
  79 }
  80
  81 gpu::CommandBuffer::State PpapiCommandBufferProxy::GetLastState() {
  82   // Note: The locking command buffer wrapper does not take a global lock before
  83   // calling this function.
  84   return last_state_;
  85 }
  86
  87 void PpapiCommandBufferProxy::Flush(int32 put_offset) {
  88   if (last_state_.error != gpu::error::kNoError)
  89     return;
  90
  91   IPC::Message* message = new PpapiHostMsg_PPBGraphics3D_AsyncFlush(
  92       ppapi::API_ID_PPB_GRAPHICS_3D, resource_, put_offset);
  93
  94   // Do not let a synchronous flush hold up this message. If this handler is
  95   // deferred until after the synchronous flush completes, it will overwrite the
  96   // cached last_state_ with out-of-date data.
  97   message->set_unblock(true);
  98   Send(message);
  99 }
 100
 101 gpu::CommandBuffer::State PpapiCommandBufferProxy::FlushSync(int32 put_offset,
 102                                                    int32 last_known_get) {
 103   if (last_known_get == last_state_.get_offset) {
 104     // Send will flag state with lost context if IPC fails.
 105     if (last_state_.error == gpu::error::kNoError) {
 106       gpu::CommandBuffer::State state;
 107       bool success = false;
 108       if (Send(new PpapiHostMsg_PPBGraphics3D_Flush(
 109                ppapi::API_ID_PPB_GRAPHICS_3D, resource_, put_offset,
 110               last_known_get, &state, &success))) {
 111         UpdateState(state, success);
 112       }
 113     }
 114   } else {
 115     Flush(put_offset);
 116   }
 117   return last_state_;
 118 }
 119
 120 void PpapiCommandBufferProxy::SetGetBuffer(int32 transfer_buffer_id) {
 121   if (last_state_.error == gpu::error::kNoError) {
 122     Send(new PpapiHostMsg_PPBGraphics3D_SetGetBuffer(
 123          ppapi::API_ID_PPB_GRAPHICS_3D, resource_, transfer_buffer_id));
 124   }
 125 }
 126
 127 void PpapiCommandBufferProxy::SetGetOffset(int32 get_offset) {
 128   // Not implemented in proxy.
 129   NOTREACHED();
 130 }
 131
 132 gpu::Buffer PpapiCommandBufferProxy::CreateTransferBuffer(size_t size,
 133                                                           int32* id) {
 134   *id = -1;
 135
 136   if (last_state_.error != gpu::error::kNoError)
 137     return gpu::Buffer();
 138
 139   if (!Send(new PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer(
 140             ppapi::API_ID_PPB_GRAPHICS_3D, resource_, size, id))) {
 141     return gpu::Buffer();
 142   }
 143
 144   if ((*id) <= 0)
 145     return gpu::Buffer();
 146
 147   return GetTransferBuffer(*id);
 148 }
 149
 150 void PpapiCommandBufferProxy::DestroyTransferBuffer(int32 id) {
 151   if (last_state_.error != gpu::error::kNoError)
 152     return;
 153
 154   // Remove the transfer buffer from the client side4 cache.
 155   TransferBufferMap::iterator it = transfer_buffers_.find(id);
 156
 157   if (it != transfer_buffers_.end()) {
 158     // Delete the shared memory object, closing the handle in this process.
 159     delete it->second.shared_memory;
 160
 161     transfer_buffers_.erase(it);
 162   }
 163
 164   Send(new PpapiHostMsg_PPBGraphics3D_DestroyTransferBuffer(
 165       ppapi::API_ID_PPB_GRAPHICS_3D, resource_, id));
 166 }
 167
 168 gpu::Buffer PpapiCommandBufferProxy::GetTransferBuffer(int32 id) {
 169   if (last_state_.error != gpu::error::kNoError)
 170     return gpu::Buffer();
 171
 172   // Check local cache to see if there is already a client side shared memory
 173   // object for this id.
 174   TransferBufferMap::iterator it = transfer_buffers_.find(id);
 175   if (it != transfer_buffers_.end()) {
 176     return it->second;
 177   }
 178
 179   // Assuming we are in the renderer process, the service is responsible for
 180   // duplicating the handle. This might not be true for NaCl.
 181   ppapi::proxy::SerializedHandle handle(
 182       ppapi::proxy::SerializedHandle::SHARED_MEMORY);
 183   if (!Send(new PpapiHostMsg_PPBGraphics3D_GetTransferBuffer(
 184             ppapi::API_ID_PPB_GRAPHICS_3D, resource_, id, &handle))) {
 185     return gpu::Buffer();
 186   }
 187   if (!handle.is_shmem())
 188     return gpu::Buffer();
 189
 190   // Cache the transfer buffer shared memory object client side.
 191   scoped_ptr<base::SharedMemory> shared_memory(
 192       new base::SharedMemory(handle.shmem(), false));
 193
 194   // Map the shared memory on demand.
 195   if (!shared_memory->memory()) {
 196     if (!shared_memory->Map(handle.size())) {
 197       return gpu::Buffer();
 198     }
 199   }
 200
 201   gpu::Buffer buffer;
 202   buffer.ptr = shared_memory->memory();
 203   buffer.size = handle.size();
 204   buffer.shared_memory = shared_memory.release();
 205   transfer_buffers_[id] = buffer;
 206
 207   return buffer;
 208 }
 209
 210 void PpapiCommandBufferProxy::SetToken(int32 token) {
 211   NOTREACHED();
 212 }
 213
 214 void PpapiCommandBufferProxy::SetParseError(gpu::error::Error error) {
 215   NOTREACHED();
 216 }
 217
 218 void PpapiCommandBufferProxy::SetContextLostReason(
 219     gpu::error::ContextLostReason reason) {
 220   NOTREACHED();
 221 }
 222
 223 bool PpapiCommandBufferProxy::Send(IPC::Message* msg) {
 224   DCHECK(last_state_.error == gpu::error::kNoError);
 225
 226   if (channel_->Send(msg))
 227     return true;
 228
 229   last_state_.error = gpu::error::kLostContext;
 230   return false;
 231 }
 232
 233 void PpapiCommandBufferProxy::UpdateState(
 234     const gpu::CommandBuffer::State& state,
 235     bool success) {
 236   // Handle wraparound. It works as long as we don't have more than 2B state
 237   // updates in flight across which reordering occurs.
 238   if (success) {
 239     if (state.generation - last_state_.generation < 0x80000000U) {
 240       last_state_ = state;
 241     }
 242   } else {
 243     last_state_.error = gpu::error::kLostContext;
 244     ++last_state_.generation;
 245   }
 246 }
 247
 248 }  // namespace proxy
 249 }  // namespace ppapi