Add multi-process GpuMemoryBuffer framework.

content/browser/gpu/browser_gpu_channel_host_factory.cc

 // Copyright (c) 2012 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_channel_host_factory.h"
 
 #include "base/bind.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
+#include "content/common/child_process_host_impl.h"
+#include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/common/gpu/gpu_messages.h"
-#include "content/common/child_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_client.h"
 #include "ipc/ipc_forwarding_message_filter.h"
 
 namespace content {
 
 BrowserGpuChannelHostFactory* BrowserGpuChannelHostFactory::instance_ = NULL;
 
 BrowserGpuChannelHostFactory::CreateRequest::CreateRequest()
     : event(false, false),
@@ skipping 253 matching lines @@
   if (request.channel_handle.name.empty())
     return NULL;
 
   GetContentClient()->SetGpuInfo(request.gpu_info);
   gpu_channel_ = GpuChannelHost::Create(
       this, request.gpu_host_id, gpu_client_id_,
       request.gpu_info, request.channel_handle);
   return gpu_channel_.get();
 }
 
+scoped_ptr<gfx::GpuMemoryBuffer>
+    BrowserGpuChannelHostFactory::AllocateGpuMemoryBuffer(
+        size_t width,
+        size_t height,
+        unsigned internalformat) {
+  DCHECK(GpuMemoryBufferImpl::IsFormatValid(internalformat));
+  if (!GpuMemoryBufferImpl::IsFormatValid(internalformat))
+    return scoped_ptr<gfx::GpuMemoryBuffer>();

[piman, 2013/10/21 21:57:00]

nit: either DCHECK or test, but not both.
If the contract is that all internalformats passed here are valid (and you've
audited the callers), then keep the DCHECK and remove the test.
If the contract is that this can fail gracefully if the internalformat is
invalid, then remove the DCHECK.

[reveman, 2013/10/22 16:26:11]

Removed the DCHECK.

+
+  size_t size = width * height *
+      GpuMemoryBufferImpl::BytesPerPixel(internalformat);
+  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
+  if (!shm->CreateAnonymous(size))
+    return scoped_ptr<gfx::GpuMemoryBuffer>();
+
+  return make_scoped_ptr<gfx::GpuMemoryBuffer>(
+      new GpuMemoryBufferImpl(shm.Pass(),
+                              width,
+                              height,
+                              internalformat));
+}
+
 // static
 void BrowserGpuChannelHostFactory::AddFilterOnIO(
     int host_id,
     scoped_refptr<IPC::ChannelProxy::MessageFilter> filter) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   GpuProcessHost* host = GpuProcessHost::FromID(host_id);
   if (host)
     host->AddFilter(filter.get());
 }
@@ skipping 15 matching lines @@
   filter->AddRoute(MSG_ROUTING_CONTROL, handler);
 
   GetIOLoopProxy()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::AddFilterOnIO,
                  gpu_host_id_,
                  filter));
 }
 
 }  // namespace content