gpu: Use mojom.GpuService API for memory allocation.

content/gpu/gpu_child_thread.cc

Index: content/gpu/gpu_child_thread.cc
diff --git a/content/gpu/gpu_child_thread.cc b/content/gpu/gpu_child_thread.cc
index 3f53ad19721536ee5de95456ebd439d1d1cacf9c..794419cf8cd5005328ddccf1e8ee8b9c2ec76b78 100644
--- a/content/gpu/gpu_child_thread.cc
+++ b/content/gpu/gpu_child_thread.cc
@@ -75,61 +75,9 @@ bool GpuProcessLogMessageHandler(int severity,
   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();
@@ -151,7 +99,7 @@ GpuChildThread::GpuChildThread(
     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),
@@ -175,8 +123,6 @@ GpuChildThread::GpuChildThread(
     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),
@@ -272,7 +218,6 @@ bool GpuChildThread::OnMessageReceived(const IPC::Message& msg) {
   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);
@@ -475,14 +420,6 @@ void GpuChildThread::OnLoadedShader(const std::string& shader) {
     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())