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
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_COMPOSITOR_VIZ_PROCESS_TRANSPORT_FACTORY_H_
#define CONTENT_BROWSER_COMPOSITOR_VIZ_PROCESS_TRANSPORT_FACTORY_H_
#include <memory>
#include "base/memory/raw_ptr.h"
#include "build/build_config.h"
#include "components/viz/common/surfaces/frame_sink_id_allocator.h"
#include "components/viz/common/surfaces/subtree_capture_id_allocator.h"
#include "content/browser/compositor/image_transport_factory.h"
#include "gpu/command_buffer/common/context_result.h"
#include "gpu/ipc/client/gpu_channel_host.h"
#include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
#include "services/viz/public/mojom/compositing/compositor_frame_sink.mojom.h"
#include "ui/compositor/compositor.h"
namespace base {
class SingleThreadTaskRunner;
}
namespace cc {
class SingleThreadTaskGraphRunner;
}
namespace gpu {
class GpuChannelEstablishFactory;
}
namespace viz {
class CompositingModeReporterImpl;
class HostDisplayClient;
class RasterContextProvider;
}
namespace viz {
class ContextProviderCommandBuffer;
}
namespace content {
// Interface implementations to interact with the display compositor in the viz
// process.
class VizProcessTransportFactory : public ui::ContextFactory,
public ImageTransportFactory {
public:
VizProcessTransportFactory(
gpu::GpuChannelEstablishFactory* gpu_channel_establish_factory,
scoped_refptr<base::SingleThreadTaskRunner> resize_task_runner,
viz::CompositingModeReporterImpl* compositing_mode_reporter);
VizProcessTransportFactory(const VizProcessTransportFactory&) = delete;
VizProcessTransportFactory& operator=(const VizProcessTransportFactory&) =
delete;
~VizProcessTransportFactory() override;
// Connects HostFrameSinkManager to FrameSinkManagerImpl in viz process.
void ConnectHostFrameSinkManager();
// ui::ContextFactory implementation.
void CreateLayerTreeFrameSink(
base::WeakPtr<ui::Compositor> compositor) override;
scoped_refptr<viz::RasterContextProvider>
SharedMainThreadRasterContextProvider() override;
void RemoveCompositor(ui::Compositor* compositor) override;
cc::TaskGraphRunner* GetTaskGraphRunner() override;
viz::FrameSinkId AllocateFrameSinkId() override;
viz::SubtreeCaptureId AllocateSubtreeCaptureId() override;
viz::HostFrameSinkManager* GetHostFrameSinkManager() override;
// ImageTransportFactory implementation.
void DisableGpuCompositing() override;
ui::ContextFactory* GetContextFactory() override;
private:
struct CompositorData {
CompositorData();
CompositorData(CompositorData&& other);
CompositorData& operator=(CompositorData&& other);
~CompositorData();
std::unique_ptr<viz::HostDisplayClient> display_client;
};
// Disables GPU compositing. This notifies UI and renderer compositors to drop
// LayerTreeFrameSinks and request new ones. If fallback happens while
// creating a new LayerTreeFrameSink for UI compositor it should be passed in
// as |guilty_compositor| to avoid extra work and reentrancy problems.
void DisableGpuCompositing(ui::Compositor* guilty_compositor);
// Provided as a callback when the GPU process has crashed.
void OnGpuProcessLost();
// Esstablish GpuChannel for software compositing. If failed, it will keep
// retry for every 150 ms.
scoped_refptr<gpu::GpuChannelHost> GetGpuChannelHostForSoftwareCompositing();
// Finishes creation of LayerTreeFrameSink after GPU channel has been
// established.
void OnEstablishedGpuChannel(
base::WeakPtr<ui::Compositor> compositor_weak_ptr,
scoped_refptr<gpu::GpuChannelHost> gpu_channel);
// Tries to create the raster and main thread ContextProviders. If the
// ContextProviders already exist and haven't been lost then this will do
// nothing. Also verifies |gpu_channel_host| and checks if GPU compositing is
// blacklisted.
//
// Returns kSuccess if caller can use GPU compositing, kTransientFailure if
// caller should try again or kFatalFailure/kSurfaceFailure if caller should
// fallback to software compositing.
gpu::ContextResult TryCreateContextsForGpuCompositing(
scoped_refptr<gpu::GpuChannelHost> gpu_channel_host);
const raw_ptr<gpu::GpuChannelEstablishFactory> gpu_channel_establish_factory_;
// Controls the compositing mode based on what mode the display compositors
// are using.
[[maybe_unused]] const raw_ptr<viz::CompositingModeReporterImpl>
compositing_mode_reporter_;
// ContextProvider used on worker threads for rasterization.
scoped_refptr<viz::RasterContextProvider> worker_context_provider_;
// ContextProvider used on the main thread. Shared by ui::Compositors.
scoped_refptr<viz::ContextProviderCommandBuffer> main_context_provider_;
std::unique_ptr<cc::SingleThreadTaskGraphRunner> task_graph_runner_;
base::flat_map<ui::Compositor*, CompositorData> compositor_data_map_;
viz::FrameSinkIdAllocator frame_sink_id_allocator_;
viz::SubtreeCaptureIdAllocator subtree_capture_id_allocator_;
const raw_ptr<viz::HostFrameSinkManager> host_frame_sink_manager_;
scoped_refptr<base::SingleThreadTaskRunner> const resize_task_runner_;
bool is_gpu_compositing_disabled_ = false;
base::WeakPtrFactory<VizProcessTransportFactory> weak_ptr_factory_{this};
};
} // namespace content
#endif // CONTENT_BROWSER_COMPOSITOR_VIZ_PROCESS_TRANSPORT_FACTORY_H_
|
