Revert 172805

> Made the registration and deletion of transfer buffers async.
> 
> Added an IPC to request multiple transfer buffer IDs up front.
> 
> Every renderer command buffer proxy gets some IPCs immediately after initialization.
> 
> Removed request_id arg from CreateTransferBuffer. It wasn't being used.
> 
> Review URL: https://chromiumcodereview.appspot.com/11308296

TBR=apatrick@chromium.org
Review URL: https://codereview.chromium.org/11578020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173018 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 84 insertions, 42 deletions

diff --git a/gpu/command_buffer/service/transfer_buffer_manager.cc b/gpu/command_buffer/service/transfer_buffer_manager.cc
index 12c9fb1..7bde12a 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager.cc
+++ b/gpu/command_buffer/service/transfer_buffer_manager.cc
@@ -8,7 +8,6 @@
 
 #include "base/process_util.h"
 #include "base/debug/trace_event.h"
-#include "gpu/command_buffer/common/gles2_cmd_utils.h"
 
 using ::base::SharedMemory;
 
@@ -19,15 +18,17 @@ TransferBufferManagerInterface::~TransferBufferManagerInterface() {
 
 TransferBufferManager::TransferBufferManager()
     : shared_memory_bytes_allocated_(0) {
+  // Element zero is always NULL.
+  registered_objects_.push_back(Buffer());
 }
 
 TransferBufferManager::~TransferBufferManager() {
-  while (!registered_buffers_.empty()) {
-    BufferMap::iterator it = registered_buffers_.begin();
-    DCHECK(shared_memory_bytes_allocated_ >= it->second.size);
-    shared_memory_bytes_allocated_ -= it->second.size;
-    delete it->second.shared_memory;
-    registered_buffers_.erase(it);
+  for (size_t i = 0; i < registered_objects_.size(); ++i) {
+    if (registered_objects_[i].shared_memory) {
+      DCHECK(shared_memory_bytes_allocated_ >= registered_objects_[i].size);
+      shared_memory_bytes_allocated_ -= registered_objects_[i].size;
+      delete registered_objects_[i].shared_memory;
+    }
   }
   DCHECK(!shared_memory_bytes_allocated_);
 }
@@ -36,38 +37,42 @@ bool TransferBufferManager::Initialize() {
   return true;
 }
 
-bool TransferBufferManager::RegisterTransferBuffer(
-    int32 id,
-    base::SharedMemory* shared_memory,
-    size_t size) {
-  if (id <= 0) {
-    DVLOG(ERROR) << "Cannot register transfer buffer with non-positive ID.";
-    return false;
-  }
+int32 TransferBufferManager::CreateTransferBuffer(
+    size_t size, int32 id_request) {
+  SharedMemory buffer;
+  if (!buffer.CreateAnonymous(size))
+    return -1;
+
+  return RegisterTransferBuffer(&buffer, size, id_request);
+}
 
-  // Fail if the ID is in use.
-  if (registered_buffers_.find(id) != registered_buffers_.end()) {
-    DVLOG(ERROR) << "Buffer ID already in use.";
-    return false;
+int32 TransferBufferManager::RegisterTransferBuffer(
+    base::SharedMemory* shared_memory, size_t size, int32 id_request) {
+  // Check we haven't exceeded the range that fits in a 32-bit integer.
+  if (unused_registered_object_elements_.empty()) {
+    if (registered_objects_.size() > std::numeric_limits<uint32>::max())
+      return -1;
   }
 
+  // Check that the requested ID is sane (not too large, or less than -1)
+  if (id_request != -1 && (id_request > 100 || id_request < -1))
+    return -1;
+
   // Duplicate the handle.
   base::SharedMemoryHandle duped_shared_memory_handle;
   if (!shared_memory->ShareToProcess(base::GetCurrentProcessHandle(),
                                      &duped_shared_memory_handle)) {
-    DVLOG(ERROR) << "Failed to duplicate shared memory handle.";
-    return false;
+    return -1;
   }
   scoped_ptr<SharedMemory> duped_shared_memory(
       new SharedMemory(duped_shared_memory_handle, false));
 
   // Map the shared memory into this process. This validates the size.
-  if (!duped_shared_memory->Map(size)) {
-    DVLOG(ERROR) << "Failed to map shared memory.";
-    return false;
-  }
+  if (!duped_shared_memory->Map(size))
+    return -1;
 
-  // If it could be mapped register the shared memory with the ID.
+  // If it could be mapped, allocate an ID and register the shared memory with
+  // that ID.
   Buffer buffer;
   buffer.ptr = duped_shared_memory->memory();
   buffer.size = size;
@@ -77,36 +82,73 @@ bool TransferBufferManager::RegisterTransferBuffer(
   TRACE_COUNTER_ID1(
       "gpu", "GpuTransferBufferMemory", this, shared_memory_bytes_allocated_);
 
-  registered_buffers_[id] = buffer;
+  // If caller requested specific id, first try to use id_request.
+  if (id_request != -1) {
+    int32 cur_size = static_cast<int32>(registered_objects_.size());
+    if (cur_size <= id_request) {
+      // Pad registered_objects_ to reach id_request.
+      registered_objects_.resize(static_cast<size_t>(id_request + 1));
+      for (int32 id = cur_size; id < id_request; ++id)
+        unused_registered_object_elements_.insert(id);
+      registered_objects_[id_request] = buffer;
+      return id_request;
+    } else if (!registered_objects_[id_request].shared_memory) {
+      // id_request is already in free list.
+      registered_objects_[id_request] = buffer;
+      unused_registered_object_elements_.erase(id_request);
+      return id_request;
+    }
+  }
 
-  return true;
+  if (unused_registered_object_elements_.empty()) {
+    int32 handle = static_cast<int32>(registered_objects_.size());
+    registered_objects_.push_back(buffer);
+    return handle;
+  } else {
+    int32 handle = *unused_registered_object_elements_.begin();
+    unused_registered_object_elements_.erase(
+        unused_registered_object_elements_.begin());
+    DCHECK(!registered_objects_[handle].shared_memory);
+    registered_objects_[handle] = buffer;
+    return handle;
+  }
 }
 
-void TransferBufferManager::DestroyTransferBuffer(int32 id) {
-  BufferMap::iterator it = registered_buffers_.find(id);
-  if (it == registered_buffers_.end()) {
-    DVLOG(ERROR) << "Transfer buffer ID was not registered.";
+void TransferBufferManager::DestroyTransferBuffer(int32 handle) {
+  if (handle <= 0)
     return;
-  }
 
-  DCHECK(shared_memory_bytes_allocated_ >= it->second.size);
-  shared_memory_bytes_allocated_ -= it->second.size;
+  if (static_cast<size_t>(handle) >= registered_objects_.size())
+    return;
+
+  DCHECK(shared_memory_bytes_allocated_ >= registered_objects_[handle].size);
+  shared_memory_bytes_allocated_ -= registered_objects_[handle].size;
   TRACE_COUNTER_ID1(
       "CommandBuffer", "SharedMemory", this, shared_memory_bytes_allocated_);
 
-  delete it->second.shared_memory;
-  registered_buffers_.erase(it);
+  delete registered_objects_[handle].shared_memory;
+  registered_objects_[handle] = Buffer();
+  unused_registered_object_elements_.insert(handle);
+
+  // Remove all null objects from the end of the vector. This allows the vector
+  // to shrink when, for example, all objects are unregistered. Note that this
+  // loop never removes element zero, which is always NULL.
+  while (registered_objects_.size() > 1 &&
+      !registered_objects_.back().shared_memory) {
+    registered_objects_.pop_back();
+    unused_registered_object_elements_.erase(
+        static_cast<int32>(registered_objects_.size()));
+  }
 }
 
-Buffer TransferBufferManager::GetTransferBuffer(int32 id) {
-  if (id == 0)
+Buffer TransferBufferManager::GetTransferBuffer(int32 handle) {
+  if (handle < 0)
     return Buffer();
 
-  BufferMap::iterator it = registered_buffers_.find(id);
-  if (it == registered_buffers_.end())
+  if (static_cast<size_t>(handle) >= registered_objects_.size())
     return Buffer();
 
-  return it->second;
+  return registered_objects_[handle];
 }
 
 }  // namespace gpu