| // Copyright 2013 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 "ui/ozone/platform/headless/ozone_platform_headless.h" |
| |
| #include "base/command_line.h" |
| #include "base/files/file_path.h" |
| #include "base/macros.h" |
| #include "ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h" |
| #include "ui/display/manager/fake_display_delegate.h" |
| #include "ui/events/ozone/layout/keyboard_layout_engine_manager.h" |
| #include "ui/events/ozone/layout/stub/stub_keyboard_layout_engine.h" |
| #include "ui/events/platform/platform_event_source.h" |
| #include "ui/events/system_input_injector.h" |
| #include "ui/ozone/common/stub_overlay_manager.h" |
| #include "ui/ozone/platform/headless/headless_surface_factory.h" |
| #include "ui/ozone/platform/headless/headless_window.h" |
| #include "ui/ozone/platform/headless/headless_window_manager.h" |
| #include "ui/ozone/public/cursor_factory_ozone.h" |
| #include "ui/ozone/public/gpu_platform_support_host.h" |
| #include "ui/ozone/public/input_controller.h" |
| #include "ui/ozone/public/ozone_platform.h" |
| #include "ui/ozone/public/ozone_switches.h" |
| #include "ui/platform_window/platform_window_init_properties.h" |
| |
| namespace ui { |
| |
| namespace { |
| |
| // A headless implementation of PlatformEventSource that we can instantiate to |
| // make |
| // sure that the PlatformEventSource has an instance while in unit tests. |
| class HeadlessPlatformEventSource : public PlatformEventSource { |
| public: |
| HeadlessPlatformEventSource() = default; |
| ~HeadlessPlatformEventSource() override = default; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(HeadlessPlatformEventSource); |
| }; |
| |
| // OzonePlatform for headless mode |
| class OzonePlatformHeadless : public OzonePlatform { |
| public: |
| explicit OzonePlatformHeadless(const base::FilePath& dump_file) |
| : file_path_(dump_file) {} |
| ~OzonePlatformHeadless() override = default; |
| |
| // OzonePlatform: |
| ui::SurfaceFactoryOzone* GetSurfaceFactoryOzone() override { |
| return surface_factory_.get(); |
| } |
| OverlayManagerOzone* GetOverlayManager() override { |
| return overlay_manager_.get(); |
| } |
| CursorFactoryOzone* GetCursorFactoryOzone() override { |
| return cursor_factory_ozone_.get(); |
| } |
| InputController* GetInputController() override { |
| return input_controller_.get(); |
| } |
| GpuPlatformSupportHost* GetGpuPlatformSupportHost() override { |
| return gpu_platform_support_host_.get(); |
| } |
| std::unique_ptr<SystemInputInjector> CreateSystemInputInjector() override { |
| return nullptr; // no input injection support. |
| } |
| std::unique_ptr<PlatformWindow> CreatePlatformWindow( |
| PlatformWindowDelegate* delegate, |
| const PlatformWindowInitProperties& properties) override { |
| return std::make_unique<HeadlessWindow>(delegate, window_manager_.get(), |
| properties.bounds); |
| } |
| std::unique_ptr<display::NativeDisplayDelegate> CreateNativeDisplayDelegate() |
| override { |
| return std::make_unique<display::FakeDisplayDelegate>(); |
| } |
| |
| void InitializeUI(const InitParams& params) override { |
| window_manager_ = std::make_unique<HeadlessWindowManager>(); |
| surface_factory_ = std::make_unique<HeadlessSurfaceFactory>(file_path_); |
| // This unbreaks tests that create their own. |
| if (!PlatformEventSource::GetInstance()) |
| platform_event_source_ = std::make_unique<HeadlessPlatformEventSource>(); |
| KeyboardLayoutEngineManager::SetKeyboardLayoutEngine( |
| std::make_unique<StubKeyboardLayoutEngine>()); |
| |
| overlay_manager_ = std::make_unique<StubOverlayManager>(); |
| input_controller_ = CreateStubInputController(); |
| cursor_factory_ozone_ = std::make_unique<BitmapCursorFactoryOzone>(); |
| gpu_platform_support_host_.reset(CreateStubGpuPlatformSupportHost()); |
| } |
| |
| void InitializeGPU(const InitParams& params) override { |
| if (!surface_factory_) |
| surface_factory_ = std::make_unique<HeadlessSurfaceFactory>(file_path_); |
| } |
| |
| private: |
| std::unique_ptr<HeadlessWindowManager> window_manager_; |
| std::unique_ptr<HeadlessSurfaceFactory> surface_factory_; |
| std::unique_ptr<PlatformEventSource> platform_event_source_; |
| std::unique_ptr<CursorFactoryOzone> cursor_factory_ozone_; |
| std::unique_ptr<InputController> input_controller_; |
| std::unique_ptr<GpuPlatformSupportHost> gpu_platform_support_host_; |
| std::unique_ptr<OverlayManagerOzone> overlay_manager_; |
| base::FilePath file_path_; |
| |
| DISALLOW_COPY_AND_ASSIGN(OzonePlatformHeadless); |
| }; |
| |
| } // namespace |
| |
| OzonePlatform* CreateOzonePlatformHeadless() { |
| base::CommandLine* cmd = base::CommandLine::ForCurrentProcess(); |
| base::FilePath location; |
| if (cmd->HasSwitch(switches::kOzoneDumpFile)) |
| location = cmd->GetSwitchValuePath(switches::kOzoneDumpFile); |
| return new OzonePlatformHeadless(location); |
| } |
| |
| } // namespace ui |