OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/gpu/renderer_compositor_frame_sink.h" | 5 #include "content/renderer/gpu/renderer_compositor_frame_sink.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/command_line.h" | 9 #include "base/command_line.h" |
10 #include "base/location.h" | 10 #include "base/location.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 #include "gpu/command_buffer/client/context_support.h" | 21 #include "gpu/command_buffer/client/context_support.h" |
22 #include "gpu/command_buffer/client/gles2_interface.h" | 22 #include "gpu/command_buffer/client/gles2_interface.h" |
23 #include "gpu/ipc/client/command_buffer_proxy_impl.h" | 23 #include "gpu/ipc/client/command_buffer_proxy_impl.h" |
24 #include "ipc/ipc_sync_channel.h" | 24 #include "ipc/ipc_sync_channel.h" |
25 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.h" | 25 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.h" |
26 | 26 |
27 namespace content { | 27 namespace content { |
28 | 28 |
29 RendererCompositorFrameSink::RendererCompositorFrameSink( | 29 RendererCompositorFrameSink::RendererCompositorFrameSink( |
30 int32_t routing_id, | 30 int32_t routing_id, |
| 31 uint32_t compositor_frame_sink_id, |
31 std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source, | 32 std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source, |
32 scoped_refptr<cc::ContextProvider> context_provider, | 33 scoped_refptr<cc::ContextProvider> context_provider, |
33 scoped_refptr<cc::ContextProvider> worker_context_provider, | 34 scoped_refptr<cc::ContextProvider> worker_context_provider, |
34 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, | 35 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, |
35 cc::SharedBitmapManager* shared_bitmap_manager, | 36 cc::SharedBitmapManager* shared_bitmap_manager, |
36 scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue) | 37 scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue) |
37 : CompositorFrameSink(std::move(context_provider), | 38 : CompositorFrameSink(std::move(context_provider), |
38 std::move(worker_context_provider), | 39 std::move(worker_context_provider), |
39 gpu_memory_buffer_manager, | 40 gpu_memory_buffer_manager, |
40 shared_bitmap_manager), | 41 shared_bitmap_manager), |
| 42 compositor_frame_sink_id_(compositor_frame_sink_id), |
41 compositor_frame_sink_filter_( | 43 compositor_frame_sink_filter_( |
42 RenderThreadImpl::current()->compositor_message_filter()), | 44 RenderThreadImpl::current()->compositor_message_filter()), |
43 message_sender_(RenderThreadImpl::current()->sync_message_filter()), | 45 message_sender_(RenderThreadImpl::current()->sync_message_filter()), |
44 frame_swap_message_queue_(swap_frame_message_queue), | 46 frame_swap_message_queue_(swap_frame_message_queue), |
45 synthetic_begin_frame_source_(std::move(synthetic_begin_frame_source)), | 47 synthetic_begin_frame_source_(std::move(synthetic_begin_frame_source)), |
46 external_begin_frame_source_( | 48 external_begin_frame_source_( |
47 synthetic_begin_frame_source_ | 49 synthetic_begin_frame_source_ |
48 ? nullptr | 50 ? nullptr |
49 : base::MakeUnique<cc::ExternalBeginFrameSource>(this)), | 51 : base::MakeUnique<cc::ExternalBeginFrameSource>(this)), |
50 routing_id_(routing_id), | 52 routing_id_(routing_id) { |
51 sink_client_binding_(this) { | |
52 DCHECK(compositor_frame_sink_filter_); | 53 DCHECK(compositor_frame_sink_filter_); |
53 DCHECK(frame_swap_message_queue_); | 54 DCHECK(frame_swap_message_queue_); |
54 DCHECK(message_sender_); | 55 DCHECK(message_sender_); |
55 thread_checker_.DetachFromThread(); | 56 thread_checker_.DetachFromThread(); |
56 EstablishMojoConnection(); | |
57 } | 57 } |
58 | 58 |
59 RendererCompositorFrameSink::RendererCompositorFrameSink( | 59 RendererCompositorFrameSink::RendererCompositorFrameSink( |
60 int32_t routing_id, | 60 int32_t routing_id, |
| 61 uint32_t compositor_frame_sink_id, |
61 std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source, | 62 std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source, |
62 scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider, | 63 scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider, |
63 scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue) | 64 scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue) |
64 : CompositorFrameSink(std::move(vulkan_context_provider)), | 65 : CompositorFrameSink(std::move(vulkan_context_provider)), |
| 66 compositor_frame_sink_id_(compositor_frame_sink_id), |
65 compositor_frame_sink_filter_( | 67 compositor_frame_sink_filter_( |
66 RenderThreadImpl::current()->compositor_message_filter()), | 68 RenderThreadImpl::current()->compositor_message_filter()), |
67 message_sender_(RenderThreadImpl::current()->sync_message_filter()), | 69 message_sender_(RenderThreadImpl::current()->sync_message_filter()), |
68 frame_swap_message_queue_(swap_frame_message_queue), | 70 frame_swap_message_queue_(swap_frame_message_queue), |
69 synthetic_begin_frame_source_(std::move(synthetic_begin_frame_source)), | 71 synthetic_begin_frame_source_(std::move(synthetic_begin_frame_source)), |
70 external_begin_frame_source_( | 72 external_begin_frame_source_( |
71 synthetic_begin_frame_source_ | 73 synthetic_begin_frame_source_ |
72 ? nullptr | 74 ? nullptr |
73 : base::MakeUnique<cc::ExternalBeginFrameSource>(this)), | 75 : base::MakeUnique<cc::ExternalBeginFrameSource>(this)), |
74 routing_id_(routing_id), | 76 routing_id_(routing_id) { |
75 sink_client_binding_(this) { | |
76 DCHECK(compositor_frame_sink_filter_); | 77 DCHECK(compositor_frame_sink_filter_); |
77 DCHECK(frame_swap_message_queue_); | 78 DCHECK(frame_swap_message_queue_); |
78 DCHECK(message_sender_); | 79 DCHECK(message_sender_); |
79 thread_checker_.DetachFromThread(); | 80 thread_checker_.DetachFromThread(); |
80 EstablishMojoConnection(); | |
81 } | 81 } |
82 | 82 |
83 RendererCompositorFrameSink::~RendererCompositorFrameSink() { | 83 RendererCompositorFrameSink::~RendererCompositorFrameSink() { |
84 // TODO(crbug.com/702764): If not detached then IPC messages would crash | 84 // TODO(crbug.com/702764): If not detached then IPC messages would crash |
85 // after this class is destroyed. | 85 // after this class is destroyed. |
86 CHECK(!bound_); | 86 CHECK(!bound_); |
87 } | 87 } |
88 | 88 |
89 bool RendererCompositorFrameSink::BindToClient( | 89 bool RendererCompositorFrameSink::BindToClient( |
90 cc::CompositorFrameSinkClient* client) { | 90 cc::CompositorFrameSinkClient* client) { |
91 DCHECK(thread_checker_.CalledOnValidThread()); | 91 DCHECK(thread_checker_.CalledOnValidThread()); |
92 if (!cc::CompositorFrameSink::BindToClient(client)) | 92 if (!cc::CompositorFrameSink::BindToClient(client)) |
93 return false; | 93 return false; |
94 | 94 |
95 sink_.Bind(std::move(sink_ptr_info_)); | |
96 sink_client_binding_.Bind(std::move(sink_client_request_)); | |
97 | |
98 if (synthetic_begin_frame_source_) | 95 if (synthetic_begin_frame_source_) |
99 client_->SetBeginFrameSource(synthetic_begin_frame_source_.get()); | 96 client_->SetBeginFrameSource(synthetic_begin_frame_source_.get()); |
100 else | 97 else |
101 client_->SetBeginFrameSource(external_begin_frame_source_.get()); | 98 client_->SetBeginFrameSource(external_begin_frame_source_.get()); |
102 | 99 |
103 compositor_frame_sink_proxy_ = new RendererCompositorFrameSinkProxy(this); | 100 compositor_frame_sink_proxy_ = new RendererCompositorFrameSinkProxy(this); |
104 compositor_frame_sink_filter_handler_ = | 101 compositor_frame_sink_filter_handler_ = |
105 base::Bind(&RendererCompositorFrameSinkProxy::OnMessageReceived, | 102 base::Bind(&RendererCompositorFrameSinkProxy::OnMessageReceived, |
106 compositor_frame_sink_proxy_); | 103 compositor_frame_sink_proxy_); |
107 compositor_frame_sink_filter_->AddHandlerOnCompositorThread( | 104 compositor_frame_sink_filter_->AddHandlerOnCompositorThread( |
108 routing_id_, compositor_frame_sink_filter_handler_); | 105 routing_id_, compositor_frame_sink_filter_handler_); |
109 | |
110 bound_ = true; | 106 bound_ = true; |
111 return true; | 107 return true; |
112 } | 108 } |
113 | 109 |
114 void RendererCompositorFrameSink::DetachFromClient() { | 110 void RendererCompositorFrameSink::DetachFromClient() { |
115 DCHECK(thread_checker_.CalledOnValidThread()); | 111 DCHECK(thread_checker_.CalledOnValidThread()); |
116 client_->SetBeginFrameSource(nullptr); | 112 client_->SetBeginFrameSource(nullptr); |
117 // Destroy the begin frame source on the same thread it was bound on. | 113 // Destroy the begin frame source on the same thread it was bound on. |
118 // The CompositorFrameSink itself is destroyed on the main thread. | 114 // The CompositorFrameSink itself is destroyed on the main thread. |
119 external_begin_frame_source_ = nullptr; | 115 external_begin_frame_source_ = nullptr; |
120 synthetic_begin_frame_source_ = nullptr; | 116 synthetic_begin_frame_source_ = nullptr; |
121 compositor_frame_sink_proxy_->ClearCompositorFrameSink(); | 117 compositor_frame_sink_proxy_->ClearCompositorFrameSink(); |
122 compositor_frame_sink_filter_->RemoveHandlerOnCompositorThread( | 118 compositor_frame_sink_filter_->RemoveHandlerOnCompositorThread( |
123 routing_id_, compositor_frame_sink_filter_handler_); | 119 routing_id_, compositor_frame_sink_filter_handler_); |
124 sink_.reset(); | 120 |
125 sink_client_binding_.Close(); | |
126 cc::CompositorFrameSink::DetachFromClient(); | 121 cc::CompositorFrameSink::DetachFromClient(); |
127 bound_ = false; | 122 bound_ = false; |
128 } | 123 } |
129 | 124 |
130 void RendererCompositorFrameSink::SubmitCompositorFrame( | 125 void RendererCompositorFrameSink::SubmitCompositorFrame( |
131 cc::CompositorFrame frame) { | 126 cc::CompositorFrame frame) { |
132 // We should only submit CompositorFrames with valid BeginFrameAcks. | 127 // We should only submit CompositorFrames with valid BeginFrameAcks. |
133 DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, | 128 DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, |
134 frame.metadata.begin_frame_ack.sequence_number); | 129 frame.metadata.begin_frame_ack.sequence_number); |
135 if (ShouldAllocateNewLocalSurfaceId(frame)) | 130 if (ShouldAllocateNewLocalSurfaceId(frame)) |
136 local_surface_id_ = id_allocator_.GenerateId(); | 131 local_surface_id_ = id_allocator_.GenerateId(); |
137 UpdateFrameData(frame); | 132 UpdateFrameData(frame); |
138 | 133 |
139 { | 134 { |
140 std::unique_ptr<FrameSwapMessageQueue::SendMessageScope> | 135 std::unique_ptr<FrameSwapMessageQueue::SendMessageScope> |
141 send_message_scope = | 136 send_message_scope = |
142 frame_swap_message_queue_->AcquireSendMessageScope(); | 137 frame_swap_message_queue_->AcquireSendMessageScope(); |
143 std::vector<std::unique_ptr<IPC::Message>> messages; | 138 std::vector<std::unique_ptr<IPC::Message>> messages; |
144 frame_swap_message_queue_->DrainMessages(&messages); | 139 frame_swap_message_queue_->DrainMessages(&messages); |
145 std::vector<IPC::Message> messages_to_send; | 140 std::vector<IPC::Message> messages_to_send; |
146 FrameSwapMessageQueue::TransferMessages(&messages, &messages_to_send); | 141 FrameSwapMessageQueue::TransferMessages(&messages, &messages_to_send); |
147 uint32_t frame_token = 0; | 142 uint32_t frame_token = 0; |
148 if (!messages_to_send.empty()) | 143 if (!messages_to_send.empty()) |
149 frame_token = frame_swap_message_queue_->AllocateFrameToken(); | 144 frame_token = frame_swap_message_queue_->AllocateFrameToken(); |
150 frame.metadata.frame_token = frame_token; | 145 frame.metadata.frame_token = frame_token; |
151 sink_->SubmitCompositorFrame(local_surface_id_, std::move(frame)); | 146 Send(new ViewHostMsg_SwapCompositorFrame( |
| 147 routing_id_, compositor_frame_sink_id_, local_surface_id_, frame)); |
152 if (frame_token) { | 148 if (frame_token) { |
153 message_sender_->Send(new ViewHostMsg_FrameSwapMessages( | 149 Send(new ViewHostMsg_FrameSwapMessages(routing_id_, frame_token, |
154 routing_id_, frame_token, messages_to_send)); | 150 messages_to_send)); |
155 } | 151 } |
156 // ~send_message_scope. | 152 // ~send_message_scope. |
157 } | 153 } |
158 } | 154 } |
159 | 155 |
160 void RendererCompositorFrameSink::OnMessageReceived( | 156 void RendererCompositorFrameSink::OnMessageReceived( |
161 const IPC::Message& message) { | 157 const IPC::Message& message) { |
162 DCHECK(thread_checker_.CalledOnValidThread()); | 158 DCHECK(thread_checker_.CalledOnValidThread()); |
163 IPC_BEGIN_MESSAGE_MAP(RendererCompositorFrameSink, message) | 159 IPC_BEGIN_MESSAGE_MAP(RendererCompositorFrameSink, message) |
164 IPC_MESSAGE_HANDLER(ViewMsg_BeginFrame, OnBeginFrameIPC) | 160 IPC_MESSAGE_HANDLER(ViewMsg_ReclaimCompositorResources, |
| 161 OnReclaimCompositorResources) |
| 162 IPC_MESSAGE_HANDLER(ViewMsg_SetBeginFramePaused, |
| 163 OnSetBeginFrameSourcePaused) |
| 164 IPC_MESSAGE_HANDLER(ViewMsg_BeginFrame, OnBeginFrame) |
165 IPC_END_MESSAGE_MAP() | 165 IPC_END_MESSAGE_MAP() |
166 } | 166 } |
167 | 167 |
168 void RendererCompositorFrameSink::OnBeginFrameIPC( | 168 void RendererCompositorFrameSink::OnReclaimCompositorResources( |
169 const cc::BeginFrameArgs& args) { | 169 uint32_t compositor_frame_sink_id, |
| 170 bool is_swap_ack, |
| 171 const cc::ReturnedResourceArray& resources) { |
| 172 // Ignore message if it's a stale one coming from a different output surface |
| 173 // (e.g. after a lost context). |
| 174 if (compositor_frame_sink_id != compositor_frame_sink_id_) |
| 175 return; |
| 176 client_->ReclaimResources(resources); |
| 177 if (is_swap_ack) |
| 178 client_->DidReceiveCompositorFrameAck(); |
| 179 } |
| 180 |
| 181 void RendererCompositorFrameSink::OnSetBeginFrameSourcePaused(bool paused) { |
| 182 if (external_begin_frame_source_) |
| 183 external_begin_frame_source_->OnSetBeginFrameSourcePaused(paused); |
| 184 } |
| 185 |
| 186 void RendererCompositorFrameSink::OnBeginFrame(const cc::BeginFrameArgs& args) { |
170 if (external_begin_frame_source_) | 187 if (external_begin_frame_source_) |
171 external_begin_frame_source_->OnBeginFrame(args); | 188 external_begin_frame_source_->OnBeginFrame(args); |
172 } | 189 } |
173 | 190 |
| 191 bool RendererCompositorFrameSink::Send(IPC::Message* message) { |
| 192 return message_sender_->Send(message); |
| 193 } |
| 194 |
174 bool RendererCompositorFrameSink::ShouldAllocateNewLocalSurfaceId( | 195 bool RendererCompositorFrameSink::ShouldAllocateNewLocalSurfaceId( |
175 const cc::CompositorFrame& frame) { | 196 const cc::CompositorFrame& frame) { |
176 cc::RenderPass* root_pass = frame.render_pass_list.back().get(); | 197 cc::RenderPass* root_pass = frame.render_pass_list.back().get(); |
177 gfx::Size frame_size = root_pass->output_rect.size(); | 198 gfx::Size frame_size = root_pass->output_rect.size(); |
178 | 199 |
179 // Once the proposal in crbug.com/689754 is implemented, the LocalSurfaceId | 200 // Once the proposal in crbug.com/689754 is implemented, the LocalSurfaceId |
180 // allocation logic will be unified across all platforms. | 201 // allocation logic will be unified across all platforms. |
181 return !local_surface_id_.is_valid() || | 202 return !local_surface_id_.is_valid() || |
182 current_frame_data_.device_scale_factor != | 203 current_frame_data_.device_scale_factor != |
183 frame.metadata.device_scale_factor || | 204 frame.metadata.device_scale_factor || |
(...skipping 27 matching lines...) Expand all Loading... |
211 current_frame_data_.bottom_controls_height = | 232 current_frame_data_.bottom_controls_height = |
212 frame.metadata.bottom_controls_height; | 233 frame.metadata.bottom_controls_height; |
213 current_frame_data_.bottom_controls_shown_ratio = | 234 current_frame_data_.bottom_controls_shown_ratio = |
214 frame.metadata.bottom_controls_shown_ratio; | 235 frame.metadata.bottom_controls_shown_ratio; |
215 current_frame_data_.viewport_selection = frame.metadata.selection; | 236 current_frame_data_.viewport_selection = frame.metadata.selection; |
216 current_frame_data_.has_transparent_background = | 237 current_frame_data_.has_transparent_background = |
217 root_pass->has_transparent_background; | 238 root_pass->has_transparent_background; |
218 #endif | 239 #endif |
219 } | 240 } |
220 | 241 |
221 void RendererCompositorFrameSink::DidReceiveCompositorFrameAck( | |
222 const cc::ReturnedResourceArray& resources) { | |
223 ReclaimResources(resources); | |
224 client_->DidReceiveCompositorFrameAck(); | |
225 } | |
226 | |
227 void RendererCompositorFrameSink::OnBeginFrame(const cc::BeginFrameArgs& args) { | |
228 // See crbug.com/709689. | |
229 NOTREACHED() << "BeginFrames are delivered using Chrome IPC."; | |
230 } | |
231 | |
232 void RendererCompositorFrameSink::ReclaimResources( | |
233 const cc::ReturnedResourceArray& resources) { | |
234 client_->ReclaimResources(resources); | |
235 } | |
236 | |
237 void RendererCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) { | 242 void RendererCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) { |
238 sink_->SetNeedsBeginFrame(needs_begin_frames); | 243 Send(new ViewHostMsg_SetNeedsBeginFrames(routing_id_, needs_begin_frames)); |
239 } | 244 } |
240 | 245 |
241 void RendererCompositorFrameSink::OnDidFinishFrame( | 246 void RendererCompositorFrameSink::OnDidFinishFrame( |
242 const cc::BeginFrameAck& ack) { | 247 const cc::BeginFrameAck& ack) { |
243 DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, ack.sequence_number); | 248 DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, ack.sequence_number); |
244 // If there was damage, ViewHostMsg_SwapCompositorFrame includes the ack. | 249 // If there was damage, ViewHostMsg_SwapCompositorFrame includes the ack. |
245 if (!ack.has_damage) | 250 if (!ack.has_damage) |
246 sink_->BeginFrameDidNotSwap(ack); | 251 Send(new ViewHostMsg_BeginFrameDidNotSwap(routing_id_, ack)); |
247 } | |
248 | |
249 void RendererCompositorFrameSink::EstablishMojoConnection() { | |
250 cc::mojom::MojoCompositorFrameSinkPtr sink; | |
251 cc::mojom::MojoCompositorFrameSinkRequest sink_request = | |
252 mojo::MakeRequest(&sink); | |
253 cc::mojom::MojoCompositorFrameSinkClientPtr sink_client; | |
254 sink_client_request_ = mojo::MakeRequest(&sink_client); | |
255 RenderThreadImpl::current()->GetFrameSinkProvider()->CreateForWidget( | |
256 routing_id_, std::move(sink_request), std::move(sink_client)); | |
257 sink_ptr_info_ = sink.PassInterface(); | |
258 } | 252 } |
259 | 253 |
260 } // namespace content | 254 } // namespace content |
OLD | NEW |