Adds MapBufferSubData and MapTexSubImage2D....

gpu/command_buffer/client/fenced_allocator.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.
 
 // This file contains the implementation of the FencedAllocator class.
 
 #include "../client/fenced_allocator.h"
 #include <algorithm>
 #include "../client/cmd_buffer_helper.h"
 
 namespace gpu {
 
 #ifndef COMPILER_MSVC
 const FencedAllocator::Offset FencedAllocator::kInvalidOffset;
 #endif
 
 FencedAllocator::~FencedAllocator() {
   // Free blocks pending tokens.
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
     if (blocks_[i].state == FREE_PENDING_TOKEN) {
       i = WaitForTokenAndFreeBlock(i);
     }
   }
-  DCHECK_EQ(blocks_.size(), 1u);
-  DCHECK_EQ(blocks_[0].state, FREE);
+  // These checks are not valid if the service has crashed or lost the context.
+  // DCHECK_EQ(blocks_.size(), 1u);
+  // DCHECK_EQ(blocks_[0].state, FREE);
 }
 
 // Looks for a non-allocated block that is big enough. Search in the FREE
 // blocks first (for direct usage), first-fit, then in the FREE_PENDING_TOKEN
 // blocks, waiting for them. The current implementation isn't smart about
 // optimizing what to wait for, just looks inside the block in order (first-fit
 // as well).
 FencedAllocator::Offset FencedAllocator::Alloc(unsigned int size) {
   // Similarly to malloc, an allocation of 0 allocates at least 1 byte, to
   // return different pointers every time.
@@ skipping 22 matching lines @@
 // Looks for the corresponding block, mark it FREE, and collapse it if
 // necessary.
 void FencedAllocator::Free(FencedAllocator::Offset offset) {
   BlockIndex index = GetBlockByOffset(offset);
   DCHECK_NE(blocks_[index].state, FREE);
   blocks_[index].state = FREE;
   CollapseFreeBlock(index);
 }
 
 // Looks for the corresponding block, mark it FREE_PENDING_TOKEN.
-void FencedAllocator::FreePendingToken(FencedAllocator::Offset offset,
-                                       unsigned int token) {
+void FencedAllocator::FreePendingToken(
+    FencedAllocator::Offset offset, int32 token) {
   BlockIndex index = GetBlockByOffset(offset);
   Block &block = blocks_[index];
   block.state = FREE_PENDING_TOKEN;
   block.token = token;
 }
 
 // Gets the max of the size of the blocks marked as free.
 unsigned int FencedAllocator::GetLargestFreeSize() {
   unsigned int max_size = 0;
   for (unsigned int i = 0; i < blocks_.size(); ++i) {
@@ skipping 67 matching lines @@
 // Waits for the block's token, then mark the block as free, then collapse it.
 FencedAllocator::BlockIndex FencedAllocator::WaitForTokenAndFreeBlock(
     BlockIndex index) {
   Block &block = blocks_[index];
   DCHECK_EQ(block.state, FREE_PENDING_TOKEN);
   helper_->WaitForToken(block.token);
   block.state = FREE;
   return CollapseFreeBlock(index);
 }
 
+// Frees any blocks pending a token for which the token has been read.
+void FencedAllocator::FreeUnused() {
+  int32 last_token_read = helper_->last_token_read();
+  for (unsigned int i = 0; i < blocks_.size();) {
+    Block& block = blocks_[i];
+    if (block.state == FREE_PENDING_TOKEN && block.token <= last_token_read) {
+      block.state = FREE;
+      i = CollapseFreeBlock(i);
+    } else {
+      ++i;
+    }
+  }
+}
+
 // If the block is exactly the requested size, simply mark it IN_USE, otherwise
 // split it and mark the first one (of the requested size) IN_USE.
 FencedAllocator::Offset FencedAllocator::AllocInBlock(BlockIndex index,
                                                       unsigned int size) {
   Block &block = blocks_[index];
   DCHECK_GE(block.size, size);
   DCHECK_EQ(block.state, FREE);
   Offset offset = block.offset;
   if (block.size == size) {
     block.state = IN_USE;
@@ skipping 10 matching lines @@
 // The blocks are in offset order, so we can do a binary search.
 FencedAllocator::BlockIndex FencedAllocator::GetBlockByOffset(Offset offset) {
   Block templ = { IN_USE, offset, 0, kUnusedToken };
   Container::iterator it = std::lower_bound(blocks_.begin(), blocks_.end(),
                                             templ, OffsetCmp());
   DCHECK(it != blocks_.end() && it->offset == offset);
   return it-blocks_.begin();
 }
 
 }  // namespace gpu