Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(106)

Side by Side Diff: cc/resources/resource_provider.h

Issue 454843002: cc: Do bitmap conversion for RasterBuffer in the worker thread. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix and cleanup. Created 6 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 <deque> 8 #include <deque>
9 #include <set> 9 #include <set>
10 #include <string> 10 #include <string>
11 #include <utility> 11 #include <utility>
12 #include <vector> 12 #include <vector>
13 13
14 #include "base/basictypes.h" 14 #include "base/basictypes.h"
15 #include "base/callback.h" 15 #include "base/callback.h"
16 #include "base/containers/hash_tables.h" 16 #include "base/containers/hash_tables.h"
17 #include "base/memory/linked_ptr.h" 17 #include "base/memory/linked_ptr.h"
18 #include "base/memory/scoped_ptr.h" 18 #include "base/memory/scoped_ptr.h"
19 #include "base/threading/thread_checker.h" 19 #include "base/threading/thread_checker.h"
20 #include "cc/base/cc_export.h" 20 #include "cc/base/cc_export.h"
21 #include "cc/output/context_provider.h" 21 #include "cc/output/context_provider.h"
22 #include "cc/output/output_surface.h" 22 #include "cc/output/output_surface.h"
23 #include "cc/resources/raster_buffer.h"
23 #include "cc/resources/release_callback.h" 24 #include "cc/resources/release_callback.h"
24 #include "cc/resources/resource_format.h" 25 #include "cc/resources/resource_format.h"
25 #include "cc/resources/return_callback.h" 26 #include "cc/resources/return_callback.h"
26 #include "cc/resources/shared_bitmap.h" 27 #include "cc/resources/shared_bitmap.h"
27 #include "cc/resources/single_release_callback.h" 28 #include "cc/resources/single_release_callback.h"
28 #include "cc/resources/texture_mailbox.h" 29 #include "cc/resources/texture_mailbox.h"
29 #include "cc/resources/transferable_resource.h" 30 #include "cc/resources/transferable_resource.h"
30 #include "third_party/khronos/GLES2/gl2.h" 31 #include "third_party/khronos/GLES2/gl2.h"
31 #include "third_party/khronos/GLES2/gl2ext.h" 32 #include "third_party/khronos/GLES2/gl2ext.h"
32 #include "third_party/skia/include/core/SkBitmap.h" 33 #include "third_party/skia/include/core/SkBitmap.h"
(...skipping 273 matching lines...) Expand 10 before | Expand all | Expand 10 after
306 virtual bool HasPassed() = 0; 307 virtual bool HasPassed() = 0;
307 308
308 protected: 309 protected:
309 friend class base::RefCounted<Fence>; 310 friend class base::RefCounted<Fence>;
310 virtual ~Fence() {} 311 virtual ~Fence() {}
311 312
312 private: 313 private:
313 DISALLOW_COPY_AND_ASSIGN(Fence); 314 DISALLOW_COPY_AND_ASSIGN(Fence);
314 }; 315 };
315 316
316 // Returns a canvas for gpu rasterization. 317 // Returns a RasterBuffer for gpu rasterization.
317 // Call Unmap before the resource can be read or used for compositing. 318 // Call Release before the resource can be read or used for compositing.
318 // It is used for direct gpu rasterization. 319 // It is used for direct gpu rasterization.
319 SkCanvas* MapGpuRasterBuffer(ResourceId id); 320 RasterBuffer* AcquireGpuRasterBuffer(ResourceId id);
320 void UnmapGpuRasterBuffer(ResourceId id); 321 void ReleaseGpuRasterBuffer(ResourceId id);
321 322
322 // Returns a canvas backed by an image buffer. UnmapImageRasterBuffer 323 // Returns a RasterBuffer backed by an image buffer. ReleaseImageRasterBuffer
323 // returns true if canvas was written to while mapped. 324 // returns true if RasterBuffer was written to while acquired.
324 // Rasterizing to the canvas writes the content into the image buffer, 325 // Rasterizing to the RasterBuffer writes the content into the image buffer,
325 // which is internally bound to the underlying resource when read. 326 // which is internally bound to the underlying resource when read.
326 // Call Unmap before the resource can be read or used for compositing. 327 // Call Release before the resource can be read or used for compositing.
327 // It is used by ImageRasterWorkerPool. 328 // It is used by ImageRasterWorkerPool.
328 SkCanvas* MapImageRasterBuffer(ResourceId id); 329 RasterBuffer* AcquireImageRasterBuffer(ResourceId id);
329 bool UnmapImageRasterBuffer(ResourceId id); 330 bool ReleaseImageRasterBuffer(ResourceId id);
330 331
331 // Returns a canvas backed by pixel buffer. UnmapPixelRasterBuffer 332 // Returns a RasterBuffer backed by pixel buffer. ReleasePixelRasterBuffer
332 // returns true if canvas was written to while mapped. 333 // returns true if RasterBuffer was written to while acquired.
333 // The pixel buffer needs to be uploaded to the underlying resource 334 // The pixel buffer needs to be uploaded to the underlying resource
334 // using BeginSetPixels before the resouce can be used for compositing. 335 // using BeginSetPixels before the resouce can be used for compositing.
335 // It is used by PixelRasterWorkerPool. 336 // It is used by PixelRasterWorkerPool.
336 void AcquirePixelRasterBuffer(ResourceId id); 337 RasterBuffer* AcquirePixelRasterBuffer(ResourceId id);
337 void ReleasePixelRasterBuffer(ResourceId id); 338 bool ReleasePixelRasterBuffer(ResourceId id);
338 SkCanvas* MapPixelRasterBuffer(ResourceId id);
339 bool UnmapPixelRasterBuffer(ResourceId id);
340 339
341 // Asynchronously update pixels from acquired pixel buffer. 340 // Asynchronously update pixels from acquired pixel buffer.
342 void BeginSetPixels(ResourceId id); 341 void BeginSetPixels(ResourceId id);
343 void ForceSetPixelsToComplete(ResourceId id); 342 void ForceSetPixelsToComplete(ResourceId id);
344 bool DidSetPixelsComplete(ResourceId id); 343 bool DidSetPixelsComplete(ResourceId id);
345 344
346 // For tests only! This prevents detecting uninitialized reads. 345 // For tests only! This prevents detecting uninitialized reads.
347 // Use SetPixels or LockForWrite to allocate implicitly. 346 // Use SetPixels or LockForWrite to allocate implicitly.
348 void AllocateForTesting(ResourceId id); 347 void AllocateForTesting(ResourceId id);
349 348
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
438 ResourceType type; 437 ResourceType type;
439 ResourceFormat format; 438 ResourceFormat format;
440 SharedBitmapId shared_bitmap_id; 439 SharedBitmapId shared_bitmap_id;
441 SharedBitmap* shared_bitmap; 440 SharedBitmap* shared_bitmap;
442 linked_ptr<GpuRasterBuffer> gpu_raster_buffer; 441 linked_ptr<GpuRasterBuffer> gpu_raster_buffer;
443 linked_ptr<ImageRasterBuffer> image_raster_buffer; 442 linked_ptr<ImageRasterBuffer> image_raster_buffer;
444 linked_ptr<PixelRasterBuffer> pixel_raster_buffer; 443 linked_ptr<PixelRasterBuffer> pixel_raster_buffer;
445 }; 444 };
446 typedef base::hash_map<ResourceId, Resource> ResourceMap; 445 typedef base::hash_map<ResourceId, Resource> ResourceMap;
447 446
448 class RasterBuffer {
449 public:
450 virtual ~RasterBuffer();
451
452 SkCanvas* LockForWrite();
453 // Returns true if canvas was written to while locked.
454 bool UnlockForWrite();
455
456 protected:
457 RasterBuffer(const Resource* resource, ResourceProvider* resource_provider);
458 const Resource* resource() const { return resource_; }
459 ResourceProvider* resource_provider() const { return resource_provider_; }
460
461 virtual SkCanvas* DoLockForWrite() = 0;
462 virtual bool DoUnlockForWrite() = 0;
463
464 private:
465 const Resource* resource_;
466 ResourceProvider* resource_provider_;
467 SkCanvas* locked_canvas_;
468 int canvas_save_count_;
469 };
470
471 class GpuRasterBuffer : public RasterBuffer { 447 class GpuRasterBuffer : public RasterBuffer {
472 public: 448 public:
473 GpuRasterBuffer(const Resource* resource, 449 GpuRasterBuffer(const Resource* resource,
474 ResourceProvider* resource_provider, 450 ResourceProvider* resource_provider,
475 bool use_distance_field_text); 451 bool use_distance_field_text);
476 virtual ~GpuRasterBuffer(); 452 virtual ~GpuRasterBuffer();
477 453
478 protected: 454 protected:
479 virtual SkCanvas* DoLockForWrite() OVERRIDE; 455 virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE;
480 virtual bool DoUnlockForWrite() OVERRIDE; 456 virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE;
reveman 2014/08/15 11:54:31 Why are these functions protected?
auygun 2014/08/15 15:08:23 Done.
481 skia::RefPtr<SkSurface> CreateSurface();
482 457
483 private: 458 private:
459 const Resource* resource_;
460 ResourceProvider* resource_provider_;
484 skia::RefPtr<SkSurface> surface_; 461 skia::RefPtr<SkSurface> surface_;
485 uint32_t surface_generation_id_;
486 const bool use_distance_field_text_;
487 462
488 DISALLOW_COPY_AND_ASSIGN(GpuRasterBuffer); 463 DISALLOW_COPY_AND_ASSIGN(GpuRasterBuffer);
489 }; 464 };
490 465
491 class BitmapRasterBuffer : public RasterBuffer { 466 class ImageRasterBuffer : public RasterBuffer {
492 public:
493 virtual ~BitmapRasterBuffer();
494
495 protected:
496 BitmapRasterBuffer(const Resource* resource,
497 ResourceProvider* resource_provider);
498
499 virtual SkCanvas* DoLockForWrite() OVERRIDE;
500 virtual bool DoUnlockForWrite() OVERRIDE;
501
502 virtual uint8_t* MapBuffer(int* stride) = 0;
503 virtual void UnmapBuffer() = 0;
504
505 private:
506 uint8_t* mapped_buffer_;
507 SkBitmap raster_bitmap_;
508 uint32_t raster_bitmap_generation_id_;
509 skia::RefPtr<SkCanvas> raster_canvas_;
510 };
511
512 class ImageRasterBuffer : public BitmapRasterBuffer {
513 public: 467 public:
514 ImageRasterBuffer(const Resource* resource, 468 ImageRasterBuffer(const Resource* resource,
515 ResourceProvider* resource_provider); 469 ResourceProvider* resource_provider);
516 virtual ~ImageRasterBuffer(); 470 virtual ~ImageRasterBuffer();
517 471
472 void MapBuffer();
473 bool UnmapBuffer();
474
518 protected: 475 protected:
519 virtual uint8_t* MapBuffer(int* stride) OVERRIDE; 476 virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE;
520 virtual void UnmapBuffer() OVERRIDE; 477 virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE;
reveman 2014/08/15 11:54:31 Why are these functions protected?
auygun 2014/08/15 15:08:23 Done.
521 478
522 private: 479 private:
480 const Resource* resource_;
481 ResourceProvider* resource_provider_;
482 uint8_t* mapped_buffer_;
483 SkBitmap raster_bitmap_;
484 bool raster_bitmap_changed_;
485 int stride_;
486
523 DISALLOW_COPY_AND_ASSIGN(ImageRasterBuffer); 487 DISALLOW_COPY_AND_ASSIGN(ImageRasterBuffer);
524 }; 488 };
525 489
526 class PixelRasterBuffer : public BitmapRasterBuffer { 490 class PixelRasterBuffer : public RasterBuffer {
527 public: 491 public:
528 PixelRasterBuffer(const Resource* resource, 492 PixelRasterBuffer(const Resource* resource,
529 ResourceProvider* resource_provider); 493 ResourceProvider* resource_provider);
530 virtual ~PixelRasterBuffer(); 494 virtual ~PixelRasterBuffer();
531 495
496 void MapBuffer();
497 bool UnmapBuffer();
498
532 protected: 499 protected:
533 virtual uint8_t* MapBuffer(int* stride) OVERRIDE; 500 virtual skia::RefPtr<SkCanvas> AcquireSkCanvas() OVERRIDE;
534 virtual void UnmapBuffer() OVERRIDE; 501 virtual void ReleaseSkCanvas(const skia::RefPtr<SkCanvas>& canvas) OVERRIDE;
reveman 2014/08/15 11:54:31 Why are these functions protected?
auygun 2014/08/15 15:08:23 Done.
535 502
536 private: 503 private:
504 const Resource* resource_;
505 ResourceProvider* resource_provider_;
506 uint8_t* mapped_buffer_;
507 SkBitmap raster_bitmap_;
508 bool raster_bitmap_changed_;
509 int stride_;
510
537 DISALLOW_COPY_AND_ASSIGN(PixelRasterBuffer); 511 DISALLOW_COPY_AND_ASSIGN(PixelRasterBuffer);
538 }; 512 };
539 513
540 static bool CompareResourceMapIteratorsByChildId( 514 static bool CompareResourceMapIteratorsByChildId(
541 const std::pair<ReturnedResource, ResourceMap::iterator>& a, 515 const std::pair<ReturnedResource, ResourceMap::iterator>& a,
542 const std::pair<ReturnedResource, ResourceMap::iterator>& b); 516 const std::pair<ReturnedResource, ResourceMap::iterator>& b);
543 517
544 struct Child { 518 struct Child {
545 Child(); 519 Child();
546 ~Child(); 520 ~Child();
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after
696 return format_gl_data_format[format]; 670 return format_gl_data_format[format];
697 } 671 }
698 672
699 inline GLenum GLInternalFormat(ResourceFormat format) { 673 inline GLenum GLInternalFormat(ResourceFormat format) {
700 return GLDataFormat(format); 674 return GLDataFormat(format);
701 } 675 }
702 676
703 } // namespace cc 677 } // namespace cc
704 678
705 #endif // CC_RESOURCES_RESOURCE_PROVIDER_H_ 679 #endif // CC_RESOURCES_RESOURCE_PROVIDER_H_
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698