gpu/command_buffer/service/command_buffer_service.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 "gpu/command_buffer/service/command_buffer_service.h"
   6
   7 #include <limits>
   8
   9 #include "base/logging.h"
  10 #include "base/debug/trace_event.h"
  11 #include "gpu/command_buffer/common/cmd_buffer_common.h"
  12 #include "gpu/command_buffer/common/command_buffer_shared.h"
  13 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
  14
  15 using ::base::SharedMemory;
  16
  17 namespace gpu {
  18
  19 CommandBufferService::CommandBufferService(
  20     TransferBufferManagerInterface* transfer_buffer_manager)
  21     : ring_buffer_id_(-1),
  22       shared_state_(NULL),
  23       num_entries_(0),
  24       get_offset_(0),
  25       put_offset_(0),
  26       transfer_buffer_manager_(transfer_buffer_manager),
  27       token_(0),
  28       generation_(0),
  29       error_(error::kNoError),
  30       context_lost_reason_(error::kUnknown) {
  31 }
  32
  33 CommandBufferService::~CommandBufferService() {
  34 }
  35
  36 bool CommandBufferService::Initialize() {
  37   return true;
  38 }
  39
  40 CommandBufferService::State CommandBufferService::GetLastState() {
  41   State state;
  42   state.num_entries = num_entries_;
  43   state.get_offset = get_offset_;
  44   state.put_offset = put_offset_;
  45   state.token = token_;
  46   state.error = error_;
  47   state.context_lost_reason = context_lost_reason_;
  48   state.generation = ++generation_;
  49
  50   return state;
  51 }
  52
  53 int32 CommandBufferService::GetLastToken() {
  54   return GetLastState().token;
  55 }
  56
  57 void CommandBufferService::UpdateState() {
  58   if (shared_state_) {
  59     CommandBufferService::State state = GetLastState();
  60     shared_state_->Write(state);
  61   }
  62 }
  63
  64 void CommandBufferService::WaitForTokenInRange(int32 start, int32 end) {
  65   DCHECK(error_ != error::kNoError || InRange(start, end, token_));
  66 }
  67
  68 void CommandBufferService::WaitForGetOffsetInRange(int32 start, int32 end) {
  69   DCHECK(error_ != error::kNoError || InRange(start, end, get_offset_));
  70 }
  71
  72 void CommandBufferService::Flush(int32 put_offset) {
  73   if (put_offset < 0 || put_offset > num_entries_) {
  74     error_ = gpu::error::kOutOfBounds;
  75     return;
  76   }
  77
  78   put_offset_ = put_offset;
  79
  80   if (!put_offset_change_callback_.is_null())
  81     put_offset_change_callback_.Run();
  82 }
  83
  84 void CommandBufferService::SetGetBuffer(int32 transfer_buffer_id) {
  85   DCHECK_EQ(-1, ring_buffer_id_);
  86   DCHECK_EQ(put_offset_, get_offset_);  // Only if it's empty.
  87   // If the buffer is invalid we handle it gracefully.
  88   // This means ring_buffer_ can be NULL.
  89   ring_buffer_ = GetTransferBuffer(transfer_buffer_id);
  90   ring_buffer_id_ = transfer_buffer_id;
  91   int32 size = ring_buffer_.get() ? ring_buffer_->size() : 0;
  92   num_entries_ = size / sizeof(CommandBufferEntry);
  93   put_offset_ = 0;
  94   SetGetOffset(0);
  95   if (!get_buffer_change_callback_.is_null()) {
  96     get_buffer_change_callback_.Run(ring_buffer_id_);
  97   }
  98
  99   UpdateState();
 100 }
 101
 102 void CommandBufferService::SetSharedStateBuffer(
 103     scoped_ptr<BufferBacking> shared_state_buffer) {
 104   shared_state_buffer_ = shared_state_buffer.Pass();
 105   DCHECK(shared_state_buffer_->GetSize() >= sizeof(*shared_state_));
 106
 107   shared_state_ =
 108       static_cast<CommandBufferSharedState*>(shared_state_buffer_->GetMemory());
 109
 110   UpdateState();
 111 }
 112
 113 void CommandBufferService::SetGetOffset(int32 get_offset) {
 114   DCHECK(get_offset >= 0 && get_offset < num_entries_);
 115   get_offset_ = get_offset;
 116 }
 117
 118 scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
 119                                                                  int32* id) {
 120   *id = -1;
 121
 122   scoped_ptr<SharedMemory> shared_memory(new SharedMemory());
 123   if (!shared_memory->CreateAndMapAnonymous(size))
 124     return NULL;
 125
 126   static int32 next_id = 1;
 127   *id = next_id++;
 128
 129   if (!RegisterTransferBuffer(
 130           *id, MakeBackingFromSharedMemory(shared_memory.Pass(), size))) {
 131     *id = -1;
 132     return NULL;
 133   }
 134
 135   return GetTransferBuffer(*id);
 136 }
 137
 138 void CommandBufferService::DestroyTransferBuffer(int32 id) {
 139   transfer_buffer_manager_->DestroyTransferBuffer(id);
 140   if (id == ring_buffer_id_) {
 141     ring_buffer_id_ = -1;
 142     ring_buffer_ = NULL;
 143     num_entries_ = 0;
 144     get_offset_ = 0;
 145     put_offset_ = 0;
 146   }
 147 }
 148
 149 scoped_refptr<Buffer> CommandBufferService::GetTransferBuffer(int32 id) {
 150   return transfer_buffer_manager_->GetTransferBuffer(id);
 151 }
 152
 153 bool CommandBufferService::RegisterTransferBuffer(
 154     int32 id,
 155     scoped_ptr<BufferBacking> buffer) {
 156   return transfer_buffer_manager_->RegisterTransferBuffer(id, buffer.Pass());
 157 }
 158
 159 void CommandBufferService::SetToken(int32 token) {
 160   token_ = token;
 161   UpdateState();
 162 }
 163
 164 void CommandBufferService::SetParseError(error::Error error) {
 165   if (error_ == error::kNoError) {
 166     error_ = error;
 167     if (!parse_error_callback_.is_null())
 168       parse_error_callback_.Run();
 169   }
 170 }
 171
 172 void CommandBufferService::SetContextLostReason(
 173     error::ContextLostReason reason) {
 174   context_lost_reason_ = reason;
 175 }
 176
 177 void CommandBufferService::SetPutOffsetChangeCallback(
 178     const base::Closure& callback) {
 179   put_offset_change_callback_ = callback;
 180 }
 181
 182 void CommandBufferService::SetGetBufferChangeCallback(
 183     const GetBufferChangedCallback& callback) {
 184   get_buffer_change_callback_ = callback;
 185 }
 186
 187 void CommandBufferService::SetParseErrorCallback(
 188     const base::Closure& callback) {
 189   parse_error_callback_ = callback;
 190 }
 191
 192 }  // namespace gpu