mus: Use ui::ContextProviderCommandBuffer.

services/ui/public/cpp/gpu/gpu.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 "services/ui/public/cpp/gpu/gpu.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/cpp/gpu/client_gpu_memory_buffer_manager.h"
+#include "services/ui/public/cpp/gpu/context_provider_command_buffer.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
 #include "services/ui/public/interfaces/gpu.mojom.h"
 
 namespace ui {
 
 Gpu::Gpu(service_manager::Connector* connector,
          service_manager::InterfaceProvider* provider,
          scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(std::move(task_runner)),
@@ skipping 34 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   return base::WrapUnique(new Gpu(connector, nullptr, std::move(task_runner)));
 }
 
 std::unique_ptr<Gpu> Gpu::Create(
     service_manager::InterfaceProvider* provider,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   return base::WrapUnique(new Gpu(nullptr, provider, std::move(task_runner)));
 }
 
+scoped_refptr<cc::ContextProvider> Gpu::CreateContextProvider(
+    scoped_refptr<gpu::GpuChannelHost> gpu_channel) {
+  constexpr bool automatic_flushes = false;
+  constexpr bool support_locking = false;
+  constexpr ui::ContextProviderCommandBuffer* shared_context_provider = nullptr;

[msw, 2016/12/19 21:33:33]

optional nit: reorder after attributes to match param order?

[sadrul, 2016/12/20 03:53:20]

Done.

+  gpu::gles2::ContextCreationAttribHelper attributes;
+  attributes.alpha_size = -1;

[msw, 2016/12/19 21:33:33]

nit: this is the default; explicit assignment is not needed.

[sadrul, 2016/12/20 03:53:20]

Good point. I have kept this for now though, since the current use in other
places seem to explicitly initialize it (e.g.
RenderThreadImpl::CreateCompositorFrameSink(), CreateOffscreenContext() etc.)

+  attributes.depth_size = 0;
+  attributes.stencil_size = 0;
+  attributes.samples = 0;
+  attributes.sample_buffers = 0;
+  attributes.bind_generates_resource = false;
+  attributes.lose_context_when_out_of_memory = true;
+  return make_scoped_refptr(new ui::ContextProviderCommandBuffer(
+      std::move(gpu_channel), gpu::GPU_STREAM_DEFAULT,
+      gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle,
+      GURL("chrome://gpu/MusContextFactory"), automatic_flushes,
+      support_locking, gpu::SharedMemoryLimits(), attributes,
+      shared_context_provider, ui::command_buffer_metrics::MUS_CLIENT_CONTEXT));
+}
+
 void Gpu::EstablishGpuChannel(
     const gpu::GpuChannelEstablishedCallback& callback) {
   DCHECK(IsMainThread());
   scoped_refptr<gpu::GpuChannelHost> channel = GetGpuChannel();
   if (channel) {
     main_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(callback, std::move(channel)));
     return;
   }
   establish_callbacks_.push_back(callback);
@@ skipping 83 matching lines @@
   MojoResult result = mojo::UnwrapSharedMemoryHandle(
       std::move(handle), &platform_handle, &shared_memory_size, &readonly);
   if (result != MOJO_RESULT_OK)
     return nullptr;
   DCHECK_EQ(shared_memory_size, size);
 
   return base::MakeUnique<base::SharedMemory>(platform_handle, readonly);
 }
 
 }  // namespace ui