WIP GPU scheduler + delayed activation / tile draw

gpu/command_buffer/service/command_buffer_service.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 24 matching lines @@
   std::unique_ptr<char[]> memory_;
   size_t size_;
   DISALLOW_COPY_AND_ASSIGN(MemoryBufferBacking);
 };
 
 }  // anonymous namespace
 
 CommandBufferService::CommandBufferService(
     TransferBufferManagerInterface* transfer_buffer_manager)
     : ring_buffer_id_(-1),
-      shared_state_(NULL),
+      shared_state_(nullptr),
       num_entries_(0),
       get_offset_(0),
       put_offset_(0),
       transfer_buffer_manager_(transfer_buffer_manager),
       token_(0),
+      release_count_(0),
       generation_(0),
       error_(error::kNoError),
-      context_lost_reason_(error::kUnknown) {
-}
+      context_lost_reason_(error::kUnknown) {}
 
-CommandBufferService::~CommandBufferService() {
-}
+CommandBufferService::~CommandBufferService() {}
 
 CommandBufferService::State CommandBufferService::GetLastState() {
   State state;
   state.get_offset = get_offset_;
   state.token = token_;
+  state.release_count = release_count_;
   state.error = error_;
   state.context_lost_reason = context_lost_reason_;
   state.generation = ++generation_;
 
   return state;
 }
 
 int32_t CommandBufferService::GetLastToken() {
   return GetLastState().token;
 }
 
 void CommandBufferService::UpdateState() {
   if (shared_state_) {
     CommandBufferService::State state = GetLastState();
     shared_state_->Write(state);
   }
 }
 
-void CommandBufferService::WaitForTokenInRange(int32_t start, int32_t end) {
+CommandBuffer::State CommandBufferService::WaitForTokenInRange(int32_t start,
+                                                               int32_t end) {
   DCHECK(error_ != error::kNoError || InRange(start, end, token_));
+  return GetLastState();
 }
 
-void CommandBufferService::WaitForGetOffsetInRange(int32_t start, int32_t end) {
+CommandBuffer::State CommandBufferService::WaitForGetOffsetInRange(
+    int32_t start,
+    int32_t end) {
   DCHECK(error_ != error::kNoError || InRange(start, end, get_offset_));
+  return GetLastState();
 }
 
 void CommandBufferService::Flush(int32_t put_offset) {
   if (put_offset < 0 || put_offset >= num_entries_) {
     error_ = gpu::error::kOutOfBounds;
     return;
   }
 
   put_offset_ = put_offset;
 
@@ skipping 32 matching lines @@
       static_cast<CommandBufferSharedState*>(shared_state_buffer_->GetMemory());
 
   UpdateState();
 }
 
 void CommandBufferService::SetGetOffset(int32_t get_offset) {
   DCHECK(get_offset >= 0 && get_offset < num_entries_);
   get_offset_ = get_offset;
 }
 
+void CommandBufferService::SetReleaseCount(uint64_t release_count) {
+  DCHECK(release_count >= release_count_);
+  release_count_ = release_count;
+  UpdateState();
+}
+
 scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
                                                                  int32_t* id) {
   static int32_t next_id = 1;
   *id = next_id++;
   auto result = CreateTransferBufferWithId(size, *id);
   if (!result)
     *id = -1;
   return result;
 }
 
@@ skipping 25 matching lines @@
   if (!RegisterTransferBuffer(id,
                               base::MakeUnique<MemoryBufferBacking>(size))) {
     if (error_ == error::kNoError)
       error_ = gpu::error::kOutOfBounds;
     return NULL;
   }
 
   return GetTransferBuffer(id);
 }
 
-
 void CommandBufferService::SetToken(int32_t token) {
   token_ = token;
   UpdateState();
 }
 
 void CommandBufferService::SetParseError(error::Error error) {
   if (error_ == error::kNoError) {
     error_ = error;
     if (!parse_error_callback_.is_null())
       parse_error_callback_.Run();
@@ skipping 18 matching lines @@
     const GetBufferChangedCallback& callback) {
   get_buffer_change_callback_ = callback;
 }
 
 void CommandBufferService::SetParseErrorCallback(
     const base::Closure& callback) {
   parse_error_callback_ = callback;
 }
 
 }  // namespace gpu