gpu: Compositor management of GpuMemoryBuffer instances.

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/debug/trace_event.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/tracked_objects.h"
+#include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_memory_buffer_factory_host_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/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/content_client.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_forwarding_message_filter.h"
 #include "ipc/message_filter.h"
 
 namespace content {
 
 BrowserGpuChannelHostFactory* BrowserGpuChannelHostFactory::instance_ = NULL;
 
 struct BrowserGpuChannelHostFactory::CreateRequest {
   CreateRequest(int32 route_id)
       : event(true, false),
         gpu_host_id(0),
         route_id(route_id),
         result(CREATE_COMMAND_BUFFER_FAILED) {}
   ~CreateRequest() {}
   base::WaitableEvent event;
   int gpu_host_id;
   int32 route_id;
   CreateCommandBufferResult result;
 };
 
-struct BrowserGpuChannelHostFactory::AllocateGpuMemoryBufferRequest {
-  AllocateGpuMemoryBufferRequest(size_t width,
-                                 size_t height,
-                                 unsigned internalformat,
-                                 unsigned usage,
-                                 int client_id)
-      : event(true, false),
-        width(width),
-        height(height),
-        internalformat(internalformat),
-        usage(usage),
-        client_id(client_id) {}
-  ~AllocateGpuMemoryBufferRequest() {}
-  base::WaitableEvent event;
-  size_t width;
-  size_t height;
-  unsigned internalformat;
-  unsigned usage;
-  int client_id;
-  scoped_ptr<gfx::GpuMemoryBuffer> result;
-};
-
 class BrowserGpuChannelHostFactory::EstablishRequest
     : public base::RefCountedThreadSafe<EstablishRequest> {
  public:
   static scoped_refptr<EstablishRequest> Create(CauseForGpuLaunch cause,
                                                 int gpu_client_id,
                                                 int gpu_host_id);
   void Wait();
   void Cancel();
 
   int gpu_host_id() { return gpu_host_id_; }
@@ skipping 163 matching lines @@
   DCHECK(instance_);
   delete instance_;
   instance_ = NULL;
 }
 
 BrowserGpuChannelHostFactory::BrowserGpuChannelHostFactory()
     : gpu_client_id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()),
       shutdown_event_(new base::WaitableEvent(true, false)),
       gpu_memory_buffer_factory_host_(new GpuMemoryBufferFactoryHostImpl),
       gpu_host_id_(0) {
+  BrowserGpuMemoryBufferManager::current()->set_gpu_client_id(gpu_client_id_);

[piman, 2014/10/09 21:33:02]

Can BrowserGpuChannelHostFactory simply own the BrowserGpuMemoryBufferManager?

[reveman, 2014/10/10 02:20:16]

Done.

I kept the static BrowserGpuMemoryBufferManager::current() function for now as I
suspect we'll need it for non-renderer child process support
(BrowserGpuMemoryBufferManager->HostGpuMemoryBufferManager) but can replace all
usage of that with
BrowserGpuChannelHostFactory::instance()->gpu_memory_buffer_manager() if you
feel strongly about it.

 }
 
 BrowserGpuChannelHostFactory::~BrowserGpuChannelHostFactory() {
   DCHECK(IsMainThread());
   if (pending_request_.get())
     pending_request_->Cancel();
   for (size_t n = 0; n < established_callbacks_.size(); n++)
     established_callbacks_[n].Run();
   shutdown_event_->Signal();
 }
@@ skipping 111 matching lines @@
   return NULL;
 }
 
 void BrowserGpuChannelHostFactory::GpuChannelEstablished() {
   DCHECK(IsMainThread());
   DCHECK(pending_request_.get());
   if (pending_request_->channel_handle().name.empty()) {
     DCHECK(!gpu_channel_.get());
   } else {
     GetContentClient()->SetGpuInfo(pending_request_->gpu_info());
-    gpu_channel_ = GpuChannelHost::Create(this,
-                                          pending_request_->gpu_info(),
-                                          pending_request_->channel_handle(),
-                                          shutdown_event_.get());
+    gpu_channel_ =
+        GpuChannelHost::Create(this,
+                               pending_request_->gpu_info(),
+                               pending_request_->channel_handle(),
+                               shutdown_event_.get(),
+                               BrowserGpuMemoryBufferManager::current());
   }
   gpu_host_id_ = pending_request_->gpu_host_id();
   gpu_memory_buffer_factory_host_->set_gpu_host_id(gpu_host_id_);
   pending_request_ = NULL;
 
   for (size_t n = 0; n < established_callbacks_.size(); n++)
     established_callbacks_[n].Run();
 
   established_callbacks_.clear();
 }
 
-scoped_ptr<gfx::GpuMemoryBuffer>
-BrowserGpuChannelHostFactory::AllocateGpuMemoryBuffer(size_t width,
-                                                      size_t height,
-                                                      unsigned internalformat,
-                                                      unsigned usage) {
-  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  AllocateGpuMemoryBufferRequest request(
-      width, height, internalformat, usage, gpu_client_id_);
-  GetIOLoopProxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&BrowserGpuChannelHostFactory::AllocateGpuMemoryBufferOnIO,
-                 base::Unretained(&request)));
-
-  // We're blocking the UI thread, which is generally undesirable.
-  TRACE_EVENT0("browser",
-               "BrowserGpuChannelHostFactory::AllocateGpuMemoryBuffer");
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
-  request.event.Wait();
-  return request.result.Pass();
-}
-
 // static
 void BrowserGpuChannelHostFactory::AddFilterOnIO(
     int host_id,
     scoped_refptr<IPC::MessageFilter> filter) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   GpuProcessHost* host = GpuProcessHost::FromID(host_id);
   if (host)
     host->AddFilter(filter.get());
 }
@@ skipping 14 matching lines @@
                                        target_task_runner);
   filter->AddRoute(MSG_ROUTING_CONTROL, handler);
 
   GetIOLoopProxy()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserGpuChannelHostFactory::AddFilterOnIO,
                  gpu_host_id_,
                  filter));
 }
 
-// static
-void BrowserGpuChannelHostFactory::AllocateGpuMemoryBufferOnIO(
-    AllocateGpuMemoryBufferRequest* request) {
-  if (!GpuMemoryBufferImpl::IsFormatValid(request->internalformat) ||
-      !GpuMemoryBufferImpl::IsUsageValid(request->usage)) {
-    request->result = scoped_ptr<gfx::GpuMemoryBuffer>();
-    request->event.Signal();
-    return;
-  }
-
-  GpuMemoryBufferImpl::Create(
-      gfx::Size(request->width, request->height),
-      request->internalformat,
-      request->usage,
-      request->client_id,
-      base::Bind(&BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated,
-                 base::Unretained(request)));
-}
-
-// static
-void BrowserGpuChannelHostFactory::OnGpuMemoryBufferCreated(
-    AllocateGpuMemoryBufferRequest* request,
-    scoped_ptr<GpuMemoryBufferImpl> buffer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  request->result = buffer.PassAs<gfx::GpuMemoryBuffer>();
-  request->event.Signal();
-}
-
 }  // namespace content