Enable sync allocation of GpuMemoryBuffers from the browser process.

content/common/gpu/gpu_channel_manager.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/common/gpu/gpu_channel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/sync_point_manager.h"
 #include "content/common/message_router.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
+#include "ipc/message_filter.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_share_group.h"
 
 namespace content {
 
-GpuChannelManager::GpuMemoryBufferOperation::GpuMemoryBufferOperation(
-    int32 sync_point,
-    base::Closure callback)
-    : sync_point(sync_point), callback(callback) {
-}
+namespace {
 
-GpuChannelManager::GpuMemoryBufferOperation::~GpuMemoryBufferOperation() {
+class GpuChannelManagerMessageFilter : public IPC::MessageFilter {

[reveman, 2014/09/04 19:43:31]

I would much prefer if this "allocation on IO thread" change was done in a
separate patch.

[alexst (slow to review), 2014/09/04 21:14:47]

I originally started writing these as two separate patches, but decided to merge
them because one gives much needed context to the other.

Servicing this on IO in the GPU process is part of the design for the browser
side UI thread blocking for as little as possible. I felt there is benefit in
having the end-to-end interaction in one patch.

That said, if you feel strongly about the two parts being separate, I'll split
them up.

[reveman, 2014/09/04 22:37:24]

Ok, makes sense. You can include it in this patch if you like.

+ public:
+  GpuChannelManagerMessageFilter(
+      GpuMemoryBufferFactory* gpu_memory_buffer_factory)
+      : sender_(NULL), gpu_memory_buffer_factory_(gpu_memory_buffer_factory) {}
+
+  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
+    DCHECK(!sender_);
+    sender_ = sender;
+  }
+
+  virtual void OnFilterRemoved() OVERRIDE {
+    DCHECK(sender_);
+    sender_ = NULL;
+  }
+
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    DCHECK(sender_);
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(GpuChannelManagerMessageFilter, message)
+      IPC_MESSAGE_HANDLER(GpuMsg_CreateGpuMemoryBuffer, OnCreateGpuMemoryBuffer)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled;
+  }
+
+ protected:
+  virtual ~GpuChannelManagerMessageFilter() {}
+
+  void OnCreateGpuMemoryBuffer(const gfx::GpuMemoryBufferHandle& handle,
+                               const gfx::Size& size,
+                               unsigned internalformat,
+                               unsigned usage) {
+    TRACE_EVENT2("gpu",
+                 "GpuChannelManagerMessageFilter::OnCreateGpuMemoryBuffer",
+                 "primary_id",
+                 handle.global_id.primary_id,
+                 "secondary_id",
+                 handle.global_id.secondary_id);
+    sender_->Send(new GpuHostMsg_GpuMemoryBufferCreated(
+        gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
+            handle, size, internalformat, usage)));
+  }
+
+  IPC::Sender* sender_;
+  GpuMemoryBufferFactory* gpu_memory_buffer_factory_;
+};

[reveman, 2014/09/04 19:43:31]

style nit: blank line after this

[alexst (slow to review), 2014/09/04 21:14:47]

Done.

 }
 
 GpuChannelManager::GpuChannelManager(MessageRouter* router,
                                      GpuWatchdog* watchdog,
                                      base::MessageLoopProxy* io_message_loop,
-                                     base::WaitableEvent* shutdown_event)
+                                     base::WaitableEvent* shutdown_event,
+                                     IPC::SyncChannel* channel)
     : weak_factory_(this),
       io_message_loop_(io_message_loop),
       shutdown_event_(shutdown_event),
       router_(router),
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       watchdog_(watchdog),
       sync_point_manager_(new SyncPointManager),
-      gpu_memory_buffer_factory_(GpuMemoryBufferFactory::Create()) {
+      gpu_memory_buffer_factory_(GpuMemoryBufferFactory::Create()),
+      channel_(channel),
+      filter_(new GpuChannelManagerMessageFilter(
+          gpu_memory_buffer_factory_.get())) {
   DCHECK(router_);
   DCHECK(io_message_loop);
   DCHECK(shutdown_event);
+  channel_->AddFilter(filter_.get());
 }
 
 GpuChannelManager::~GpuChannelManager() {
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = NULL;
   }
-  DCHECK(gpu_memory_buffer_operations_.empty());
 }
 
 gpu::gles2::ProgramCache* GpuChannelManager::program_cache() {
   if (!program_cache_.get() &&
       (gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary ||
        gfx::g_driver_gl.ext.b_GL_OES_get_program_binary) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuProgramCache)) {
     program_cache_.reset(new gpu::gles2::MemoryProgramCache());
   }
@@ skipping 33 matching lines @@
     return iter->second;
 }
 
 bool GpuChannelManager::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannelManager, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
                         OnCreateViewCommandBuffer)
