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
|
// 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_PLATFORM_DRM_GPU_SCREEN_MANAGER_H_
#define UI_OZONE_PLATFORM_DRM_GPU_SCREEN_MANAGER_H_
#include "base/containers/scoped_ptr_hash_map.h"
#include "base/macros.h"
#include "base/memory/scoped_vector.h"
#include "base/observer_list.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/ozone/ozone_export.h"
#include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
typedef struct _drmModeModeInfo drmModeModeInfo;
namespace gfx {
class Point;
class Rect;
class Size;
} // namespace gfx
namespace ui {
class DrmDevice;
class DrmWindow;
class ScanoutBufferGenerator;
// Responsible for keeping track of active displays and configuring them.
class OZONE_EXPORT ScreenManager {
public:
ScreenManager(ScanoutBufferGenerator* surface_generator);
virtual ~ScreenManager();
// Register a display controller. This must be called before trying to
// configure it.
void AddDisplayController(const scoped_refptr<DrmDevice>& drm,
uint32_t crtc,
uint32_t connector);
// Remove a display controller from the list of active controllers. The
// controller is removed since it was disconnected.
void RemoveDisplayController(const scoped_refptr<DrmDevice>& drm,
uint32_t crtc);
// Configure a display controller. The display controller is identified by
// (|crtc|, |connector|) and the controller is modeset using |mode|.
bool ConfigureDisplayController(const scoped_refptr<DrmDevice>& drm,
uint32_t crtc,
uint32_t connector,
const gfx::Point& origin,
const drmModeModeInfo& mode);
// Disable the display controller identified by |crtc|. Note, the controller
// may still be connected, so this does not remove the controller.
bool DisableDisplayController(const scoped_refptr<DrmDevice>& drm,
uint32_t crtc);
// Returns a reference to the display controller configured to display within
// |bounds|. If the caller caches the controller it must also register as an
// observer to be notified when the controller goes out of scope.
HardwareDisplayController* GetDisplayController(const gfx::Rect& bounds);
// Adds a window for |widget|. Note: |widget| should not be associated with a
// window when calling this function.
void AddWindow(gfx::AcceleratedWidget widget, scoped_ptr<DrmWindow> window);
// Removes the window for |widget|. Note: |widget| must have a window
// associated with it when calling this function.
scoped_ptr<DrmWindow> RemoveWindow(gfx::AcceleratedWidget widget);
// Returns the window associated with |widget|. Note: This function should be
// called only if a valid window has been associated with |widget|.
DrmWindow* GetWindow(gfx::AcceleratedWidget widget);
// Updates the mapping between display controllers and windows such that a
// controller will be associated with at most one window.
void UpdateControllerToWindowMapping();
private:
typedef ScopedVector<HardwareDisplayController> HardwareDisplayControllers;
typedef base::ScopedPtrHashMap<gfx::AcceleratedWidget, DrmWindow>
WidgetToWindowMap;
// Returns an iterator into |controllers_| for the controller identified by
// (|crtc|, |connector|).
HardwareDisplayControllers::iterator FindDisplayController(
const scoped_refptr<DrmDevice>& drm,
uint32_t crtc);
bool ActualConfigureDisplayController(const scoped_refptr<DrmDevice>& drm,
uint32_t crtc,
uint32_t connector,
const gfx::Point& origin,
const drmModeModeInfo& mode);
// Returns an iterator into |controllers_| for the controller located at
// |origin|.
HardwareDisplayControllers::iterator FindActiveDisplayControllerByLocation(
const gfx::Rect& bounds);
// Perform modesetting in |controller| using |origin| and |mode|.
bool ModesetDisplayController(HardwareDisplayController* controller,
const gfx::Point& origin,
const drmModeModeInfo& mode,
bool fill_mode_set_buffer);
// Tries to set the controller identified by (|crtc|, |connector|) to mirror
// those in |mirror|. |original| is an iterator to the HDC where the
// controller is currently present.
bool HandleMirrorMode(HardwareDisplayControllers::iterator original,
HardwareDisplayControllers::iterator mirror,
const scoped_refptr<DrmDevice>& drm,
uint32_t crtc,
uint32_t connector);
// Aquire pending frames from the time the controller was disabled.
bool EnableController(HardwareDisplayController* controller);
DrmWindow* FindWindowAt(const gfx::Rect& bounds) const;
ScanoutBufferGenerator* buffer_generator_; // Not owned.
// List of display controllers (active and disabled).
HardwareDisplayControllers controllers_;
WidgetToWindowMap window_map_;
DISALLOW_COPY_AND_ASSIGN(ScreenManager);
};
} // namespace ui
#endif // UI_OZONE_PLATFORM_DRM_GPU_SCREEN_MANAGER_H_
|
