zero-copy: Clarify to allocate/destroy GpuMemoryBuffer on any thread and use it on the main thread o

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/message_router.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
-#include "ipc/message_filter.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_share_group.h"
 #if defined(USE_OZONE)
 #include "ui/ozone/public/gpu_platform_support.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace content {
 
 namespace {
 
-class GpuChannelManagerMessageFilter : public IPC::MessageFilter {
- public:
-  GpuChannelManagerMessageFilter(
-      GpuMemoryBufferFactory* gpu_memory_buffer_factory)
-      : sender_(NULL), gpu_memory_buffer_factory_(gpu_memory_buffer_factory) {}
-
-  void OnFilterAdded(IPC::Sender* sender) override {
-    DCHECK(!sender_);
-    sender_ = sender;
-  }
-
-  void OnFilterRemoved() override {
-    DCHECK(sender_);
-    sender_ = NULL;
-  }
-
-  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:
-  ~GpuChannelManagerMessageFilter() override {}
-
-  void OnCreateGpuMemoryBuffer(
-      const GpuMsg_CreateGpuMemoryBuffer_Params& params) {
-    TRACE_EVENT2("gpu",
-                 "GpuChannelManagerMessageFilter::OnCreateGpuMemoryBuffer",
-                 "id", params.id, "client_id", params.client_id);
-    sender_->Send(new GpuHostMsg_GpuMemoryBufferCreated(
-        gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
-            params.id, params.size, params.format, params.usage,
-            params.client_id, params.surface_handle)));
-  }
-
-  IPC::Sender* sender_;
-  GpuMemoryBufferFactory* gpu_memory_buffer_factory_;
-};
-
 gfx::GpuMemoryBufferType GetGpuMemoryBufferFactoryType() {
   std::vector<gfx::GpuMemoryBufferType> supported_types;
   GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
   DCHECK(!supported_types.empty());
   return supported_types[0];
 }
 
 }  // namespace
 
 GpuChannelManager::GpuChannelManager(MessageRouter* router,
                                      GpuWatchdog* watchdog,
                                      base::MessageLoopProxy* io_message_loop,
                                      base::WaitableEvent* shutdown_event,
                                      IPC::SyncChannel* channel)
     : io_message_loop_(io_message_loop),
       shutdown_event_(shutdown_event),
       router_(router),
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       watchdog_(watchdog),
       sync_point_manager_(gpu::SyncPointManager::Create(false)),
       gpu_memory_buffer_factory_(
           GpuMemoryBufferFactory::Create(GetGpuMemoryBufferFactoryType())),
       channel_(channel),
-      filter_(
-          new GpuChannelManagerMessageFilter(gpu_memory_buffer_factory_.get())),
       relinquish_resources_pending_(false),
       weak_factory_(this) {
   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;
   }
 }
 
@@ skipping 42 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_HANDLER(GpuMsg_RelinquishResources, OnRelinquishResources)
     IPC_MESSAGE_HANDLER(GpuMsg_UpdateValueState, OnUpdateValueState)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool GpuChannelManager::Send(IPC::Message* msg) { return router_->Send(msg); }
@@ skipping 61 matching lines @@
 
   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::OnCreateGpuMemoryBuffer(
+    const GpuMsg_CreateGpuMemoryBuffer_Params& params) {
+  TRACE_EVENT2("gpu",
+               "GpuChannelManager::OnCreateGpuMemoryBuffer",
+               "id", params.id, "client_id", params.client_id);
+  Send(new GpuHostMsg_GpuMemoryBufferCreated(
+      gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
+          params.id, params.size, params.format, params.usage,
+          params.client_id, params.surface_handle)));
+}
+
 void GpuChannelManager::DestroyGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     int client_id) {
-  io_message_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&GpuChannelManager::DestroyGpuMemoryBufferOnIO,
-                 base::Unretained(this),
-                 id,
-                 client_id));
-}
-
-void GpuChannelManager::DestroyGpuMemoryBufferOnIO(
-    gfx::GpuMemoryBufferId id,
-    int client_id) {
   gpu_memory_buffer_factory_->DestroyGpuMemoryBuffer(id, client_id);
 }
 
 void GpuChannelManager::OnDestroyGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     int client_id,
     int32 sync_point) {
   if (!sync_point) {
     DestroyGpuMemoryBuffer(id, client_id);
   } else {
@@ skipping 86 matching lines @@
     OnResourcesRelinquished();
 #endif
   }
 }
 
 void GpuChannelManager::OnResourcesRelinquished() {
   Send(new GpuHostMsg_ResourcesRelinquished());
 }
 
 }  // namespace content