1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
// 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.
#ifndef UI_OZONE_PUBLIC_OZONE_PLATFORM_H_
#define UI_OZONE_PUBLIC_OZONE_PLATFORM_H_
#include <memory>
#include "base/macros.h"
#include "base/message_loop/message_loop.h"
#include "services/service_manager/public/cpp/bind_source_info.h"
#include "services/service_manager/public/cpp/binder_registry.h"
#include "ui/events/system_input_injector.h"
#include "ui/ozone/ozone_export.h"
//#include "ui/ozone/public/interfaces/drm_device.mojom.h"
namespace display {
class NativeDisplayDelegate;
}
namespace gfx {
class Rect;
}
namespace IPC {
class MessageFilter;
}
namespace service_manager {
class Connector;
}
namespace ui {
class CursorFactoryOzone;
class InputController;
class GpuPlatformSupportHost;
class OverlayManagerOzone;
class PlatformWindow;
class PlatformWindowDelegate;
class SurfaceFactoryOzone;
class SystemInputInjector;
// Base class for Ozone platform implementations.
//
// Ozone platforms must override this class and implement the virtual
// GetFooFactoryOzone() methods to provide implementations of the
// various ozone interfaces.
//
// The OzonePlatform subclass can own any state needed by the
// implementation that is shared between the various ozone interfaces,
// such as a connection to the windowing system.
//
// A platform is free to use different implementations of each
// interface depending on the context. You can, for example, create
// different objects depending on the underlying hardware, command
// line flags, or whatever is appropriate for the platform.
class OZONE_EXPORT OzonePlatform {
public:
OzonePlatform();
virtual ~OzonePlatform();
// Additional initialization params for the platform. Platforms must not
// retain a reference to this structure.
struct InitParams {
// Ozone may retain this pointer for later use. An Ozone platform embedder
// may set this value if operating in the idiomatic mojo fashion with a
// service manager. Mojo transport does not require a service manager but in
// that case ozone will not be able to connect to the DRM and cursor
// services. Instead the host must invoke |OnGpuServiceLaunched| as
// described in ui/ozone/public/gpu_platform_support_host.h to inform the
// ozone host that a process containing these services is running.
service_manager::Connector* connector = nullptr;
// Setting this to true indicates that the platform implementation should
// operate as a single process for platforms (i.e. drm) that are usually
// split between a host and viz specific portion.
bool single_process = false;
// Setting this to true indicates that the platform implementation should
// use mojo. Setting this to true requires calling |AddInterfaces|
// afterwards in the Viz process and providing a connector as part
bool using_mojo = false;
};
// Ensures the OzonePlatform instance without doing any initialization.
// No-op in case the instance is already created.
// This is useful in order call virtual methods that depend on the ozone
// platform selected at runtime, e.g. ::GetMessageLoopTypeForGpu.
static OzonePlatform* EnsureInstance();
// Initializes the subsystems/resources necessary for the UI process (e.g.
// events) with additional properties to customize the ozone platform
// implementation. Ozone will not retain InitParams after returning from
// InitalizeForUI.
static void InitializeForUI(const InitParams& args);
// Initializes the subsystems for rendering but with additional properties
// provided by |args| as with InitalizeForUI.
static void InitializeForGPU(const InitParams& args);
// Deletes the instance. Does nothing if OzonePlatform has not yet been
// initialized.
static void Shutdown();
static OzonePlatform* GetInstance();
// Registers a callback to be run when the OzonePlatform is initialized. Note
// that if an instance already exists, then the callback is called
// immediately. If an instance does not exist, and is created later, then the
// callback is called once the instance is created and initialized, on the
// thread it is initialized on. If the caller requires the callback to run on
// a specific thread, then it needs to do ensure that by itself.
static void RegisterStartupCallback(
base::OnceCallback<void(OzonePlatform*)> callback);
// Factory getters to override in subclasses. The returned objects will be
// injected into the appropriate layer at startup. Subclasses should not
// inject these objects themselves. Ownership is retained by OzonePlatform.
virtual ui::SurfaceFactoryOzone* GetSurfaceFactoryOzone() = 0;
virtual ui::OverlayManagerOzone* GetOverlayManager() = 0;
virtual ui::CursorFactoryOzone* GetCursorFactoryOzone() = 0;
virtual ui::InputController* GetInputController() = 0;
virtual IPC::MessageFilter* GetGpuMessageFilter();
virtual ui::GpuPlatformSupportHost* GetGpuPlatformSupportHost() = 0;
virtual std::unique_ptr<SystemInputInjector> CreateSystemInputInjector() = 0;
virtual std::unique_ptr<PlatformWindow> CreatePlatformWindow(
PlatformWindowDelegate* delegate,
const gfx::Rect& bounds) = 0;
virtual std::unique_ptr<display::NativeDisplayDelegate>
CreateNativeDisplayDelegate() = 0;
// Returns the message loop type required for OzonePlatform instance that
// will be initialized for the GPU process.
virtual base::MessageLoop::Type GetMessageLoopTypeForGpu();
// Ozone platform implementations may also choose to expose mojo interfaces to
// internal functionality. Embedders wishing to take advantage of ozone mojo
// implementations must invoke AddInterfaces with a valid
// service_manager::BinderRegistry* pointer to export all Mojo interfaces
// defined within Ozone.
//
// Requests arriving before they can be immediately handled will be queued and
// executed later.
//
// A default do-nothing implementation is provided to permit platform
// implementations to opt out of implementing any Mojo interfaces.
virtual void AddInterfaces(service_manager::BinderRegistryWithArgs<
const service_manager::BindSourceInfo&>* registry);
// The GPU-specific portion of Ozone would typically run in a sandboxed
// process for additional security. Some startup might need to wait until
// after the sandbox has been configured. The embedder should use this method
// to specify that the sandbox is configured and that GPU-side setup should
// complete. A default do-nothing implementation is provided to permit
// platform implementations to ignore sandboxing and any associated launch
// ordering issues.
virtual void AfterSandboxEntry();
private:
virtual void InitializeUI(const InitParams& params) = 0;
virtual void InitializeGPU(const InitParams& params) = 0;
static OzonePlatform* instance_;
DISALLOW_COPY_AND_ASSIGN(OzonePlatform);
};
} // namespace ui
#endif // UI_OZONE_PUBLIC_OZONE_PLATFORM_H_
|
