Use mus::MojoGpuMemoryBufferManager in mus::GpuService.

components/mus/gpu/gpu_service_mus.cc

 // Copyright 2016 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 "components/mus/gpu/gpu_service_mus.h"
 
 #include "base/memory/shared_memory.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "components/mus/gpu/gpu_memory_buffer_manager_mus_local.h"
+#include "components/mus/common/mojo_gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/config/gpu_info_collector.h"
 #include "gpu/config/gpu_switches.h"
 #include "gpu/config/gpu_util.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "gpu/ipc/common/memory_stats.h"
 #include "gpu/ipc/common/surface_handle.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h"
 #include "media/gpu/ipc/service/gpu_video_decode_accelerator.h"
 #include "media/gpu/ipc/service/gpu_video_encode_accelerator.h"
 #include "media/gpu/ipc/service/media_service.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "url/gurl.h"
 
 namespace mus {
 namespace {
 
 const int kLocalGpuChannelClientId = 1;
 const uint64_t kLocalGpuChannelClientTracingId = 1;
 
 void EstablishGpuChannelDone(
+    int client_id,
     std::unique_ptr<IPC::ChannelHandle> channel_handle,
     const GpuServiceMus::EstablishGpuChannelCallback& callback) {
-  callback.Run(*channel_handle);
+  callback.Run(channel_handle ? client_id : -1, *channel_handle);
 }
 }
 
 GpuServiceMus::GpuServiceMus()
-    : main_message_loop_(base::MessageLoop::current()),
+    : next_client_id_(kLocalGpuChannelClientId),
+      main_message_loop_(base::MessageLoop::current()),
       shutdown_event_(true, false),
       gpu_thread_("GpuThread"),
       io_thread_("GpuIOThread") {
   Initialize();
 }
 
 GpuServiceMus::~GpuServiceMus() {
   // Signal this event before destroying the child process.  That way all
   // background threads can cleanup.
   // For example, in the renderer the RenderThread instances will be able to
   // notice shutdown before the render process begins waiting for them to exit.
   shutdown_event_.Signal();
   io_thread_.Stop();
 }
 
 void GpuServiceMus::EstablishGpuChannel(
-    int client_id,
     uint64_t client_tracing_id,
     bool preempts,
     bool allow_view_command_buffers,
     bool allow_real_time_streams,
     const EstablishGpuChannelCallback& callback) {
-  DCHECK_GT(client_id, kLocalGpuChannelClientId);
+  DCHECK(CalledOnValidThread());
 
   if (!gpu_channel_manager_) {
-    callback.Run(IPC::ChannelHandle());
+    callback.Run(-1, IPC::ChannelHandle());
     return;
   }
 
+  const int client_id = ++next_client_id_;
   std::unique_ptr<IPC::ChannelHandle> channel_handle(new IPC::ChannelHandle);
   gpu_thread_.task_runner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GpuServiceMus::EstablishGpuChannelOnGpuThread,
                  base::Unretained(this), client_id, client_tracing_id, preempts,
                  allow_view_command_buffers, allow_real_time_streams,
                  base::Unretained(channel_handle.get())),
-      base::Bind(&EstablishGpuChannelDone, base::Passed(&channel_handle),
-                 callback));
+      base::Bind(&EstablishGpuChannelDone, client_id,
+                 base::Passed(&channel_handle), callback));
 }
 
 gfx::GpuMemoryBufferHandle GpuServiceMus::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     int32_t surface_handle) {
+  DCHECK(CalledOnValidThread());
   return gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
       id, size, format, usage, client_id,
       static_cast<gpu::SurfaceHandle>(surface_handle));
 }
 
 gfx::GpuMemoryBufferHandle GpuServiceMus::CreateGpuMemoryBufferFromeHandle(
     gfx::GpuMemoryBufferHandle buffer_handle,
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     int client_id) {
+  DCHECK(CalledOnValidThread());
+
   return gpu_memory_buffer_factory_->CreateGpuMemoryBufferFromHandle(
       buffer_handle, id, size, format, client_id);
 }
 
 void GpuServiceMus::DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                                            int client_id,
                                            const gpu::SyncToken& sync_token) {
+  DCHECK(CalledOnValidThread());
+
   if (gpu_channel_manager_)
     gpu_channel_manager_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
 }
 
 void GpuServiceMus::DidCreateOffscreenContext(const GURL& active_url) {
   NOTIMPLEMENTED();
 }
 
 void GpuServiceMus::DidDestroyChannel(int client_id) {
   media_service_->RemoveChannel(client_id);
@@ skipping 26 matching lines @@
     gpu::SurfaceHandle child_window) {
   NOTIMPLEMENTED();
 }
 #endif
 
 void GpuServiceMus::SetActiveURL(const GURL& url) {
   NOTIMPLEMENTED();
 }
 
 void GpuServiceMus::Initialize() {
+  DCHECK(CalledOnValidThread());
   base::Thread::Options thread_options(base::MessageLoop::TYPE_DEFAULT, 0);
   thread_options.priority = base::ThreadPriority::NORMAL;
   CHECK(gpu_thread_.StartWithOptions(thread_options));
 
   thread_options = base::Thread::Options(base::MessageLoop::TYPE_IO, 0);
   thread_options.priority = base::ThreadPriority::NORMAL;
 #if defined(OS_ANDROID)
   // TODO(reveman): Remove this in favor of setting it explicitly for each type
   // of process.
   thread_options.priority = base::ThreadPriority::DISPLAY;
 #endif
   CHECK(io_thread_.StartWithOptions(thread_options));
 
   IPC::ChannelHandle channel_handle;
   bool manual_reset = true;
   bool initially_signaled = false;
   base::WaitableEvent event(manual_reset, initially_signaled);
   gpu_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&GpuServiceMus::InitializeOnGpuThread,
                             base::Unretained(this), &channel_handle, &event));
   event.Wait();
 
-  gpu_memory_buffer_manager_mus_local_.reset(new GpuMemoryBufferManagerMusLocal(
-      kLocalGpuChannelClientId, kLocalGpuChannelClientTracingId));
+  gpu_memory_buffer_manager_local_.reset(new MojoGpuMemoryBufferManager);
   gpu_channel_local_ = gpu::GpuChannelHost::Create(
       this, kLocalGpuChannelClientId, gpu_info_, channel_handle,
-      &shutdown_event_, gpu_memory_buffer_manager_mus_local_.get());
+      &shutdown_event_, gpu_memory_buffer_manager_local_.get());
 }
 
 void GpuServiceMus::InitializeOnGpuThread(IPC::ChannelHandle* channel_handle,
                                           base::WaitableEvent* event) {
   gpu_info_.video_decode_accelerator_capabilities =
       media::GpuVideoDecodeAccelerator::GetCapabilities(gpu_preferences_);
   gpu_info_.video_encode_accelerator_supported_profiles =
       media::GpuVideoEncodeAccelerator::GetSupportedProfiles(gpu_preferences_);
   gpu_info_.jpeg_decode_accelerator_supported =
       media::GpuJpegDecodeAccelerator::IsSupported();
@@ skipping 70 matching lines @@
   return shm;
 }
 
 // static
 GpuServiceMus* GpuServiceMus::GetInstance() {
   return base::Singleton<GpuServiceMus,
                          base::LeakySingletonTraits<GpuServiceMus>>::get();
 }
 
 }  // namespace mus