OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 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 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_ | 5 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_ |
6 #define CC_RESOURCES_RESOURCE_PROVIDER_H_ | 6 #define CC_RESOURCES_RESOURCE_PROVIDER_H_ |
7 | 7 |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 #include <stdint.h> | 9 #include <stdint.h> |
10 | 10 |
(...skipping 198 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
209 const ReturnedResourceArray& transferable_resources); | 209 const ReturnedResourceArray& transferable_resources); |
210 | 210 |
211 // The following lock classes are part of the ResourceProvider API and are | 211 // The following lock classes are part of the ResourceProvider API and are |
212 // needed to read and write the resource contents. The user must ensure | 212 // needed to read and write the resource contents. The user must ensure |
213 // that they only use GL locks on GL resources, etc, and this is enforced | 213 // that they only use GL locks on GL resources, etc, and this is enforced |
214 // by assertions. | 214 // by assertions. |
215 class CC_EXPORT ScopedReadLockGL { | 215 class CC_EXPORT ScopedReadLockGL { |
216 public: | 216 public: |
217 ScopedReadLockGL(ResourceProvider* resource_provider, | 217 ScopedReadLockGL(ResourceProvider* resource_provider, |
218 ResourceId resource_id); | 218 ResourceId resource_id); |
219 virtual ~ScopedReadLockGL(); | 219 ~ScopedReadLockGL(); |
220 | 220 |
221 unsigned texture_id() const { return resource_->gl_id; } | 221 unsigned texture_id() const { return texture_id_; } |
222 GLenum target() const { return resource_->target; } | 222 GLenum target() const { return target_; } |
223 const gfx::Size& texture_size() const { return resource_->size; } | 223 const gfx::Size& size() const { return size_; } |
224 | 224 |
225 protected: | 225 private: |
226 ResourceProvider* resource_provider_; | 226 ResourceProvider* resource_provider_; |
227 ResourceId resource_id_; | 227 ResourceId resource_id_; |
228 | 228 unsigned texture_id_; |
229 private: | 229 GLenum target_; |
230 const ResourceProvider::Resource* resource_; | 230 gfx::Size size_; |
231 | 231 |
232 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL); | 232 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGL); |
233 }; | 233 }; |
234 | 234 |
235 class CC_EXPORT ScopedSamplerGL : public ScopedReadLockGL { | 235 class CC_EXPORT ScopedSamplerGL { |
236 public: | 236 public: |
237 ScopedSamplerGL(ResourceProvider* resource_provider, | 237 ScopedSamplerGL(ResourceProvider* resource_provider, |
238 ResourceId resource_id, | 238 ResourceId resource_id, |
239 GLenum filter); | 239 GLenum filter); |
240 ScopedSamplerGL(ResourceProvider* resource_provider, | 240 ScopedSamplerGL(ResourceProvider* resource_provider, |
241 ResourceId resource_id, | 241 ResourceId resource_id, |
242 GLenum unit, | 242 GLenum unit, |
243 GLenum filter); | 243 GLenum filter); |
244 ~ScopedSamplerGL() override; | 244 ~ScopedSamplerGL(); |
245 | 245 |
| 246 unsigned texture_id() const { return resource_lock_.texture_id(); } |
246 GLenum target() const { return target_; } | 247 GLenum target() const { return target_; } |
247 | 248 |
248 private: | 249 private: |
| 250 ScopedReadLockGL resource_lock_; |
249 GLenum unit_; | 251 GLenum unit_; |
250 GLenum target_; | 252 GLenum target_; |
251 | 253 |
252 DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL); | 254 DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL); |
253 }; | 255 }; |
254 | 256 |
255 class CC_EXPORT ScopedWriteLockGL { | 257 class CC_EXPORT ScopedWriteLockGL { |
256 public: | 258 public: |
257 ScopedWriteLockGL(ResourceProvider* resource_provider, | 259 ScopedWriteLockGL(ResourceProvider* resource_provider, |
258 ResourceId resource_id); | 260 ResourceId resource_id, |
| 261 bool create_mailbox); |
259 ~ScopedWriteLockGL(); | 262 ~ScopedWriteLockGL(); |
260 | 263 |
261 unsigned texture_id() const { return texture_id_; } | 264 unsigned texture_id() const { return texture_id_; } |
| 265 GLenum target() const { return target_; } |
| 266 ResourceFormat format() const { return format_; } |
| 267 const gfx::Size& size() const { return size_; } |
262 | 268 |
263 void UpdateResourceSyncToken(const gpu::SyncToken& sync_token) { | 269 const TextureMailbox& mailbox() const { return mailbox_; } |
264 set_sync_token_ = true; | 270 |
| 271 void set_sync_token(const gpu::SyncToken& sync_token) { |
265 sync_token_ = sync_token; | 272 sync_token_ = sync_token; |
266 } | 273 } |
267 | 274 |
268 private: | 275 private: |
269 ResourceProvider* resource_provider_; | 276 ResourceProvider* resource_provider_; |
270 ResourceProvider::Resource* resource_; | 277 ResourceId resource_id_; |
271 unsigned texture_id_; | 278 unsigned texture_id_; |
272 bool set_sync_token_; | 279 GLenum target_; |
| 280 ResourceFormat format_; |
| 281 gfx::Size size_; |
| 282 TextureMailbox mailbox_; |
273 gpu::SyncToken sync_token_; | 283 gpu::SyncToken sync_token_; |
| 284 base::ThreadChecker thread_checker_; |
274 | 285 |
275 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL); | 286 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL); |
276 }; | 287 }; |
277 | 288 |
| 289 class CC_EXPORT ScopedTextureProvider { |
| 290 public: |
| 291 ScopedTextureProvider(gpu::gles2::GLES2Interface* gl, |
| 292 ScopedWriteLockGL* resource_lock, |
| 293 bool use_mailbox); |
| 294 ~ScopedTextureProvider(); |
| 295 |
| 296 unsigned texture_id() const { return texture_id_; } |
| 297 |
| 298 private: |
| 299 gpu::gles2::GLES2Interface* gl_; |
| 300 bool use_mailbox_; |
| 301 unsigned texture_id_; |
| 302 |
| 303 DISALLOW_COPY_AND_ASSIGN(ScopedTextureProvider); |
| 304 }; |
| 305 |
| 306 class CC_EXPORT ScopedSkSurfaceProvider { |
| 307 public: |
| 308 ScopedSkSurfaceProvider(ContextProvider* context_provider, |
| 309 ScopedWriteLockGL* resource_lock, |
| 310 bool use_mailbox, |
| 311 bool use_distance_field_text, |
| 312 bool can_use_lcd_text, |
| 313 int msaa_sample_count); |
| 314 ~ScopedSkSurfaceProvider(); |
| 315 |
| 316 SkSurface* sk_surface() { return sk_surface_.get(); } |
| 317 |
| 318 private: |
| 319 ScopedTextureProvider texture_provider_; |
| 320 sk_sp<SkSurface> sk_surface_; |
| 321 |
| 322 DISALLOW_COPY_AND_ASSIGN(ScopedSkSurfaceProvider); |
| 323 }; |
| 324 |
278 class CC_EXPORT ScopedReadLockSoftware { | 325 class CC_EXPORT ScopedReadLockSoftware { |
279 public: | 326 public: |
280 ScopedReadLockSoftware(ResourceProvider* resource_provider, | 327 ScopedReadLockSoftware(ResourceProvider* resource_provider, |
281 ResourceId resource_id); | 328 ResourceId resource_id); |
282 ~ScopedReadLockSoftware(); | 329 ~ScopedReadLockSoftware(); |
283 | 330 |
284 const SkBitmap* sk_bitmap() const { | 331 const SkBitmap* sk_bitmap() const { |
285 DCHECK(valid()); | 332 DCHECK(valid()); |
286 return &sk_bitmap_; | 333 return &sk_bitmap_; |
287 } | 334 } |
(...skipping 12 matching lines...) Expand all Loading... |
300 public: | 347 public: |
301 ScopedWriteLockSoftware(ResourceProvider* resource_provider, | 348 ScopedWriteLockSoftware(ResourceProvider* resource_provider, |
302 ResourceId resource_id); | 349 ResourceId resource_id); |
303 ~ScopedWriteLockSoftware(); | 350 ~ScopedWriteLockSoftware(); |
304 | 351 |
305 SkBitmap& sk_bitmap() { return sk_bitmap_; } | 352 SkBitmap& sk_bitmap() { return sk_bitmap_; } |
306 bool valid() const { return !!sk_bitmap_.getPixels(); } | 353 bool valid() const { return !!sk_bitmap_.getPixels(); } |
307 | 354 |
308 private: | 355 private: |
309 ResourceProvider* resource_provider_; | 356 ResourceProvider* resource_provider_; |
310 ResourceProvider::Resource* resource_; | 357 ResourceId resource_id_; |
311 SkBitmap sk_bitmap_; | 358 SkBitmap sk_bitmap_; |
312 base::ThreadChecker thread_checker_; | 359 base::ThreadChecker thread_checker_; |
313 | 360 |
314 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware); | 361 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware); |
315 }; | 362 }; |
316 | 363 |
317 class CC_EXPORT ScopedWriteLockGpuMemoryBuffer { | 364 class CC_EXPORT ScopedWriteLockGpuMemoryBuffer { |
318 public: | 365 public: |
319 ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider, | 366 ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider, |
320 ResourceId resource_id); | 367 ResourceId resource_id); |
321 ~ScopedWriteLockGpuMemoryBuffer(); | 368 ~ScopedWriteLockGpuMemoryBuffer(); |
322 | 369 |
323 gfx::GpuMemoryBuffer* GetGpuMemoryBuffer(); | 370 gfx::GpuMemoryBuffer* GetGpuMemoryBuffer(); |
324 | 371 |
325 private: | 372 private: |
326 ResourceProvider* resource_provider_; | 373 ResourceProvider* resource_provider_; |
327 ResourceProvider::Resource* resource_; | 374 ResourceId resource_id_; |
| 375 ResourceFormat format_; |
| 376 gfx::Size size_; |
328 std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_; | 377 std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_; |
329 base::ThreadChecker thread_checker_; | 378 base::ThreadChecker thread_checker_; |
330 | 379 |
331 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer); | 380 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer); |
332 }; | 381 }; |
333 | 382 |
334 class CC_EXPORT ScopedReadLockGpuMemoryBuffer { | 383 class CC_EXPORT ScopedReadLockGpuMemoryBuffer { |
335 public: | 384 public: |
336 ScopedReadLockGpuMemoryBuffer(ResourceProvider* resource_provider, | 385 ScopedReadLockGpuMemoryBuffer(ResourceProvider* resource_provider, |
337 ResourceId resource_id); | 386 ResourceId resource_id); |
338 ~ScopedReadLockGpuMemoryBuffer(); | 387 ~ScopedReadLockGpuMemoryBuffer(); |
339 | 388 |
| 389 ResourceId resource_id() const { return resource_id_; } |
| 390 |
340 // This may return nullptr. | 391 // This may return nullptr. |
341 gfx::GpuMemoryBuffer* GetGpuMemoryBuffer() const; | 392 gfx::GpuMemoryBuffer* gpu_memory_buffer() const { |
| 393 return gpu_memory_buffer_; |
| 394 } |
342 | 395 |
343 // This returns the GL texture that is backed by a GL image bound to the | 396 // This returns the GL texture that is backed by a GL image bound to the |
344 // resource's GpuMemoryBuffer. | 397 // resource's GpuMemoryBuffer. |
345 unsigned GetTextureId() const; | 398 unsigned texture_id() const { return texture_id_; } |
346 | |
347 ResourceId GetResourceId() const; | |
348 | 399 |
349 private: | 400 private: |
350 ResourceProvider* resource_provider_; | 401 ResourceProvider* resource_provider_; |
351 ResourceId resource_id_; | 402 ResourceId resource_id_; |
352 const ResourceProvider::Resource* resource_; | 403 gfx::GpuMemoryBuffer* gpu_memory_buffer_; |
| 404 unsigned texture_id_; |
353 base::ThreadChecker thread_checker_; | 405 base::ThreadChecker thread_checker_; |
354 | 406 |
355 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGpuMemoryBuffer); | 407 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGpuMemoryBuffer); |
356 }; | 408 }; |
357 | 409 |
358 class CC_EXPORT ScopedWriteLockGr { | |
359 public: | |
360 ScopedWriteLockGr(ResourceProvider* resource_provider, | |
361 ResourceId resource_id); | |
362 ~ScopedWriteLockGr(); | |
363 | |
364 void InitSkSurface(GrContext* gr_context, | |
365 bool use_distance_field_text, | |
366 bool can_use_lcd_text, | |
367 int msaa_sample_count); | |
368 void ReleaseSkSurface(); | |
369 | |
370 SkSurface* sk_surface() { return sk_surface_.get(); } | |
371 | |
372 gfx::Size GetResourceSize() const { return resource_->size; } | |
373 | |
374 void UpdateResourceSyncToken(const gpu::SyncToken& sync_token) { | |
375 set_sync_token_ = true; | |
376 sync_token_ = sync_token; | |
377 } | |
378 | |
379 private: | |
380 ResourceProvider* resource_provider_; | |
381 ResourceProvider::Resource* resource_; | |
382 base::ThreadChecker thread_checker_; | |
383 sk_sp<SkSurface> sk_surface_; | |
384 bool set_sync_token_; | |
385 gpu::SyncToken sync_token_; | |
386 | |
387 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGr); | |
388 }; | |
389 | |
390 class Fence : public base::RefCounted<Fence> { | 410 class Fence : public base::RefCounted<Fence> { |
391 public: | 411 public: |
392 Fence() {} | 412 Fence() {} |
393 | 413 |
394 virtual void Set() = 0; | 414 virtual void Set() = 0; |
395 virtual bool HasPassed() = 0; | 415 virtual bool HasPassed() = 0; |
396 virtual void Wait() = 0; | 416 virtual void Wait() = 0; |
397 | 417 |
398 protected: | 418 protected: |
399 friend class base::RefCounted<Fence>; | 419 friend class base::RefCounted<Fence>; |
(...skipping 286 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
686 // A process-unique ID used for disambiguating memory dumps from different | 706 // A process-unique ID used for disambiguating memory dumps from different |
687 // resource providers. | 707 // resource providers. |
688 int tracing_id_; | 708 int tracing_id_; |
689 | 709 |
690 DISALLOW_COPY_AND_ASSIGN(ResourceProvider); | 710 DISALLOW_COPY_AND_ASSIGN(ResourceProvider); |
691 }; | 711 }; |
692 | 712 |
693 } // namespace cc | 713 } // namespace cc |
694 | 714 |
695 #endif // CC_RESOURCES_RESOURCE_PROVIDER_H_ | 715 #endif // CC_RESOURCES_RESOURCE_PROVIDER_H_ |
OLD | NEW |