Add PERSISTENT_MAP usage for GpuMemoryBuffers.

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

 // Copyright 2014 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 "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 82 matching lines @@
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage,
     int32 surface_id) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Fallback to shared memory buffer if |format| and |usage| are not supported
   // by factory.
   if (!gpu_memory_buffer_factory_host_->IsGpuMemoryBufferConfigurationSupported(
           format, usage)) {
     DCHECK(GpuMemoryBufferImplSharedMemory::IsFormatSupported(format));
-    DCHECK_EQ(usage, gfx::GpuMemoryBuffer::MAP);
+    DCHECK(usage == gfx::GpuMemoryBuffer::MAP ||
+           usage == gfx::GpuMemoryBuffer::PERSISTENT_MAP)
+        << usage;

[reveman, 2015/05/19 16:12:12]

Do you mind adding a GpuMemoryBufferImplSharedMemory::IsUsageSupported function
to clean this up a bit?

[danakj, 2015/05/19 22:19:43]

Done.

     return GpuMemoryBufferImplSharedMemory::Create(
         g_next_gpu_memory_buffer_id.GetNext(), size, format);
   }
 
   AllocateGpuMemoryBufferRequest request(size, format, usage, gpu_client_id_,
                                          surface_id);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferOnIO,
@@ skipping 21 matching lines @@
 
   BufferMap& buffers = clients_[child_client_id];
   DCHECK(buffers.find(new_id) == buffers.end());
 
   // Fallback to shared memory buffer if |format| and |usage| are not supported
   // by factory.
   if (!gpu_memory_buffer_factory_host_->IsGpuMemoryBufferConfigurationSupported(
           format, usage)) {
     // Early out if we cannot fallback to shared memory buffer.
     if (!GpuMemoryBufferImplSharedMemory::IsFormatSupported(format) ||
-        !GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, format) ||
-        usage != gfx::GpuMemoryBuffer::MAP) {
+        !GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, format)) {
       callback.Run(gfx::GpuMemoryBufferHandle());
       return;
     }
+    if (usage != gfx::GpuMemoryBuffer::MAP &&
+        usage != gfx::GpuMemoryBuffer::PERSISTENT_MAP) {
+      callback.Run(gfx::GpuMemoryBufferHandle());
+      return;
+    }
 
     buffers[new_id] = BufferInfo(size, format, gfx::SHARED_MEMORY_BUFFER);
     callback.Run(GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
         new_id, size, format, child_process_handle));
     return;
   }
 
   // Note: Handling of cases where the child process is removed before the
   // allocation completes is less subtle if we set the buffer type to
   // EMPTY_BUFFER here and verify that this has not changed when allocation
@@ skipping 190 matching lines @@
   DCHECK_NE(handle.type, gfx::SHARED_MEMORY_BUFFER);
 
   // Store the type of this buffer so it can be cleaned up if the child
   // process is removed.
   buffer_it->second.type = handle.type;
 
   callback.Run(handle);
 }
 
 }  // namespace content