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
|
// 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 CC_SURFACES_DISPLAY_H_
#define CC_SURFACES_DISPLAY_H_
#include <vector>
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "cc/output/output_surface_client.h"
#include "cc/output/renderer.h"
#include "cc/resources/returned_resource.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/surfaces/display_scheduler.h"
#include "cc/surfaces/surface_aggregator.h"
#include "cc/surfaces/surface_id.h"
#include "cc/surfaces/surface_manager.h"
#include "cc/surfaces/surfaces_export.h"
#include "ui/events/latency_info.h"
namespace gpu {
class GpuMemoryBufferManager;
}
namespace gfx {
class Size;
}
namespace cc {
class BeginFrameSource;
class DirectRenderer;
class DisplayClient;
class OutputSurface;
class RendererSettings;
class ResourceProvider;
class SharedBitmapManager;
class Surface;
class SurfaceAggregator;
class SurfaceIdAllocator;
class SurfaceFactory;
class TextureMailboxDeleter;
// A Display produces a surface that can be used to draw to a physical display
// (OutputSurface). The client is responsible for creating and sizing the
// surface IDs used to draw into the display and deciding when to draw.
class CC_SURFACES_EXPORT Display : public DisplaySchedulerClient,
public OutputSurfaceClient,
public RendererClient,
public SurfaceAggregatorClient,
public SurfaceDamageObserver {
public:
Display(DisplayClient* client,
SurfaceManager* manager,
SharedBitmapManager* bitmap_manager,
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
const RendererSettings& settings);
~Display() override;
bool Initialize(scoped_ptr<OutputSurface> output_surface,
DisplayScheduler* scheduler);
// device_scale_factor is used to communicate to the external window system
// what scale this was rendered at.
void SetSurfaceId(SurfaceId id, float device_scale_factor);
void Resize(const gfx::Size& new_size);
void SetExternalClip(const gfx::Rect& clip);
SurfaceId CurrentSurfaceId();
// SurfaceAggregatorClient implementation
void AddSurface(Surface* surface) override;
void RemoveSurface(Surface* surface) override;
// DisplaySchedulerClient implementation.
bool DrawAndSwap() override;
// OutputSurfaceClient implementation.
void CommitVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval) override;
void SetNeedsRedrawRect(const gfx::Rect& damage_rect) override;
void DidSwapBuffers() override;
void DidSwapBuffersComplete() override;
void ReclaimResources(const CompositorFrameAck* ack) override;
void DidLoseOutputSurface() override;
void SetExternalTilePriorityConstraints(
const gfx::Rect& viewport_rect,
const gfx::Transform& transform) override;
void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
void SetTreeActivationCallback(const base::Closure& callback) override;
void OnDraw(const gfx::Transform& transform,
const gfx::Rect& viewport,
const gfx::Rect& clip,
bool resourceless_software_draw) override;
// RendererClient implementation.
void SetFullRootLayerDamage() override;
// SurfaceDamageObserver implementation.
void OnSurfaceDamaged(SurfaceId surface, bool* changed) override;
private:
void InitializeRenderer();
void UpdateRootSurfaceResourcesLocked();
DisplayClient* client_;
SurfaceManager* manager_;
SharedBitmapManager* bitmap_manager_;
gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
RendererSettings settings_;
SurfaceId current_surface_id_;
gfx::Size current_surface_size_;
float device_scale_factor_;
bool swapped_since_resize_;
gfx::Rect external_clip_;
scoped_ptr<OutputSurface> output_surface_;
DisplayScheduler* scheduler_;
scoped_ptr<ResourceProvider> resource_provider_;
scoped_ptr<SurfaceAggregator> aggregator_;
scoped_ptr<DirectRenderer> renderer_;
scoped_ptr<TextureMailboxDeleter> texture_mailbox_deleter_;
std::vector<ui::LatencyInfo> stored_latency_info_;
DISALLOW_COPY_AND_ASSIGN(Display);
};
} // namespace cc
#endif // CC_SURFACES_DISPLAY_H_
|
