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 ~ScopedReadLockGL(); | 219 virtual ~ScopedReadLockGL(); |
220 | 220 |
221 unsigned texture_id() const { return texture_id_; } | 221 unsigned texture_id() const { return resource_->gl_id; } |
222 GLenum target() const { return target_; } | 222 GLenum target() const { return resource_->target; } |
223 const gfx::Size& size() const { return size_; } | 223 const gfx::Size& texture_size() const { return resource_->size; } |
| 224 |
| 225 protected: |
| 226 ResourceProvider* resource_provider_; |
| 227 ResourceId resource_id_; |
224 | 228 |
225 private: | 229 private: |
226 ResourceProvider* resource_provider_; | 230 const ResourceProvider::Resource* resource_; |
227 ResourceId resource_id_; | |
228 unsigned texture_id_; | |
229 GLenum target_; | |
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 { | 235 class CC_EXPORT ScopedSamplerGL : public ScopedReadLockGL { |
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(); | 244 ~ScopedSamplerGL() override; |
245 | 245 |
246 unsigned texture_id() const { return resource_lock_.texture_id(); } | |
247 GLenum target() const { return target_; } | 246 GLenum target() const { return target_; } |
248 | 247 |
249 private: | 248 private: |
250 ScopedReadLockGL resource_lock_; | |
251 GLenum unit_; | 249 GLenum unit_; |
252 GLenum target_; | 250 GLenum target_; |
253 | 251 |
254 DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL); | 252 DISALLOW_COPY_AND_ASSIGN(ScopedSamplerGL); |
255 }; | 253 }; |
256 | 254 |
257 class CC_EXPORT ScopedWriteLockGL { | 255 class CC_EXPORT ScopedWriteLockGL { |
258 public: | 256 public: |
259 ScopedWriteLockGL(ResourceProvider* resource_provider, | 257 ScopedWriteLockGL(ResourceProvider* resource_provider, |
260 ResourceId resource_id, | 258 ResourceId resource_id); |
261 bool create_mailbox); | |
262 ~ScopedWriteLockGL(); | 259 ~ScopedWriteLockGL(); |
263 | 260 |
264 unsigned texture_id() const { return texture_id_; } | 261 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_; } | |
268 | 262 |
269 const TextureMailbox& mailbox() const { return mailbox_; } | 263 void UpdateResourceSyncToken(const gpu::SyncToken& sync_token) { |
270 | 264 set_sync_token_ = true; |
271 void set_sync_token(const gpu::SyncToken& sync_token) { | |
272 sync_token_ = sync_token; | 265 sync_token_ = sync_token; |
273 } | 266 } |
274 | 267 |
275 private: | 268 private: |
276 ResourceProvider* resource_provider_; | 269 ResourceProvider* resource_provider_; |
277 ResourceId resource_id_; | 270 ResourceProvider::Resource* resource_; |
278 unsigned texture_id_; | 271 unsigned texture_id_; |
279 GLenum target_; | 272 bool set_sync_token_; |
280 ResourceFormat format_; | |
281 gfx::Size size_; | |
282 TextureMailbox mailbox_; | |
283 gpu::SyncToken sync_token_; | 273 gpu::SyncToken sync_token_; |
284 base::ThreadChecker thread_checker_; | |
285 | 274 |
286 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL); | 275 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL); |
287 }; | 276 }; |
288 | 277 |
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 | |
325 class CC_EXPORT ScopedReadLockSoftware { | 278 class CC_EXPORT ScopedReadLockSoftware { |
326 public: | 279 public: |
327 ScopedReadLockSoftware(ResourceProvider* resource_provider, | 280 ScopedReadLockSoftware(ResourceProvider* resource_provider, |
328 ResourceId resource_id); | 281 ResourceId resource_id); |
329 ~ScopedReadLockSoftware(); | 282 ~ScopedReadLockSoftware(); |
330 | 283 |
331 const SkBitmap* sk_bitmap() const { | 284 const SkBitmap* sk_bitmap() const { |
332 DCHECK(valid()); | 285 DCHECK(valid()); |
333 return &sk_bitmap_; | 286 return &sk_bitmap_; |
334 } | 287 } |
(...skipping 12 matching lines...) Expand all Loading... |
347 public: | 300 public: |
348 ScopedWriteLockSoftware(ResourceProvider* resource_provider, | 301 ScopedWriteLockSoftware(ResourceProvider* resource_provider, |
349 ResourceId resource_id); | 302 ResourceId resource_id); |
350 ~ScopedWriteLockSoftware(); | 303 ~ScopedWriteLockSoftware(); |
351 | 304 |
352 SkBitmap& sk_bitmap() { return sk_bitmap_; } | 305 SkBitmap& sk_bitmap() { return sk_bitmap_; } |
353 bool valid() const { return !!sk_bitmap_.getPixels(); } | 306 bool valid() const { return !!sk_bitmap_.getPixels(); } |
354 | 307 |
355 private: | 308 private: |
356 ResourceProvider* resource_provider_; | 309 ResourceProvider* resource_provider_; |
357 ResourceId resource_id_; | 310 ResourceProvider::Resource* resource_; |
358 SkBitmap sk_bitmap_; | 311 SkBitmap sk_bitmap_; |
359 base::ThreadChecker thread_checker_; | 312 base::ThreadChecker thread_checker_; |
360 | 313 |
361 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware); | 314 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware); |
362 }; | 315 }; |
363 | 316 |
364 class CC_EXPORT ScopedWriteLockGpuMemoryBuffer { | 317 class CC_EXPORT ScopedWriteLockGpuMemoryBuffer { |
365 public: | 318 public: |
366 ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider, | 319 ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider, |
367 ResourceId resource_id); | 320 ResourceId resource_id); |
368 ~ScopedWriteLockGpuMemoryBuffer(); | 321 ~ScopedWriteLockGpuMemoryBuffer(); |
369 | 322 |
370 gfx::GpuMemoryBuffer* GetGpuMemoryBuffer(); | 323 gfx::GpuMemoryBuffer* GetGpuMemoryBuffer(); |
371 | 324 |
372 private: | 325 private: |
373 ResourceProvider* resource_provider_; | 326 ResourceProvider* resource_provider_; |
374 ResourceId resource_id_; | 327 ResourceProvider::Resource* resource_; |
375 ResourceFormat format_; | |
376 gfx::Size size_; | |
377 std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_; | 328 std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_; |
378 base::ThreadChecker thread_checker_; | 329 base::ThreadChecker thread_checker_; |
379 | 330 |
380 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer); | 331 DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer); |
381 }; | 332 }; |
382 | 333 |
383 class CC_EXPORT ScopedReadLockGpuMemoryBuffer { | 334 class CC_EXPORT ScopedReadLockGpuMemoryBuffer { |
384 public: | 335 public: |
385 ScopedReadLockGpuMemoryBuffer(ResourceProvider* resource_provider, | 336 ScopedReadLockGpuMemoryBuffer(ResourceProvider* resource_provider, |
386 ResourceId resource_id); | 337 ResourceId resource_id); |
387 ~ScopedReadLockGpuMemoryBuffer(); | 338 ~ScopedReadLockGpuMemoryBuffer(); |
388 | 339 |
389 ResourceId resource_id() const { return resource_id_; } | |
390 | |
391 // This may return nullptr. | 340 // This may return nullptr. |
392 gfx::GpuMemoryBuffer* gpu_memory_buffer() const { | 341 gfx::GpuMemoryBuffer* GetGpuMemoryBuffer() const; |
393 return gpu_memory_buffer_; | |
394 } | |
395 | 342 |
396 // This returns the GL texture that is backed by a GL image bound to the | 343 // This returns the GL texture that is backed by a GL image bound to the |
397 // resource's GpuMemoryBuffer. | 344 // resource's GpuMemoryBuffer. |
398 unsigned texture_id() const { return texture_id_; } | 345 unsigned GetTextureId() const; |
| 346 |
| 347 ResourceId GetResourceId() const; |
399 | 348 |
400 private: | 349 private: |
401 ResourceProvider* resource_provider_; | 350 ResourceProvider* resource_provider_; |
402 ResourceId resource_id_; | 351 ResourceId resource_id_; |
403 gfx::GpuMemoryBuffer* gpu_memory_buffer_; | 352 const ResourceProvider::Resource* resource_; |
404 unsigned texture_id_; | |
405 base::ThreadChecker thread_checker_; | 353 base::ThreadChecker thread_checker_; |
406 | 354 |
407 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGpuMemoryBuffer); | 355 DISALLOW_COPY_AND_ASSIGN(ScopedReadLockGpuMemoryBuffer); |
408 }; | 356 }; |
409 | 357 |
| 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 |
410 class Fence : public base::RefCounted<Fence> { | 390 class Fence : public base::RefCounted<Fence> { |
411 public: | 391 public: |
412 Fence() {} | 392 Fence() {} |
413 | 393 |
414 virtual void Set() = 0; | 394 virtual void Set() = 0; |
415 virtual bool HasPassed() = 0; | 395 virtual bool HasPassed() = 0; |
416 virtual void Wait() = 0; | 396 virtual void Wait() = 0; |
417 | 397 |
418 protected: | 398 protected: |
419 friend class base::RefCounted<Fence>; | 399 friend class base::RefCounted<Fence>; |
(...skipping 286 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
706 // A process-unique ID used for disambiguating memory dumps from different | 686 // A process-unique ID used for disambiguating memory dumps from different |
707 // resource providers. | 687 // resource providers. |
708 int tracing_id_; | 688 int tracing_id_; |
709 | 689 |
710 DISALLOW_COPY_AND_ASSIGN(ResourceProvider); | 690 DISALLOW_COPY_AND_ASSIGN(ResourceProvider); |
711 }; | 691 }; |
712 | 692 |
713 } // namespace cc | 693 } // namespace cc |
714 | 694 |
715 #endif // CC_RESOURCES_RESOURCE_PROVIDER_H_ | 695 #endif // CC_RESOURCES_RESOURCE_PROVIDER_H_ |
OLD | NEW |