Implement MusGpuMemoryBufferManager

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/common/mojo_gpu_memory_buffer_manager.h"
+#include "build/build_config.h"
+#include "components/mus/gpu/mus_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/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 "ui/gl/init/gl_factory.h"
 #include "url/gurl.h"
 
+#if defined(USE_OZONE)
+#include "ui/ozone/public/ozone_platform.h"
+#endif
+
 namespace mus {
 namespace {
 
 const int kLocalGpuChannelClientId = 1;
 const uint64_t kLocalGpuChannelClientTracingId = 1;
 
 void EstablishGpuChannelDone(
     int client_id,
     const IPC::ChannelHandle* channel_handle,
     const GpuServiceMus::EstablishGpuChannelCallback& callback) {
@@ skipping 135 matching lines @@
   CHECK(io_thread_.StartWithOptions(thread_options));
 
   IPC::ChannelHandle channel_handle;
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
   gpu_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&GpuServiceMus::InitializeOnGpuThread,
                             base::Unretained(this), &channel_handle, &event));
   event.Wait();
 
-  gpu_memory_buffer_manager_local_.reset(new MojoGpuMemoryBufferManager);
+  gpu_memory_buffer_manager_local_.reset(
+      new MusGpuMemoryBufferManager(this, kLocalGpuChannelClientId));
   gpu_channel_local_ = gpu::GpuChannelHost::Create(
       this, kLocalGpuChannelClientId, gpu_info_, channel_handle,
       &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();
 
+#if defined(USE_OZONE)
+  ui::OzonePlatform::InitializeForGPU();
+#endif
+
   if (gpu::GetNativeGpuMemoryBufferType() != gfx::EMPTY_BUFFER) {
     gpu_memory_buffer_factory_ =
         gpu::GpuMemoryBufferFactory::CreateNativeType();
   }
 
   if (!gl::init::InitializeGLOneOff())
     VLOG(1) << "gl::init::InitializeGLOneOff failed";
 
   DCHECK(!owned_sync_point_manager_);
   const bool allow_threaded_wait = false;
@@ skipping 54 matching lines @@
   return shm;
 }
 
 // static
 GpuServiceMus* GpuServiceMus::GetInstance() {
   return base::Singleton<GpuServiceMus,
                          base::LeakySingletonTraits<GpuServiceMus>>::get();
 }
 
 }  // namespace mus