-    IPC_MESSAGE_HANDLER(GpuMsg_CreateGpuMemoryBuffer, OnCreateGpuMemoryBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_DestroyGpuMemoryBuffer, OnDestroyGpuMemoryBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool GpuChannelManager::Send(IPC::Message* msg) { return router_->Send(msg); }
 
 void GpuChannelManager::OnEstablishChannel(int client_id,
@@ skipping 57 matching lines @@
   CreateCommandBufferResult result = CREATE_COMMAND_BUFFER_FAILED;
 
   GpuChannelMap::const_iterator iter = gpu_channels_.find(client_id);
   if (iter != gpu_channels_.end()) {
     result = iter->second->CreateViewCommandBuffer(
         window, surface_id, init_params, route_id);
   }
 
   Send(new GpuHostMsg_CommandBufferCreated(result));
 }
-
-void GpuChannelManager::CreateGpuMemoryBuffer(
-    const gfx::GpuMemoryBufferHandle& handle,
-    const gfx::Size& size,
-    unsigned internalformat,
-    unsigned usage) {
-  Send(new GpuHostMsg_GpuMemoryBufferCreated(
-      gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
-          handle, size, internalformat, usage)));
+void GpuChannelManager::DestroyGpuMemoryBuffer(
+    const gfx::GpuMemoryBufferHandle& handle) {
+  io_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuChannelManager::DestroyGpuMemoryBufferOnIO,
+                 base::Unretained(this),
+                 handle));
 }
 
-void GpuChannelManager::OnCreateGpuMemoryBuffer(
-    const gfx::GpuMemoryBufferHandle& handle,
-    const gfx::Size& size,
-    unsigned internalformat,
-    unsigned usage) {
-  if (gpu_memory_buffer_operations_.empty()) {
-    CreateGpuMemoryBuffer(handle, size, internalformat, usage);
-  } else {
-    gpu_memory_buffer_operations_.push_back(new GpuMemoryBufferOperation(
-        0,
-        base::Bind(&GpuChannelManager::CreateGpuMemoryBuffer,
-                   base::Unretained(this),
-                   handle,
-                   size,
-                   internalformat,
-                   usage)));
-  }
-}
-
-void GpuChannelManager::DestroyGpuMemoryBuffer(
+void GpuChannelManager::DestroyGpuMemoryBufferOnIO(
     const gfx::GpuMemoryBufferHandle& handle) {
   gpu_memory_buffer_factory_->DestroyGpuMemoryBuffer(handle);
 }
 
 void GpuChannelManager::OnDestroyGpuMemoryBuffer(
     const gfx::GpuMemoryBufferHandle& handle,
     int32 sync_point) {
-  if (!sync_point && gpu_memory_buffer_operations_.empty()) {
+  if (!sync_point) {
     DestroyGpuMemoryBuffer(handle);
   } else {
-    gpu_memory_buffer_operations_.push_back(new GpuMemoryBufferOperation(
+    sync_point_manager()->AddSyncPointCallback(
         sync_point,
         base::Bind(&GpuChannelManager::DestroyGpuMemoryBuffer,
                    base::Unretained(this),
-                   handle)));
-    if (sync_point) {
-      sync_point_manager()->AddSyncPointCallback(
-          sync_point,
-          base::Bind(
-              &GpuChannelManager::OnDestroyGpuMemoryBufferSyncPointRetired,
-              base::Unretained(this),
-              gpu_memory_buffer_operations_.back()));
-    }
+                   handle));
   }
 }
 
-void GpuChannelManager::OnDestroyGpuMemoryBufferSyncPointRetired(
-    GpuMemoryBufferOperation* gpu_memory_buffer_operation) {
-  // Mark operation as no longer having a pending sync point.
-  gpu_memory_buffer_operation->sync_point = 0;
-
-  // De-queue operations until we reach a pending sync point.
-  while (!gpu_memory_buffer_operations_.empty()) {
-    // Check if operation has a pending sync point.
-    if (gpu_memory_buffer_operations_.front()->sync_point)
-      break;
-
-    gpu_memory_buffer_operations_.front()->callback.Run();
-    delete gpu_memory_buffer_operations_.front();
-    gpu_memory_buffer_operations_.pop_front();
-  }
-}
-
 void GpuChannelManager::OnLoadedShader(std::string program_proto) {
   if (program_cache())
     program_cache()->LoadProgram(program_proto);
 }
 
 bool GpuChannelManager::HandleMessagesScheduled() {
   for (GpuChannelMap::iterator iter = gpu_channels_.begin();
        iter != gpu_channels_.end(); ++iter) {
     if (iter->second->handle_messages_scheduled())
       return true;
@@ skipping 28 matching lines @@
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
   }
   return default_offscreen_surface_.get();
 }
 
 }  // namespace content