Use mapped memory for uploading large textures.

gpu/command_buffer/client/ring_buffer.cc

 // Copyright (c) 2011 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 RingBuffer class.
 
 #include "gpu/command_buffer/client/ring_buffer.h"
 
 #include <algorithm>
 
@@ skipping 85 matching lines @@
       DCHECK(block.state == IN_USE)
           << "block that corresponds to offset already freed";
       block.token = token;
       block.state = FREE_PENDING_TOKEN;
       return;
     }
   }
   NOTREACHED() << "attempt to free non-existant block";
 }
 
+void RingBuffer::DiscardBlock(void* pointer) {
+  Offset offset = GetOffset(pointer);
+  offset -= base_offset_;
+  DCHECK(!blocks_.empty()) << "no allocations to discard";
+  for (Container::reverse_iterator it = blocks_.rbegin();
+        it != blocks_.rend();
+        ++it) {
+    Block& block = *it;
+    if (block.offset == offset) {
+      DCHECK(block.state != PADDING)
+          << "block that corresponds to offset already discarded";
+      block.state = PADDING;
+
+      // Remove block if it were in the back along with any extra padding.
+      while (!blocks_.empty() && blocks_.back().state == PADDING) {
+        free_offset_= blocks_.back().offset;
+        blocks_.pop_back();
+      }
+
+      // Remove blocks if it were in the front along with extra padding.
+      while (!blocks_.empty() && blocks_.front().state == PADDING) {
+        blocks_.pop_front();
+        if (blocks_.empty())
+          break;
+
+        in_use_offset_ = blocks_.front().offset;
+      }
+
+      // In the special case when there are no blocks, we should be reset it.
+      if (blocks_.empty()) {
+        in_use_offset_ = 0;
+        free_offset_ = 0;
+      }
+      return;
+    }
+  }
+  NOTREACHED() << "attempt to discard non-existant block";
+}
+
 unsigned int RingBuffer::GetLargestFreeSizeNoWaiting() {
   unsigned int last_token_read = helper_->last_token_read();
   while (!blocks_.empty()) {
     Block& block = blocks_.front();
     if (block.token > last_token_read || block.state == IN_USE) break;
     FreeOldestBlock();
   }
   if (free_offset_ == in_use_offset_) {
     if (blocks_.empty()) {
       // The entire buffer is free.
       DCHECK_EQ(free_offset_, 0u);
       return size_;
     } else {
       // The entire buffer is in use.
       return 0;
     }
   } else if (free_offset_ > in_use_offset_) {
     // It's free from free_offset_ to size_ and from 0 to in_use_offset_
     return std::max(size_ - free_offset_, in_use_offset_);
   } else {
     // It's free from free_offset_ -> in_use_offset_;
     return in_use_offset_ - free_offset_;
   }
 }
 
 }  // namespace gpu