Redesigned CommandBuffer and NPDevice3D interfaces

gpu/command_buffer/service/command_buffer_service.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/command_buffer_service.h"
 
 #include <limits>
 
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
 
 CommandBufferService::CommandBufferService()
     : size_(0),
       get_offset_(0),
       put_offset_(0),
       token_(0),
-      parse_error_(0),
-      error_status_(false) {
+      error_(parse_error::kParseNoError) {
   // Element zero is always NULL.
   registered_objects_.push_back(linked_ptr<SharedMemory>());
 }
 
 CommandBufferService::~CommandBufferService() {
 }
 
 bool CommandBufferService::Initialize(int32 size) {
   // Fail if already initialized.
   if (ring_buffer_.get())
@@ skipping 15 matching lines @@
 Buffer CommandBufferService::GetRingBuffer() {
   Buffer buffer;
   if (ring_buffer_.get()) {
     buffer.ptr = ring_buffer_->memory();
     buffer.size = ring_buffer_->max_size();
     buffer.shared_memory = ring_buffer_.get();
   }
   return buffer;
 }
 
-int32 CommandBufferService::GetSize() {
-  return size_;
+CommandBufferService::State CommandBufferService::GetState() {
+  State state;
+  state.size = size_;
+  state.get_offset = get_offset_;
+  state.put_offset = put_offset_;
+  state.token = token_;
+  state.error = error_;
+
+  return state;
 }
 
-int32 CommandBufferService::SyncOffsets(int32 put_offset) {
-  if (put_offset < 0 || put_offset >= size_)
-    return -1;
+CommandBufferService::State CommandBufferService::Flush(int32 put_offset) {
+  if (put_offset < 0 || put_offset >= size_) {
+    error_ = gpu::parse_error::kParseOutOfBounds;
+    return GetState();
+  }
 
   put_offset_ = put_offset;
 
   if (put_offset_change_callback_.get()) {
     put_offset_change_callback_->Run();
   }
 
-  return get_offset_;
-}
-
-int32 CommandBufferService::GetGetOffset() {
-  return get_offset_;
+  return GetState();
 }
 
 void CommandBufferService::SetGetOffset(int32 get_offset) {
   DCHECK(get_offset >= 0 && get_offset < size_);
   get_offset_ = get_offset;
 }
 
-int32 CommandBufferService::GetPutOffset() {
-  return put_offset_;
-}
-
 int32 CommandBufferService::CreateTransferBuffer(size_t size) {
   linked_ptr<SharedMemory> buffer(new SharedMemory);
   if (!buffer->Create(std::wstring(), false, false, size))
     return -1;
 
   if (unused_registered_object_elements_.empty()) {
     // Check we haven't exceeded the range that fits in a 32-bit integer.
     if (registered_objects_.size() > std::numeric_limits<uint32>::max())
       return -1;
 
@@ skipping 46 matching lines @@
       return Buffer();
   }
 
   Buffer buffer;
   buffer.ptr = shared_memory->memory();
   buffer.size = shared_memory->max_size();
   buffer.shared_memory = shared_memory;
   return buffer;
 }
 
-int32 CommandBufferService::GetToken() {
-  return token_;
-}
-
 void CommandBufferService::SetToken(int32 token) {
   token_ = token;
 }
 
-int32 CommandBufferService::ResetParseError() {
-  int32 last_error = parse_error_;
-  parse_error_ = 0;
-  return last_error;
-}
-
-void CommandBufferService::SetParseError(int32 parse_error) {
-  if (parse_error_ == 0) {
-    parse_error_ = parse_error;
+void CommandBufferService::SetParseError(parse_error::ParseError error) {
+  if (error_ == parse_error::kParseNoError) {
+    error_ = error;
   }
 }
 
-bool CommandBufferService::GetErrorStatus() {
-  return error_status_;
-}
-
-void CommandBufferService::RaiseErrorStatus() {
-  error_status_ = true;
-}
-
 void CommandBufferService::SetPutOffsetChangeCallback(
     Callback0::Type* callback) {
   put_offset_change_callback_.reset(callback);
 }
 
 }  // namespace gpu