gpu: Use mojom.GpuService API for memory allocation.

content/gpu/gpu_child_thread.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/gpu/gpu_child_thread.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 57 matching lines @@
                                  const std::string& str) {
   std::string header = str.substr(0, message_start);
   std::string message = str.substr(message_start);
 
   g_thread_safe_sender.Get()->Send(
       new GpuHostMsg_OnLogMessage(severity, header, message));
 
   return false;
 }
 
-// Message filter used to to handle GpuMsg_CreateGpuMemoryBuffer messages
-// on the IO thread. This allows the UI thread in the browser process to remain

[jbauman, 2017/02/22 02:49:45]

I think we want to continue to be able to create the gpu memory buffers on the
IO thread. Would it work to make a new channel just for these messages and
process them there?

[sadrul, 2017/02/22 03:08:51]

Having the allocation messages come to a different channel/message-pipe would
essentially expose this detail to the client (i.e. the gpu host will need to
explicitly know about this, and do things differently), which doesn't feel
great.

Alternatively, it would be possible to set things up so that all incoming mojo
messages are received on the IO thread first. I could do that, and handle the
memory-allocation messages on IO thread, but post-task the rest of the messages
to the 'main' thread. WDYT?

... although, looking back in history, the CL that introduced this filter [1] I
think did so because otherwise, the filter was being set-up too late, and some
of the initial allocation-requests were going unhandled. That should not happen
with the mojo API, since mojo takes care of queueing the messages appropriately.
So perhaps handling the messages on the IO thread isn't quite essential?

1: https://codereview.chromium.org/1210703002

