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 37 matching lines @@
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_drm_bridge_client.h"
 #endif
 
 namespace content {
 namespace {
 
-// Message filter used to to handle GpuMsg_CreateGpuMemoryBuffer messages
-// on the IO thread. This allows the UI thread in the browser process to remain
-// 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,
     DeferredMessages deferred_messages,
     gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
-    : GpuChildThread(GetOptions(gpu_memory_buffer_factory),
+    : GpuChildThread(GetOptions(),
                      std::move(watchdog_thread),
                      dead_on_arrival,
                      false /* in_browser_process */,
                      gpu_info,
                      gpu_feature_info,
                      gpu_memory_buffer_factory) {
   deferred_messages_ = std::move(deferred_messages);
 }
 
 GpuChildThread::GpuChildThread(
     const InProcessChildThreadParams& params,
     const gpu::GPUInfo& gpu_info,
     const gpu::GpuFeatureInfo& gpu_feature_info,
     gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : GpuChildThread(ChildThreadImpl::Options::Builder()
                          .InBrowserProcess(params)
-                         .AddStartupFilter(new GpuMemoryBufferMessageFilter(
-                             gpu_memory_buffer_factory))
                          .ConnectToBrowser(true)
                          .Build(),
                      nullptr /* watchdog_thread */,
                      false /* dead_on_arrival */,
                      true /* in_browser_process */,
                      gpu_info,
                      gpu_feature_info,
                      gpu_memory_buffer_factory) {}
 
 GpuChildThread::GpuChildThread(
@@ skipping 67 matching lines @@
 bool GpuChildThread::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChildThread, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_GpuSwitched, OnGpuSwitched)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   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_DestroyGpuMemoryBuffer, OnDestroyGpuMemoryBuffer)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  if (handled)
-    return true;
-
-  return false;
-}
-
 void GpuChildThread::OnAssociatedInterfaceRequest(
     const std::string& name,
     mojo::ScopedInterfaceEndpointHandle handle) {
   if (associated_interfaces_.CanBindRequest(name))
     associated_interfaces_.BindRequest(name, std::move(handle));
   else
     ChildThreadImpl::OnAssociatedInterfaceRequest(name, std::move(handle));
 }
 
 void GpuChildThread::CreateGpuService(
@@ skipping 47 matching lines @@
   NOTREACHED();
 }
 
 void GpuChildThread::OnGpuSwitched() {
   DVLOG(1) << "GPU: GPU has switched";
   // Notify observers in the GPU process.
   if (!in_browser_process_)
     ui::GpuSwitchingManager::GetInstance()->NotifyGpuSwitched();
 }
 
-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);
-}
-
 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