mus-gpu: Include GpuPreferences when requesting for GpuService.

services/ui/gpu/gpu_main.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/gpu/gpu_main.h"
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "gpu/ipc/gpu_in_process_thread_service.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "services/ui/common/server_gpu_memory_buffer_manager.h"
 #include "services/ui/gpu/gpu_service.h"
 
+#if defined(OS_MACOSX)
+#include "base/message_loop/message_pump_mac.h"
+#endif
+
 namespace {
 
 #if defined(USE_X11)
 std::unique_ptr<base::MessagePump> CreateMessagePumpX11() {
   // TODO(sad): This should create a TYPE_UI message pump, and create a
   // PlatformEventSource when gpu process split happens.
   return base::MessageLoop::CreateMessagePumpForType(
       base::MessageLoop::TYPE_DEFAULT);
 }
 #endif  // defined(USE_X11)
@@ skipping 70 matching lines @@
 void GpuMain::OnStart() {
   // |this| will outlive the gpu thread and so it's safe to use
   // base::Unretained here.
   gpu_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::InitOnGpuThread, base::Unretained(this),
                  io_thread_.task_runner(), compositor_thread_.task_runner()));
 }
 
 void GpuMain::CreateGpuService(mojom::GpuServiceRequest request,
-                               mojom::GpuHostPtr gpu_host) {
+                               mojom::GpuHostPtr gpu_host,
+                               const gpu::GpuPreferences& preferences) {
   // |this| will outlive the gpu thread and so it's safe to use
   // base::Unretained here.
   gpu_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&GpuMain::CreateGpuServiceOnGpuThread, base::Unretained(this),
                  base::Passed(std::move(request)),
-                 base::Passed(gpu_host.PassInterface())));
+                 base::Passed(gpu_host.PassInterface()), preferences));
 }
 
 void GpuMain::CreateDisplayCompositor(
     cc::mojom::DisplayCompositorRequest request,
     cc::mojom::DisplayCompositorClientPtr client) {
   if (!gpu_service_) {
     pending_display_compositor_request_ = std::move(request);
     pending_display_compositor_client_info_ = client.PassInterface();
     return;
   }
@@ skipping 79 matching lines @@
 }
 
 void GpuMain::TearDownOnGpuThread() {
   gpu_service_.reset();
   gpu_memory_buffer_factory_.reset();
   gpu_init_.reset();
 }
 
 void GpuMain::CreateGpuServiceOnGpuThread(
     mojom::GpuServiceRequest request,
-    mojom::GpuHostPtrInfo gpu_host_info) {
+    mojom::GpuHostPtrInfo gpu_host_info,
+    const gpu::GpuPreferences& preferences) {
   mojom::GpuHostPtr gpu_host;
   gpu_host.Bind(std::move(gpu_host_info));
-  gpu_service_->InitializeWithHost(std::move(gpu_host));
+  gpu_service_->InitializeWithHost(std::move(gpu_host), preferences);
   gpu_service_->Bind(std::move(request));
 
   if (pending_display_compositor_request_.is_pending()) {
     CreateDisplayCompositorInternal(
         std::move(pending_display_compositor_request_),
         std::move(pending_display_compositor_client_info_));
   }
 }
 
 void GpuMain::BindGpuInternalOnGpuThread(mojom::GpuServiceRequest request) {
   gpu_service_->Bind(std::move(request));
 }
 
 void GpuMain::PreSandboxStartup() {
   // TODO(sad): https://crbug.com/645602
 }
 
 bool GpuMain::EnsureSandboxInitialized(
     gpu::GpuWatchdogThread* watchdog_thread) {
   // TODO(sad): https://crbug.com/645602
   return true;
 }
 
 }  // namespace ui