services/ui: Revert CLs that broke Windows.

services/ui/service.cc

 // Copyright 2014 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/service.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "mojo/public/c/system/main.h"
 #include "services/catalog/public/cpp/resource_loader.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/tracing/public/cpp/tracing_impl.h"
 #include "services/ui/clipboard/clipboard_impl.h"
 #include "services/ui/common/switches.h"
 #include "services/ui/display/platform_screen.h"
+#include "services/ui/gles2/gpu_impl.h"
 #include "services/ui/gpu/gpu_service_impl.h"
 #include "services/ui/gpu/gpu_service_mus.h"
 #include "services/ui/ws/accessibility_manager.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/user_activity_monitor.h"
 #include "services/ui/ws/user_display_manager.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_server_test_impl.h"
@@ skipping 12 matching lines @@
 #include <X11/Xlib.h>
 #include "ui/platform_window/x11/x11_window.h"
 #elif defined(USE_OZONE)
 #include "ui/events/ozone/layout/keyboard_layout_engine.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 using shell::Connection;
 using mojo::InterfaceRequest;
+using ui::mojom::Gpu;
 using ui::mojom::WindowServerTest;
 using ui::mojom::WindowTreeHostFactory;
 
 namespace ui {
 
 namespace {
 
 const char kResourceFileStrings[] = "mus_app_resources_strings.pak";
 const char kResourceFile100[] = "mus_app_resources_100.pak";
 const char kResourceFile200[] = "mus_app_resources_200.pak";
 
 }  // namespace
 
 // TODO(sky): this is a pretty typical pattern, make it easier to do.
 struct Service::PendingRequest {
   shell::Identity remote_identity;
   std::unique_ptr<mojom::WindowTreeFactoryRequest> wtf_request;
   std::unique_ptr<mojom::DisplayManagerRequest> dm_request;
 };
 
 struct Service::UserState {
   std::unique_ptr<ws::AccessibilityManager> accessibility;
   std::unique_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
 Service::Service()
     : test_config_(false),
+// TODO(penghuang): Kludge: Use mojo command buffer when running on
+// Windows since chrome command buffer breaks unit tests
+#if defined(OS_WIN)
+      use_chrome_gpu_command_buffer_(false),
+#else
+      use_chrome_gpu_command_buffer_(true),
+#endif
       platform_screen_(display::PlatformScreen::Create()),
       weak_ptr_factory_(this) {
 }
 
 Service::~Service() {
   // Destroy |window_server_| first, since it depends on |event_source_|.
   // WindowServer (or more correctly its Displays) may have state that needs to
   // be destroyed before GpuState as well.
   window_server_.reset();
+
+  if (platform_display_init_params_.gpu_state)
+    platform_display_init_params_.gpu_state->StopThreads();
 }
 
 void Service::InitializeResources(shell::Connector* connector) {
   if (ui::ResourceBundle::HasSharedInstance())
     return;
 
   std::set<std::string> resource_paths;
   resource_paths.insert(kResourceFileStrings);
   resource_paths.insert(kResourceFile100);
   resource_paths.insert(kResourceFile200);
@@ skipping 32 matching lines @@
 
 void Service::OnStart(const shell::Identity& identity) {
   platform_display_init_params_.surfaces_state = new SurfacesState;
 
   base::PlatformThread::SetName("mus");
   tracing_.Initialize(connector(), identity.name());
   TRACE_EVENT0("mus", "Service::Initialize started");
 
   test_config_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseTestConfig);
+// TODO(penghuang): Kludge: use mojo command buffer when running on Windows
+// since Chrome command buffer breaks unit tests
+#if defined(OS_WIN)
+  use_chrome_gpu_command_buffer_ = false;
+#else
+  use_chrome_gpu_command_buffer_ =
+      !base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseMojoGpuCommandBufferInMus);
+#endif
 #if defined(USE_X11)
   XInitThreads();
   if (test_config_)
     ui::test::SetUseOverrideRedirectWindowByDefault(true);
 #endif
 
   InitializeResources(connector());
 
 #if defined(USE_OZONE)
   // The ozone platform can provide its own event source. So initialize the
@@ skipping 21 matching lines @@
 
 #if !defined(OS_ANDROID)
   event_source_ = ui::PlatformEventSource::CreateDefault();
 #endif
 
   // This needs to happen after DeviceDataManager has been constructed. That
   // happens either during OzonePlatform or PlatformEventSource initialization,
   // so keep this line below both of those.
   input_device_server_.RegisterAsObserver();
 
-  GpuServiceMus::GetInstance();
+  if (use_chrome_gpu_command_buffer_) {
+    GpuServiceMus::GetInstance();
+  } else {
+    // TODO(rjkroege): It is possible that we might want to generalize the
+    // GpuState object.
+    platform_display_init_params_.gpu_state = new GpuState();
+  }
 
   // Gpu must be running before the PlatformScreen can be initialized.
   platform_screen_->Init();
   window_server_.reset(
       new ws::WindowServer(this, platform_display_init_params_.surfaces_state));
 
   // DeviceDataManager must be initialized before TouchController. On non-Linux
   // platforms there is no DeviceDataManager so don't create touch controller.
   if (ui::DeviceDataManager::HasInstance())
     touch_controller_.reset(
         new ws::TouchController(window_server_->display_manager()));
 }
 
 bool Service::OnConnect(Connection* connection) {
   connection->AddInterface<mojom::AccessibilityManager>(this);
   connection->AddInterface<mojom::Clipboard>(this);
   connection->AddInterface<mojom::DisplayManager>(this);
-  connection->AddInterface<mojom::GpuService>(this);
   connection->AddInterface<mojom::UserAccessManager>(this);
   connection->AddInterface<mojom::UserActivityMonitor>(this);
   connection->AddInterface<WindowTreeHostFactory>(this);
   connection->AddInterface<mojom::WindowManagerWindowTreeFactory>(this);
   connection->AddInterface<mojom::WindowTreeFactory>(this);
   if (test_config_)
     connection->AddInterface<WindowServerTest>(this);
 
+  if (use_chrome_gpu_command_buffer_) {
+    connection->AddInterface<mojom::GpuService>(this);
+  } else {
+    connection->AddInterface<Gpu>(this);
+  }
+
   // On non-Linux platforms there will be no DeviceDataManager instance and no
   // purpose in adding the Mojo interface to connect to.
   if (input_device_server_.IsRegisteredAsObserver())
     input_device_server_.AddInterface(connection);
 
 #if defined(USE_OZONE)
   ui::OzonePlatform::GetInstance()->AddInterfaces(connection);
 #endif
 
   return true;
@@ skipping 54 matching lines @@
         new mojom::DisplayManagerRequest(std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
   window_server_->display_manager()
       ->GetUserDisplayManager(remote_identity.user_id())
       ->AddDisplayManagerBinding(std::move(request));
 }
 
 void Service::Create(const shell::Identity& remote_identity,
+                     mojom::GpuRequest request) {
+  if (use_chrome_gpu_command_buffer_)
+    return;
+  DCHECK(platform_display_init_params_.gpu_state);
+  new GpuImpl(std::move(request), platform_display_init_params_.gpu_state);
+}
+
+void Service::Create(const shell::Identity& remote_identity,
                      mojom::GpuServiceRequest request) {
+  if (!use_chrome_gpu_command_buffer_)
+    return;
   new GpuServiceImpl(std::move(request));
 }
 
 void Service::Create(const shell::Identity& remote_identity,
                      mojom::UserAccessManagerRequest request) {
   window_server_->user_id_tracker()->Bind(std::move(request));
 }
 
 void Service::Create(const shell::Identity& remote_identity,
                      mojom::UserActivityMonitorRequest request) {
@@ skipping 51 matching lines @@
   // Display manages its own lifetime.
   ws::Display* host_impl =
       new ws::Display(window_server_.get(), platform_display_init_params_);
   host_impl->Init(nullptr);
 
   if (touch_controller_)
     touch_controller_->UpdateTouchTransforms();
 }
 
 }  // namespace ui