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 "ui/compositor/test/in_process_context_factory.h" | 5 #include "ui/compositor/test/in_process_context_factory.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/command_line.h" | 10 #include "base/command_line.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 #include "gpu/command_buffer/client/context_support.h" | 25 #include "gpu/command_buffer/client/context_support.h" |
26 #include "gpu/command_buffer/client/gles2_interface.h" | 26 #include "gpu/command_buffer/client/gles2_interface.h" |
27 #include "gpu/command_buffer/common/gles2_cmd_utils.h" | 27 #include "gpu/command_buffer/common/gles2_cmd_utils.h" |
28 #include "ui/compositor/compositor_switches.h" | 28 #include "ui/compositor/compositor_switches.h" |
29 #include "ui/compositor/layer.h" | 29 #include "ui/compositor/layer.h" |
30 #include "ui/compositor/reflector.h" | 30 #include "ui/compositor/reflector.h" |
31 #include "ui/compositor/test/in_process_context_provider.h" | 31 #include "ui/compositor/test/in_process_context_provider.h" |
32 #include "ui/gl/gl_implementation.h" | 32 #include "ui/gl/gl_implementation.h" |
33 #include "ui/gl/test/gl_surface_test_support.h" | 33 #include "ui/gl/test/gl_surface_test_support.h" |
34 | 34 |
| 35 #if !defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW) |
| 36 #include "gpu/ipc/common/gpu_surface_tracker.h" |
| 37 #endif |
| 38 |
35 namespace ui { | 39 namespace ui { |
36 namespace { | 40 namespace { |
37 | 41 |
38 class FakeReflector : public Reflector { | 42 class FakeReflector : public Reflector { |
39 public: | 43 public: |
40 FakeReflector() {} | 44 FakeReflector() {} |
41 ~FakeReflector() override {} | 45 ~FakeReflector() override {} |
42 void OnMirroringCompositorResized() override {} | 46 void OnMirroringCompositorResized() override {} |
43 void AddMirroringLayer(Layer* layer) override {} | 47 void AddMirroringLayer(Layer* layer) override {} |
44 void RemoveMirroringLayer(Layer* layer) override {} | 48 void RemoveMirroringLayer(Layer* layer) override {} |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
106 void OnSwapBuffersComplete() { client_->DidReceiveSwapBuffersAck(); } | 110 void OnSwapBuffersComplete() { client_->DidReceiveSwapBuffersAck(); } |
107 | 111 |
108 cc::OutputSurfaceClient* client_ = nullptr; | 112 cc::OutputSurfaceClient* client_ = nullptr; |
109 base::WeakPtrFactory<DirectOutputSurface> weak_ptr_factory_; | 113 base::WeakPtrFactory<DirectOutputSurface> weak_ptr_factory_; |
110 | 114 |
111 DISALLOW_COPY_AND_ASSIGN(DirectOutputSurface); | 115 DISALLOW_COPY_AND_ASSIGN(DirectOutputSurface); |
112 }; | 116 }; |
113 | 117 |
114 } // namespace | 118 } // namespace |
115 | 119 |
| 120 struct InProcessContextFactory::PerCompositorData { |
| 121 gpu::SurfaceHandle surface_handle = gpu::kNullSurfaceHandle; |
| 122 std::unique_ptr<cc::Display> display; |
| 123 }; |
| 124 |
116 InProcessContextFactory::InProcessContextFactory( | 125 InProcessContextFactory::InProcessContextFactory( |
117 bool context_factory_for_test, | 126 bool context_factory_for_test, |
118 cc::SurfaceManager* surface_manager) | 127 cc::SurfaceManager* surface_manager) |
119 : next_surface_client_id_(1u), | 128 : next_surface_client_id_(1u), |
120 use_test_surface_(true), | 129 use_test_surface_(true), |
121 context_factory_for_test_(context_factory_for_test), | 130 context_factory_for_test_(context_factory_for_test), |
122 surface_manager_(surface_manager) { | 131 surface_manager_(surface_manager) { |
123 DCHECK(surface_manager); | 132 DCHECK(surface_manager); |
124 DCHECK_NE(gl::GetGLImplementation(), gl::kGLImplementationNone) | 133 DCHECK_NE(gl::GetGLImplementation(), gl::kGLImplementationNone) |
125 << "If running tests, ensure that main() is calling " | 134 << "If running tests, ensure that main() is calling " |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
159 attribs.alpha_size = 8; | 168 attribs.alpha_size = 8; |
160 attribs.blue_size = 8; | 169 attribs.blue_size = 8; |
161 attribs.green_size = 8; | 170 attribs.green_size = 8; |
162 attribs.red_size = 8; | 171 attribs.red_size = 8; |
163 attribs.depth_size = 0; | 172 attribs.depth_size = 0; |
164 attribs.stencil_size = 0; | 173 attribs.stencil_size = 0; |
165 attribs.samples = 0; | 174 attribs.samples = 0; |
166 attribs.sample_buffers = 0; | 175 attribs.sample_buffers = 0; |
167 attribs.fail_if_major_perf_caveat = false; | 176 attribs.fail_if_major_perf_caveat = false; |
168 attribs.bind_generates_resource = false; | 177 attribs.bind_generates_resource = false; |
| 178 PerCompositorData* data = per_compositor_data_[compositor.get()].get(); |
| 179 if (!data) |
| 180 data = CreatePerCompositorData(compositor.get()); |
| 181 |
169 scoped_refptr<InProcessContextProvider> context_provider = | 182 scoped_refptr<InProcessContextProvider> context_provider = |
170 InProcessContextProvider::Create( | 183 InProcessContextProvider::Create( |
171 attribs, shared_worker_context_provider_.get(), | 184 attribs, shared_worker_context_provider_.get(), |
172 &gpu_memory_buffer_manager_, &image_factory_, compositor->widget(), | 185 &gpu_memory_buffer_manager_, &image_factory_, data->surface_handle, |
173 "UICompositor"); | 186 "UICompositor"); |
174 | 187 |
175 std::unique_ptr<cc::OutputSurface> display_output_surface; | 188 std::unique_ptr<cc::OutputSurface> display_output_surface; |
176 if (use_test_surface_) { | 189 if (use_test_surface_) { |
177 bool flipped_output_surface = false; | 190 bool flipped_output_surface = false; |
178 display_output_surface = base::MakeUnique<cc::PixelTestOutputSurface>( | 191 display_output_surface = base::MakeUnique<cc::PixelTestOutputSurface>( |
179 context_provider, flipped_output_surface); | 192 context_provider, flipped_output_surface); |
180 } else { | 193 } else { |
181 display_output_surface = | 194 display_output_surface = |
182 base::MakeUnique<DirectOutputSurface>(context_provider); | 195 base::MakeUnique<DirectOutputSurface>(context_provider); |
183 } | 196 } |
184 | 197 |
185 std::unique_ptr<cc::DelayBasedBeginFrameSource> begin_frame_source( | 198 std::unique_ptr<cc::DelayBasedBeginFrameSource> begin_frame_source( |
186 new cc::DelayBasedBeginFrameSource( | 199 new cc::DelayBasedBeginFrameSource( |
187 base::MakeUnique<cc::DelayBasedTimeSource>( | 200 base::MakeUnique<cc::DelayBasedTimeSource>( |
188 compositor->task_runner().get()))); | 201 compositor->task_runner().get()))); |
189 std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler( | 202 std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler( |
190 begin_frame_source.get(), compositor->task_runner().get(), | 203 begin_frame_source.get(), compositor->task_runner().get(), |
191 display_output_surface->capabilities().max_frames_pending)); | 204 display_output_surface->capabilities().max_frames_pending)); |
192 per_compositor_data_[compositor.get()] = base::MakeUnique<cc::Display>( | 205 |
| 206 data->display = base::MakeUnique<cc::Display>( |
193 &shared_bitmap_manager_, &gpu_memory_buffer_manager_, | 207 &shared_bitmap_manager_, &gpu_memory_buffer_manager_, |
194 compositor->GetRendererSettings(), compositor->frame_sink_id(), | 208 compositor->GetRendererSettings(), compositor->frame_sink_id(), |
195 std::move(begin_frame_source), std::move(display_output_surface), | 209 std::move(begin_frame_source), std::move(display_output_surface), |
196 std::move(scheduler), base::MakeUnique<cc::TextureMailboxDeleter>( | 210 std::move(scheduler), base::MakeUnique<cc::TextureMailboxDeleter>( |
197 compositor->task_runner().get())); | 211 compositor->task_runner().get())); |
198 | 212 |
199 auto* display = per_compositor_data_[compositor.get()].get(); | 213 auto* display = per_compositor_data_[compositor.get()]->display.get(); |
200 auto compositor_frame_sink = base::MakeUnique<cc::DirectCompositorFrameSink>( | 214 auto compositor_frame_sink = base::MakeUnique<cc::DirectCompositorFrameSink>( |
201 compositor->frame_sink_id(), surface_manager_, display, context_provider, | 215 compositor->frame_sink_id(), surface_manager_, display, context_provider, |
202 shared_worker_context_provider_, &gpu_memory_buffer_manager_, | 216 shared_worker_context_provider_, &gpu_memory_buffer_manager_, |
203 &shared_bitmap_manager_); | 217 &shared_bitmap_manager_); |
204 compositor->SetCompositorFrameSink(std::move(compositor_frame_sink)); | 218 compositor->SetCompositorFrameSink(std::move(compositor_frame_sink)); |
205 } | 219 } |
206 | 220 |
207 std::unique_ptr<Reflector> InProcessContextFactory::CreateReflector( | 221 std::unique_ptr<Reflector> InProcessContextFactory::CreateReflector( |
208 Compositor* mirrored_compositor, | 222 Compositor* mirrored_compositor, |
209 Layer* mirroring_layer) { | 223 Layer* mirroring_layer) { |
(...skipping 13 matching lines...) Expand all Loading... |
223 shared_main_thread_contexts_ = InProcessContextProvider::CreateOffscreen( | 237 shared_main_thread_contexts_ = InProcessContextProvider::CreateOffscreen( |
224 &gpu_memory_buffer_manager_, &image_factory_, nullptr); | 238 &gpu_memory_buffer_manager_, &image_factory_, nullptr); |
225 if (shared_main_thread_contexts_.get() && | 239 if (shared_main_thread_contexts_.get() && |
226 !shared_main_thread_contexts_->BindToCurrentThread()) | 240 !shared_main_thread_contexts_->BindToCurrentThread()) |
227 shared_main_thread_contexts_ = NULL; | 241 shared_main_thread_contexts_ = NULL; |
228 | 242 |
229 return shared_main_thread_contexts_; | 243 return shared_main_thread_contexts_; |
230 } | 244 } |
231 | 245 |
232 void InProcessContextFactory::RemoveCompositor(Compositor* compositor) { | 246 void InProcessContextFactory::RemoveCompositor(Compositor* compositor) { |
233 if (!per_compositor_data_.count(compositor)) | 247 PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor); |
| 248 if (it == per_compositor_data_.end()) |
234 return; | 249 return; |
235 per_compositor_data_.erase(compositor); | 250 PerCompositorData* data = it->second.get(); |
| 251 DCHECK(data); |
| 252 #if !defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW) |
| 253 if (data->surface_handle) |
| 254 gpu::GpuSurfaceTracker::Get()->RemoveSurface(data->surface_handle); |
| 255 #endif |
| 256 per_compositor_data_.erase(it); |
236 } | 257 } |
237 | 258 |
238 bool InProcessContextFactory::DoesCreateTestContexts() { | 259 bool InProcessContextFactory::DoesCreateTestContexts() { |
239 return context_factory_for_test_; | 260 return context_factory_for_test_; |
240 } | 261 } |
241 | 262 |
242 uint32_t InProcessContextFactory::GetImageTextureTarget( | 263 uint32_t InProcessContextFactory::GetImageTextureTarget( |
243 gfx::BufferFormat format, | 264 gfx::BufferFormat format, |
244 gfx::BufferUsage usage) { | 265 gfx::BufferUsage usage) { |
245 return GL_TEXTURE_2D; | 266 return GL_TEXTURE_2D; |
(...skipping 13 matching lines...) Expand all Loading... |
259 } | 280 } |
260 | 281 |
261 cc::SurfaceManager* InProcessContextFactory::GetSurfaceManager() { | 282 cc::SurfaceManager* InProcessContextFactory::GetSurfaceManager() { |
262 return surface_manager_; | 283 return surface_manager_; |
263 } | 284 } |
264 | 285 |
265 void InProcessContextFactory::SetDisplayVisible(ui::Compositor* compositor, | 286 void InProcessContextFactory::SetDisplayVisible(ui::Compositor* compositor, |
266 bool visible) { | 287 bool visible) { |
267 if (!per_compositor_data_.count(compositor)) | 288 if (!per_compositor_data_.count(compositor)) |
268 return; | 289 return; |
269 per_compositor_data_[compositor]->SetVisible(visible); | 290 per_compositor_data_[compositor]->display->SetVisible(visible); |
270 } | 291 } |
271 | 292 |
272 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor, | 293 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor, |
273 const gfx::Size& size) { | 294 const gfx::Size& size) { |
274 if (!per_compositor_data_.count(compositor)) | 295 if (!per_compositor_data_.count(compositor)) |
275 return; | 296 return; |
276 per_compositor_data_[compositor]->Resize(size); | 297 per_compositor_data_[compositor]->display->Resize(size); |
277 } | 298 } |
278 | 299 |
279 void InProcessContextFactory::AddObserver(ContextFactoryObserver* observer) { | 300 void InProcessContextFactory::AddObserver(ContextFactoryObserver* observer) { |
280 observer_list_.AddObserver(observer); | 301 observer_list_.AddObserver(observer); |
281 } | 302 } |
282 | 303 |
283 void InProcessContextFactory::RemoveObserver(ContextFactoryObserver* observer) { | 304 void InProcessContextFactory::RemoveObserver(ContextFactoryObserver* observer) { |
284 observer_list_.RemoveObserver(observer); | 305 observer_list_.RemoveObserver(observer); |
285 } | 306 } |
286 | 307 |
| 308 InProcessContextFactory::PerCompositorData* |
| 309 InProcessContextFactory::CreatePerCompositorData(ui::Compositor* compositor) { |
| 310 DCHECK(!per_compositor_data_[compositor]); |
| 311 |
| 312 gfx::AcceleratedWidget widget = compositor->widget(); |
| 313 |
| 314 auto data = base::MakeUnique<PerCompositorData>(); |
| 315 if (widget == gfx::kNullAcceleratedWidget) { |
| 316 data->surface_handle = gpu::kNullSurfaceHandle; |
| 317 } else { |
| 318 #if defined(GPU_SURFACE_HANDLE_IS_ACCELERATED_WINDOW) |
| 319 data->surface_handle = widget; |
| 320 #else |
| 321 gpu::GpuSurfaceTracker* tracker = gpu::GpuSurfaceTracker::Get(); |
| 322 data->surface_handle = tracker->AddSurfaceForNativeWidget(widget); |
| 323 #endif |
| 324 } |
| 325 |
| 326 PerCompositorData* return_ptr = data.get(); |
| 327 per_compositor_data_[compositor] = std::move(data); |
| 328 return return_ptr; |
| 329 } |
| 330 |
287 } // namespace ui | 331 } // namespace ui |
OLD | NEW |