Enable asynchronous glReadPixels on Windows.

gpu/command_buffer/client/mapped_memory.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.
 
 #include "gpu/command_buffer/client/mapped_memory.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 
 namespace gpu {
 
 MemoryChunk::MemoryChunk(int32 shm_id,
                          scoped_refptr<gpu::Buffer> shm,
                          CommandBufferHelper* helper,
                          const base::Closure& poll_callback)
     : shm_id_(shm_id),
       shm_(shm),
       allocator_(shm->size(), helper, poll_callback, shm->memory()) {}
 
 MemoryChunk::~MemoryChunk() {}
 
 MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper,
                                          const base::Closure& poll_callback,
                                          size_t unused_memory_reclaim_limit)
-    : chunk_size_multiple_(1),
+    : chunk_size_multiple_(FencedAllocator::kAllocAlignment),
       helper_(helper),
       poll_callback_(poll_callback),
       allocated_memory_(0),
       max_free_bytes_(unused_memory_reclaim_limit) {
 }
 
 MappedMemoryManager::~MappedMemoryManager() {
   CommandBuffer* cmd_buf = helper_->command_buffer();
   for (MemoryChunkVector::iterator iter = chunks_.begin();
        iter != chunks_.end(); ++iter) {
@@ skipping 49 matching lines @@
   int32 id = -1;
   scoped_refptr<gpu::Buffer> shm =
       cmd_buf->CreateTransferBuffer(chunk_size, &id);
   if (id  < 0)
     return NULL;
   DCHECK(shm.get());
   MemoryChunk* mc = new MemoryChunk(id, shm, helper_, poll_callback_);
   allocated_memory_ += mc->GetSize();
   chunks_.push_back(mc);
   void* mem = mc->Alloc(size);
   DCHECK(mem);

[miu, 2014/11/13 01:31:46]

This DCHECK failed with my changes to the BufferTracker unit tests.  I was
adding 4 bytes of metadata to the 64 bytes of data, which meant BufferTracker
would allocate a new gpu::Buffer of size 68 bytes.  The gpu::Buffer and
MemoryChunk would properly account for the 68 bytes, but the FencedAllocator
used by MemoryChunk::Alloc() will always round down to the nearest 16-byte
alignment, causing MemoryChunk::Alloc(68) to fail.

The solution is to ensure the MappedMemoryManager::set_chunk_size_multiple() is
always called with a value >= 16.

   *shm_id = mc->shm_id();
   *shm_offset = mc->GetOffset(mem);
   return mem;
 }
 
 void MappedMemoryManager::Free(void* pointer) {
   for (size_t ii = 0; ii < chunks_.size(); ++ii) {
     MemoryChunk* chunk = chunks_[ii];
     if (chunk->IsInChunk(pointer)) {
       chunk->Free(pointer);
@@ skipping 24 matching lines @@
       cmd_buf->DestroyTransferBuffer(chunk->shm_id());
       allocated_memory_ -= chunk->GetSize();
       iter = chunks_.erase(iter);
     } else {
       ++iter;
     }
   }
 }
 
 }  // namespace gpu