-// fast at all times.
-class GpuMemoryBufferMessageFilter : public IPC::MessageFilter {
- public:
-  explicit GpuMemoryBufferMessageFilter(
-      gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
-      : gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
-        sender_(nullptr) {}
-
-  // Overridden from IPC::MessageFilter:
-  void OnFilterAdded(IPC::Channel* channel) override {
-    DCHECK(!sender_);
-    sender_ = channel;
-  }
-  void OnFilterRemoved() override {
-    DCHECK(sender_);
-    sender_ = nullptr;
-  }
-  bool OnMessageReceived(const IPC::Message& message) override {
-    DCHECK(sender_);
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(GpuMemoryBufferMessageFilter, message)
-      IPC_MESSAGE_HANDLER(GpuMsg_CreateGpuMemoryBuffer, OnCreateGpuMemoryBuffer)
-      IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
-  }
-
- protected:
-  ~GpuMemoryBufferMessageFilter() override {}
-
-  void OnCreateGpuMemoryBuffer(
-      const GpuMsg_CreateGpuMemoryBuffer_Params& params) {
-    TRACE_EVENT2("gpu", "GpuMemoryBufferMessageFilter::OnCreateGpuMemoryBuffer",
-                 "id", params.id.id, "client_id", params.client_id);
-
-    DCHECK(gpu_memory_buffer_factory_);
-    sender_->Send(new GpuHostMsg_GpuMemoryBufferCreated(
-        gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
-            params.id, params.size, params.format, params.usage,
-            params.client_id, params.surface_handle)));
-  }
-
-  gpu::GpuMemoryBufferFactory* const gpu_memory_buffer_factory_;
-  IPC::Sender* sender_;
-};
-
-ChildThreadImpl::Options GetOptions(
-    gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory) {
+ChildThreadImpl::Options GetOptions() {
   ChildThreadImpl::Options::Builder builder;
 
-  builder.AddStartupFilter(
-      new GpuMemoryBufferMessageFilter(gpu_memory_buffer_factory));
-
 #if defined(USE_OZONE)
   IPC::MessageFilter* message_filter =
       ui::OzonePlatform::GetInstance()->GetGpuMessageFilter();
   if (message_filter)
     builder.AddStartupFilter(message_filter);
 #endif
 
   builder.ConnectToBrowser(true);
 
   return builder.Build();
 }
 
 }  // namespace
 
 GpuChildThread::GpuChildThread(
     std::unique_ptr<gpu::GpuWatchdogThread> watchdog_thread,
     bool dead_on_arrival,
     const gpu::GPUInfo& gpu_info,
     const gpu::GpuFeatureInfo& gpu_feature_info,
     const DeferredMessages& deferred_messages,
     gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
-    : ChildThreadImpl(GetOptions(gpu_memory_buffer_factory)),
+    : ChildThreadImpl(GetOptions()),
       dead_on_arrival_(dead_on_arrival),
       gpu_info_(gpu_info),
       deferred_messages_(deferred_messages),
       in_browser_process_(false),
       gpu_service_(new ui::GpuService(gpu_info,
                                       std::move(watchdog_thread),
                                       gpu_memory_buffer_factory,
                                       ChildProcess::current()->io_task_runner(),
                                       gpu_feature_info)),
       gpu_main_binding_(this) {
 #if defined(OS_WIN)
   target_services_ = NULL;
 #endif
   g_thread_safe_sender.Get() = thread_safe_sender();
 }
 
 GpuChildThread::GpuChildThread(
     const InProcessChildThreadParams& params,
     const gpu::GPUInfo& gpu_info,
     const gpu::GpuFeatureInfo& gpu_feature_info,
     gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : ChildThreadImpl(ChildThreadImpl::Options::Builder()
                           .InBrowserProcess(params)
-                          .AddStartupFilter(new GpuMemoryBufferMessageFilter(
-                              gpu_memory_buffer_factory))
                           .ConnectToBrowser(true)
                           .Build()),
       dead_on_arrival_(false),
       gpu_info_(gpu_info),
       in_browser_process_(true),
       gpu_service_(new ui::GpuService(gpu_info,
                                       nullptr /* watchdog thread */,
                                       gpu_memory_buffer_factory,
                                       ChildProcess::current()->io_task_runner(),
                                       gpu_feature_info)),
@@ skipping 75 matching lines @@
   return handled;
 }
 
 bool GpuChildThread::OnMessageReceived(const IPC::Message& msg) {
   if (ChildThreadImpl::OnMessageReceived(msg))
     return true;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChildThread, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
-    IPC_MESSAGE_HANDLER(GpuMsg_DestroyGpuMemoryBuffer, OnDestroyGpuMemoryBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(GpuMsg_WakeUpGpu, OnWakeUpGpu);
     IPC_MESSAGE_HANDLER(GpuMsg_DestroyingVideoSurface,
                         OnDestroyingVideoSurface);
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   if (handled)
     return true;
@@ skipping 182 matching lines @@
 void GpuChildThread::OnCloseChannel(int32_t client_id) {
   if (gpu_channel_manager())
     gpu_channel_manager()->RemoveChannel(client_id);
 }
 
 void GpuChildThread::OnLoadedShader(const std::string& shader) {
   if (gpu_channel_manager())
     gpu_channel_manager()->PopulateShaderCache(shader);
 }
 
-void GpuChildThread::OnDestroyGpuMemoryBuffer(
-    gfx::GpuMemoryBufferId id,
-    int client_id,
-    const gpu::SyncToken& sync_token) {
-  if (gpu_channel_manager())
-    gpu_channel_manager()->DestroyGpuMemoryBuffer(id, client_id, sync_token);
-}
-
 #if defined(OS_ANDROID)
 void GpuChildThread::OnWakeUpGpu() {
   if (gpu_channel_manager())
     gpu_channel_manager()->WakeUpGpu();
 }
 
 void GpuChildThread::OnDestroyingVideoSurface(int surface_id) {
   media::AVDACodecAllocator::Instance()->OnSurfaceDestroyed(surface_id);
   Send(new GpuHostMsg_DestroyingVideoSurfaceAck(surface_id));
 }
 #endif
 
 void GpuChildThread::BindServiceFactoryRequest(
     service_manager::mojom::ServiceFactoryRequest request) {
   DVLOG(1) << "GPU: Binding service_manager::mojom::ServiceFactoryRequest";
   DCHECK(service_factory_);
   service_factory_bindings_.AddBinding(service_factory_.get(),
                                        std::move(request));
 }
 
 }  // namespace content