| // Copyright 2018 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/ws/test_ws/test_window_service.h" |
| |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "services/service_manager/public/cpp/connector.h" |
| #include "services/ws/public/mojom/constants.mojom.h" |
| #include "services/ws/test_ws/test_gpu_interface_provider.h" |
| #include "services/ws/window_service.h" |
| #include "ui/compositor/test/context_factories_for_test.h" |
| #include "ui/gl/test/gl_surface_test_support.h" |
| |
| namespace ws { |
| namespace test { |
| |
| TestWindowService::TestWindowService() = default; |
| |
| TestWindowService::~TestWindowService() { |
| // WindowService depends upon Screen, which is owned by AuraTestHelper. |
| service_context_.reset(); |
| |
| // |aura_test_helper_| could be null when exiting before fully initialized. |
| if (aura_test_helper_) { |
| aura::client::SetScreenPositionClient(aura_test_helper_->root_window(), |
| nullptr); |
| // AuraTestHelper expects TearDown() to be called. |
| aura_test_helper_->TearDown(); |
| aura_test_helper_.reset(); |
| } |
| |
| ui::TerminateContextFactoryForTests(); |
| } |
| |
| std::unique_ptr<aura::Window> TestWindowService::NewTopLevel( |
| aura::PropertyConverter* property_converter, |
| const base::flat_map<std::string, std::vector<uint8_t>>& properties) { |
| std::unique_ptr<aura::Window> top_level = |
| std::make_unique<aura::Window>(nullptr); |
| top_level->Init(ui::LAYER_NOT_DRAWN); |
| aura_test_helper_->root_window()->AddChild(top_level.get()); |
| for (auto property : properties) { |
| property_converter->SetPropertyFromTransportValue( |
| top_level.get(), property.first, &property.second); |
| } |
| return top_level; |
| } |
| |
| void TestWindowService::RunDragLoop(aura::Window* window, |
| const ui::OSExchangeData& data, |
| const gfx::Point& screen_location, |
| uint32_t drag_operation, |
| ui::DragDropTypes::DragEventSource source, |
| DragDropCompletedCallback callback) { |
| std::move(callback).Run(drag_drop_client_.StartDragAndDrop( |
| data, window->GetRootWindow(), window, screen_location, drag_operation, |
| source)); |
| } |
| |
| void TestWindowService::CancelDragLoop(aura::Window* window) { |
| drag_drop_client_.DragCancel(); |
| } |
| |
| aura::WindowTreeHost* TestWindowService::GetWindowTreeHostForDisplayId( |
| int64_t display_id) { |
| return aura_test_helper_->host(); |
| } |
| |
| void TestWindowService::OnStart() { |
| CHECK(!started_); |
| started_ = true; |
| |
| registry_.AddInterface(base::BindRepeating( |
| &TestWindowService::BindServiceFactory, base::Unretained(this))); |
| |
| #if defined(OS_CHROMEOS) |
| // Use gpu service only for ChromeOS to run content_browsertests in mash. |
| // |
| // To use this code path for all platforms, we need to fix the following |
| // flaky failure on Win7 bot: |
| // gl_surface_egl.cc: |
| // EGL Driver message (Critical) eglInitialize: No available renderers |
| // gl_initializer_win.cc: |
| // GLSurfaceEGL::InitializeOneOff failed. |
| CreateGpuHost(); |
| #else |
| gl::GLSurfaceTestSupport::InitializeOneOff(); |
| CreateAuraTestHelper(); |
| #endif // defined(OS_CHROMEOS) |
| } |
| |
| void TestWindowService::OnBindInterface( |
| const service_manager::BindSourceInfo& source_info, |
| const std::string& interface_name, |
| mojo::ScopedMessagePipeHandle interface_pipe) { |
| registry_.BindInterface(interface_name, std::move(interface_pipe)); |
| } |
| |
| void TestWindowService::CreateService( |
| service_manager::mojom::ServiceRequest request, |
| const std::string& name, |
| service_manager::mojom::PIDReceiverPtr pid_receiver) { |
| DCHECK_EQ(name, mojom::kServiceName); |
| |
| // Defer CreateService if |aura_test_helper_| is not created. |
| if (!aura_test_helper_) { |
| DCHECK(!pending_create_service_); |
| |
| pending_create_service_ = base::BindOnce( |
| &TestWindowService::CreateService, base::Unretained(this), |
| std::move(request), name, std::move(pid_receiver)); |
| return; |
| } |
| |
| DCHECK(!ui_service_created_); |
| ui_service_created_ = true; |
| |
| auto window_service = std::make_unique<WindowService>( |
| this, |
| std::make_unique<TestGpuInterfaceProvider>( |
| gpu_host_.get(), discardable_shared_memory_manager_.get()), |
| aura_test_helper_->focus_client()); |
| service_context_ = std::make_unique<service_manager::ServiceContext>( |
| std::move(window_service), std::move(request)); |
| pid_receiver->SetPID(base::GetCurrentProcId()); |
| } |
| |
| void TestWindowService::OnGpuServiceInitialized() { |
| CreateAuraTestHelper(); |
| |
| if (pending_create_service_) |
| std::move(pending_create_service_).Run(); |
| } |
| |
| void TestWindowService::BindServiceFactory( |
| service_manager::mojom::ServiceFactoryRequest request) { |
| service_factory_bindings_.AddBinding(this, std::move(request)); |
| } |
| |
| void TestWindowService::CreateGpuHost() { |
| discardable_shared_memory_manager_ = |
| std::make_unique<discardable_memory::DiscardableSharedMemoryManager>(); |
| |
| gpu_host_ = std::make_unique<gpu_host::DefaultGpuHost>( |
| this, context()->connector(), discardable_shared_memory_manager_.get()); |
| |
| // |aura_test_helper_| is created later in OnGpuServiceInitialized. |
| } |
| |
| void TestWindowService::CreateAuraTestHelper() { |
| DCHECK(!aura_test_helper_); |
| |
| ui::ContextFactory* context_factory = nullptr; |
| ui::ContextFactoryPrivate* context_factory_private = nullptr; |
| ui::InitializeContextFactoryForTests(false /* enable_pixel_output */, |
| &context_factory, |
| &context_factory_private); |
| aura_test_helper_ = std::make_unique<aura::test::AuraTestHelper>(); |
| aura_test_helper_->SetUp(context_factory, context_factory_private); |
| |
| aura::client::SetScreenPositionClient(aura_test_helper_->root_window(), |
| &screen_position_client_); |
| } |
| |
| } // namespace test |
| } // namespace ws |