gpu: GPU service scheduler.

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/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
+#include "gpu/command_buffer/common/scheduling_priority.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 {
 
@@ skipping 32 matching lines @@
 std::unique_ptr<Gpu> Gpu::Create(
     service_manager::Connector* connector,
     const std::string& service_name,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   return base::WrapUnique(
       new Gpu(connector, service_name, 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;
+  int32_t stream_id = 0;
+  gpu::SchedulingPriority stream_priority = gpu::SchedulingPriority::kNormal;
+
+  bool automatic_flushes = false;
+  bool support_locking = false;

[sadrul, 2017/05/11 04:05:09]

Can these remain constexpr (or const)?

[sunnyps, 2017/05/11 20:58:55]

Done.

+
   gpu::gles2::ContextCreationAttribHelper attributes;
   attributes.alpha_size = -1;
   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;
-  constexpr ui::ContextProviderCommandBuffer* shared_context_provider = nullptr;
+  ui::ContextProviderCommandBuffer* shared_context_provider = nullptr;
   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,
+      std::move(gpu_channel), stream_id, stream_priority,
+      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)));
@@ skipping 80 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