OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "services/ui/public/cpp/window_compositor_frame_sink.h" | 5 #include "services/ui/public/cpp/client_compositor_frame_sink.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/memory/ptr_util.h" | 8 #include "base/memory/ptr_util.h" |
9 #include "cc/output/compositor_frame.h" | 9 #include "cc/output/compositor_frame.h" |
10 #include "cc/output/compositor_frame_sink_client.h" | 10 #include "cc/output/compositor_frame_sink_client.h" |
11 | 11 |
12 namespace ui { | 12 namespace ui { |
13 | 13 |
14 // static | 14 // static |
15 std::unique_ptr<WindowCompositorFrameSink> WindowCompositorFrameSink::Create( | 15 std::unique_ptr<ClientCompositorFrameSink> ClientCompositorFrameSink::Create( |
16 const cc::FrameSinkId& frame_sink_id, | 16 const cc::FrameSinkId& frame_sink_id, |
17 scoped_refptr<cc::ContextProvider> context_provider, | 17 scoped_refptr<cc::ContextProvider> context_provider, |
18 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, | 18 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, |
19 std::unique_ptr<WindowCompositorFrameSinkBinding>* | 19 std::unique_ptr<ClientCompositorFrameSinkBinding>* |
20 compositor_frame_sink_binding) { | 20 compositor_frame_sink_binding) { |
21 cc::mojom::MojoCompositorFrameSinkPtr compositor_frame_sink; | 21 cc::mojom::MojoCompositorFrameSinkPtr compositor_frame_sink; |
22 cc::mojom::MojoCompositorFrameSinkClientPtr compositor_frame_sink_client; | 22 cc::mojom::MojoCompositorFrameSinkClientPtr compositor_frame_sink_client; |
23 cc::mojom::MojoCompositorFrameSinkClientRequest | 23 cc::mojom::MojoCompositorFrameSinkClientRequest |
24 compositor_frame_sink_client_request = | 24 compositor_frame_sink_client_request = |
25 MakeRequest(&compositor_frame_sink_client); | 25 MakeRequest(&compositor_frame_sink_client); |
26 | 26 |
27 compositor_frame_sink_binding->reset(new WindowCompositorFrameSinkBinding( | 27 compositor_frame_sink_binding->reset(new ClientCompositorFrameSinkBinding( |
28 MakeRequest(&compositor_frame_sink), | 28 MakeRequest(&compositor_frame_sink), |
29 compositor_frame_sink_client.PassInterface())); | 29 compositor_frame_sink_client.PassInterface())); |
30 return base::WrapUnique(new WindowCompositorFrameSink( | 30 return base::WrapUnique(new ClientCompositorFrameSink( |
31 frame_sink_id, std::move(context_provider), gpu_memory_buffer_manager, | 31 frame_sink_id, std::move(context_provider), gpu_memory_buffer_manager, |
32 compositor_frame_sink.PassInterface(), | 32 compositor_frame_sink.PassInterface(), |
33 std::move(compositor_frame_sink_client_request))); | 33 std::move(compositor_frame_sink_client_request))); |
34 } | 34 } |
35 | 35 |
36 WindowCompositorFrameSink::~WindowCompositorFrameSink() {} | 36 ClientCompositorFrameSink::~ClientCompositorFrameSink() {} |
37 | 37 |
38 bool WindowCompositorFrameSink::BindToClient( | 38 bool ClientCompositorFrameSink::BindToClient( |
39 cc::CompositorFrameSinkClient* client) { | 39 cc::CompositorFrameSinkClient* client) { |
40 if (!cc::CompositorFrameSink::BindToClient(client)) | 40 if (!cc::CompositorFrameSink::BindToClient(client)) |
41 return false; | 41 return false; |
42 | 42 |
43 DCHECK(!thread_checker_); | 43 DCHECK(!thread_checker_); |
44 thread_checker_.reset(new base::ThreadChecker()); | 44 thread_checker_.reset(new base::ThreadChecker()); |
45 compositor_frame_sink_.Bind(std::move(compositor_frame_sink_info_)); | 45 compositor_frame_sink_.Bind(std::move(compositor_frame_sink_info_)); |
46 client_binding_.reset( | 46 client_binding_.reset( |
47 new mojo::Binding<cc::mojom::MojoCompositorFrameSinkClient>( | 47 new mojo::Binding<cc::mojom::MojoCompositorFrameSinkClient>( |
48 this, std::move(client_request_))); | 48 this, std::move(client_request_))); |
49 | 49 |
50 begin_frame_source_ = base::MakeUnique<cc::ExternalBeginFrameSource>(this); | 50 begin_frame_source_ = base::MakeUnique<cc::ExternalBeginFrameSource>(this); |
51 | 51 |
52 client->SetBeginFrameSource(begin_frame_source_.get()); | 52 client->SetBeginFrameSource(begin_frame_source_.get()); |
53 return true; | 53 return true; |
54 } | 54 } |
55 | 55 |
56 void WindowCompositorFrameSink::DetachFromClient() { | 56 void ClientCompositorFrameSink::DetachFromClient() { |
57 client_->SetBeginFrameSource(nullptr); | 57 client_->SetBeginFrameSource(nullptr); |
58 begin_frame_source_.reset(); | 58 begin_frame_source_.reset(); |
59 client_binding_.reset(); | 59 client_binding_.reset(); |
60 compositor_frame_sink_.reset(); | 60 compositor_frame_sink_.reset(); |
61 cc::CompositorFrameSink::DetachFromClient(); | 61 cc::CompositorFrameSink::DetachFromClient(); |
62 } | 62 } |
63 | 63 |
64 void WindowCompositorFrameSink::SubmitCompositorFrame( | 64 void ClientCompositorFrameSink::SubmitCompositorFrame( |
65 cc::CompositorFrame frame) { | 65 cc::CompositorFrame frame) { |
66 DCHECK(thread_checker_); | 66 DCHECK(thread_checker_); |
67 DCHECK(thread_checker_->CalledOnValidThread()); | 67 DCHECK(thread_checker_->CalledOnValidThread()); |
68 if (!compositor_frame_sink_) | 68 if (!compositor_frame_sink_) |
69 return; | 69 return; |
70 | 70 |
71 gfx::Size frame_size = last_submitted_frame_size_; | 71 gfx::Size frame_size = last_submitted_frame_size_; |
72 if (!frame.render_pass_list.empty()) | 72 if (!frame.render_pass_list.empty()) |
73 frame_size = frame.render_pass_list.back()->output_rect.size(); | 73 frame_size = frame.render_pass_list.back()->output_rect.size(); |
74 if (!local_surface_id_.is_valid() || frame_size != last_submitted_frame_size_) | 74 if (!local_surface_id_.is_valid() || frame_size != last_submitted_frame_size_) |
75 local_surface_id_ = id_allocator_.GenerateId(); | 75 local_surface_id_ = id_allocator_.GenerateId(); |
76 | 76 |
77 compositor_frame_sink_->SubmitCompositorFrame(local_surface_id_, | 77 compositor_frame_sink_->SubmitCompositorFrame(local_surface_id_, |
78 std::move(frame)); | 78 std::move(frame)); |
79 | 79 |
80 last_submitted_frame_size_ = frame_size; | 80 last_submitted_frame_size_ = frame_size; |
81 } | 81 } |
82 | 82 |
83 WindowCompositorFrameSink::WindowCompositorFrameSink( | 83 ClientCompositorFrameSink::ClientCompositorFrameSink( |
84 const cc::FrameSinkId& frame_sink_id, | 84 const cc::FrameSinkId& frame_sink_id, |
85 scoped_refptr<cc::ContextProvider> context_provider, | 85 scoped_refptr<cc::ContextProvider> context_provider, |
86 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, | 86 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager, |
87 cc::mojom::MojoCompositorFrameSinkPtrInfo compositor_frame_sink_info, | 87 cc::mojom::MojoCompositorFrameSinkPtrInfo compositor_frame_sink_info, |
88 cc::mojom::MojoCompositorFrameSinkClientRequest client_request) | 88 cc::mojom::MojoCompositorFrameSinkClientRequest client_request) |
89 : cc::CompositorFrameSink(std::move(context_provider), | 89 : cc::CompositorFrameSink(std::move(context_provider), |
90 nullptr, | 90 nullptr, |
91 gpu_memory_buffer_manager, | 91 gpu_memory_buffer_manager, |
92 nullptr), | 92 nullptr), |
93 compositor_frame_sink_info_(std::move(compositor_frame_sink_info)), | 93 compositor_frame_sink_info_(std::move(compositor_frame_sink_info)), |
94 client_request_(std::move(client_request)), | 94 client_request_(std::move(client_request)), |
95 frame_sink_id_(frame_sink_id) {} | 95 frame_sink_id_(frame_sink_id) {} |
96 | 96 |
97 void WindowCompositorFrameSink::DidReceiveCompositorFrameAck() { | 97 void ClientCompositorFrameSink::DidReceiveCompositorFrameAck() { |
98 DCHECK(thread_checker_); | 98 DCHECK(thread_checker_); |
99 DCHECK(thread_checker_->CalledOnValidThread()); | 99 DCHECK(thread_checker_->CalledOnValidThread()); |
100 if (!client_) | 100 if (!client_) |
101 return; | 101 return; |
102 client_->DidReceiveCompositorFrameAck(); | 102 client_->DidReceiveCompositorFrameAck(); |
103 } | 103 } |
104 | 104 |
105 void WindowCompositorFrameSink::OnBeginFrame( | 105 void ClientCompositorFrameSink::OnBeginFrame( |
106 const cc::BeginFrameArgs& begin_frame_args) { | 106 const cc::BeginFrameArgs& begin_frame_args) { |
107 begin_frame_source_->OnBeginFrame(begin_frame_args); | 107 begin_frame_source_->OnBeginFrame(begin_frame_args); |
108 } | 108 } |
109 | 109 |
110 void WindowCompositorFrameSink::ReclaimResources( | 110 void ClientCompositorFrameSink::ReclaimResources( |
111 const cc::ReturnedResourceArray& resources) { | 111 const cc::ReturnedResourceArray& resources) { |
112 DCHECK(thread_checker_); | 112 DCHECK(thread_checker_); |
113 DCHECK(thread_checker_->CalledOnValidThread()); | 113 DCHECK(thread_checker_->CalledOnValidThread()); |
114 if (!client_) | 114 if (!client_) |
115 return; | 115 return; |
116 client_->ReclaimResources(resources); | 116 client_->ReclaimResources(resources); |
117 } | 117 } |
118 | 118 |
119 void WindowCompositorFrameSink::WillDrawSurface( | 119 void ClientCompositorFrameSink::WillDrawSurface( |
120 const cc::LocalSurfaceId& local_surface_id, | 120 const cc::LocalSurfaceId& local_surface_id, |
121 const gfx::Rect& damage_rect) { | 121 const gfx::Rect& damage_rect) { |
122 // TODO(fsamuel, staraz): Implement this. | 122 // TODO(fsamuel, staraz): Implement this. |
123 } | 123 } |
124 | 124 |
125 void WindowCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) { | 125 void ClientCompositorFrameSink::OnNeedsBeginFrames(bool needs_begin_frames) { |
126 compositor_frame_sink_->SetNeedsBeginFrame(needs_begin_frames); | 126 compositor_frame_sink_->SetNeedsBeginFrame(needs_begin_frames); |
127 } | 127 } |
128 | 128 |
129 void WindowCompositorFrameSink::OnDidFinishFrame(const cc::BeginFrameAck& ack) { | 129 void ClientCompositorFrameSink::OnDidFinishFrame(const cc::BeginFrameAck& ack) { |
130 // TODO(eseckler): Pass on the ack to compositor_frame_sink_. | 130 // TODO(eseckler): Pass on the ack to compositor_frame_sink_. |
131 } | 131 } |
132 | 132 |
133 WindowCompositorFrameSinkBinding::~WindowCompositorFrameSinkBinding() {} | 133 ClientCompositorFrameSinkBinding::~ClientCompositorFrameSinkBinding() {} |
134 | 134 |
135 WindowCompositorFrameSinkBinding::WindowCompositorFrameSinkBinding( | 135 ClientCompositorFrameSinkBinding::ClientCompositorFrameSinkBinding( |
136 cc::mojom::MojoCompositorFrameSinkRequest compositor_frame_sink_request, | 136 cc::mojom::MojoCompositorFrameSinkRequest compositor_frame_sink_request, |
137 cc::mojom::MojoCompositorFrameSinkClientPtrInfo | 137 cc::mojom::MojoCompositorFrameSinkClientPtrInfo |
138 compositor_frame_sink_client) | 138 compositor_frame_sink_client) |
139 : compositor_frame_sink_request_(std::move(compositor_frame_sink_request)), | 139 : compositor_frame_sink_request_(std::move(compositor_frame_sink_request)), |
140 compositor_frame_sink_client_(std::move(compositor_frame_sink_client)) {} | 140 compositor_frame_sink_client_(std::move(compositor_frame_sink_client)) {} |
141 | 141 |
142 cc::mojom::MojoCompositorFrameSinkRequest | 142 cc::mojom::MojoCompositorFrameSinkRequest |
143 WindowCompositorFrameSinkBinding::TakeFrameSinkRequest() { | 143 ClientCompositorFrameSinkBinding::TakeFrameSinkRequest() { |
144 return std::move(compositor_frame_sink_request_); | 144 return std::move(compositor_frame_sink_request_); |
145 } | 145 } |
146 | 146 |
147 cc::mojom::MojoCompositorFrameSinkClientPtrInfo | 147 cc::mojom::MojoCompositorFrameSinkClientPtrInfo |
148 WindowCompositorFrameSinkBinding::TakeFrameSinkClient() { | 148 ClientCompositorFrameSinkBinding::TakeFrameSinkClient() { |
149 return std::move(compositor_frame_sink_client_); | 149 return std::move(compositor_frame_sink_client_); |
150 } | 150 } |
151 | 151 |
152 } // namespace ui | 152 } // namespace ui |
OLD | NEW |