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

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

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: Make RasterBuffer the public interface used by raster tasks. 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 #include "cc/resources/resource_provider.h" 5 #include "cc/resources/resource_provider.h"
6 6
7 #include <algorithm> 7 #include <algorithm>
8 #include <limits> 8 #include <limits>
9 9
10 #include "base/containers/hash_tables.h" 10 #include "base/containers/hash_tables.h"
(...skipping 378 matching lines...) Expand 10 before | Expand all | Expand 10 after
389 texture_pool(0), 389 texture_pool(0),
390 wrap_mode(wrap_mode), 390 wrap_mode(wrap_mode),
391 hint(TextureUsageAny), 391 hint(TextureUsageAny),
392 type(Bitmap), 392 type(Bitmap),
393 format(RGBA_8888), 393 format(RGBA_8888),
394 shared_bitmap_id(bitmap_id), 394 shared_bitmap_id(bitmap_id),
395 shared_bitmap(NULL) { 395 shared_bitmap(NULL) {
396 DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT); 396 DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
397 } 397 }
398 398
399 ResourceProvider::RasterBuffer::RasterBuffer(
400 const Resource* resource,
401 ResourceProvider* resource_provider)
402 : resource_(resource),
403 resource_provider_(resource_provider),
404 locked_canvas_(NULL),
405 canvas_save_count_(0) {
406 DCHECK(resource_);
407 DCHECK(resource_provider_);
408 }
409
410 ResourceProvider::RasterBuffer::~RasterBuffer() {}
411
412 SkCanvas* ResourceProvider::RasterBuffer::LockForWrite() {
413 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
414 "ResourceProvider::RasterBuffer::LockForWrite");
415
416 DCHECK(!locked_canvas_);
417
418 locked_canvas_ = DoLockForWrite();
419 canvas_save_count_ = locked_canvas_ ? locked_canvas_->save() : 0;
420 return locked_canvas_;
421 }
422
423 bool ResourceProvider::RasterBuffer::UnlockForWrite() {
424 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
425 "ResourceProvider::RasterBuffer::UnlockForWrite");
426
427 if (locked_canvas_) {
428 locked_canvas_->restoreToCount(canvas_save_count_);
429 locked_canvas_ = NULL;
430 }
431 return DoUnlockForWrite();
432 }
433
434 ResourceProvider::GpuRasterBuffer::GpuRasterBuffer( 399 ResourceProvider::GpuRasterBuffer::GpuRasterBuffer(
435 const Resource* resource, 400 const Resource* resource,
436 ResourceProvider* resource_provider, 401 ResourceProvider* resource_provider,
437 bool use_distance_field_text) 402 bool use_distance_field_text)
438 : RasterBuffer(resource, resource_provider), 403 : resource_(resource),
404 resource_provider_(resource_provider),
405 locked_canvas_(NULL),
406 canvas_save_count_(0),
439 surface_generation_id_(0u), 407 surface_generation_id_(0u),
440 use_distance_field_text_(use_distance_field_text) { 408 use_distance_field_text_(use_distance_field_text) {
441 } 409 }
442 410
443 ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() { 411 ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() {
444 } 412 }
445 413
446 SkCanvas* ResourceProvider::GpuRasterBuffer::DoLockForWrite() { 414 void ResourceProvider::GpuRasterBuffer::LockForWrite() {
415 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
416 "ResourceProvider::GpuRasterBuffer::LockForWrite");
417
447 if (!surface_) 418 if (!surface_)
448 surface_ = CreateSurface(); 419 surface_ = CreateSurface();
449 surface_generation_id_ = surface_ ? surface_->generationID() : 0u; 420 surface_generation_id_ = surface_ ? surface_->generationID() : 0u;
450 return surface_ ? surface_->getCanvas() : NULL; 421
422 DCHECK(!locked_canvas_);
423 locked_canvas_ = surface_ ? surface_->getCanvas() : NULL;
424 canvas_save_count_ = locked_canvas_ ? locked_canvas_->save() : 0;
451 } 425 }
452 426
453 bool ResourceProvider::GpuRasterBuffer::DoUnlockForWrite() { 427 bool ResourceProvider::GpuRasterBuffer::UnlockForWrite() {
428 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
429 "ResourceProvider::GpuRasterBuffer::UnlockForWrite");
430
431 if (locked_canvas_) {
432 locked_canvas_->restoreToCount(canvas_save_count_);
433 locked_canvas_ = NULL;
434 }
435
454 // generationID returns a non-zero, unique value corresponding to the content 436 // generationID returns a non-zero, unique value corresponding to the content
455 // of surface. Hence, a change since DoLockForWrite was called means the 437 // of surface. Hence, a change since DoLockForWrite was called means the
456 // surface has changed. 438 // surface has changed.
457 return surface_ ? surface_generation_id_ != surface_->generationID() : false; 439 return surface_ ? surface_generation_id_ != surface_->generationID() : false;
458 } 440 }
459 441
442 SkCanvas* ResourceProvider::GpuRasterBuffer::GetSkCanvas() {
443 return locked_canvas_;
444 }
445
460 skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() { 446 skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() {
461 DCHECK_EQ(GLTexture, resource()->type); 447 DCHECK_EQ(GLTexture, resource()->type);
462 DCHECK(resource()->gl_id); 448 DCHECK(resource()->gl_id);
463 449
464 class GrContext* gr_context = resource_provider()->GrContext(); 450 class GrContext* gr_context = resource_provider()->GrContext();
465 // TODO(alokp): Implement TestContextProvider::GrContext(). 451 // TODO(alokp): Implement TestContextProvider::GrContext().
466 if (!gr_context) 452 if (!gr_context)
467 return skia::RefPtr<SkSurface>(); 453 return skia::RefPtr<SkSurface>();
468 454
469 GrBackendTextureDesc desc; 455 GrBackendTextureDesc desc;
470 desc.fFlags = kRenderTarget_GrBackendTextureFlag; 456 desc.fFlags = kRenderTarget_GrBackendTextureFlag;
471 desc.fWidth = resource()->size.width(); 457 desc.fWidth = resource()->size.width();
472 desc.fHeight = resource()->size.height(); 458 desc.fHeight = resource()->size.height();
473 desc.fConfig = ToGrPixelConfig(resource()->format); 459 desc.fConfig = ToGrPixelConfig(resource()->format);
474 desc.fOrigin = kTopLeft_GrSurfaceOrigin; 460 desc.fOrigin = kTopLeft_GrSurfaceOrigin;
475 desc.fTextureHandle = resource()->gl_id; 461 desc.fTextureHandle = resource()->gl_id;
476 skia::RefPtr<GrTexture> gr_texture = 462 skia::RefPtr<GrTexture> gr_texture =
477 skia::AdoptRef(gr_context->wrapBackendTexture(desc)); 463 skia::AdoptRef(gr_context->wrapBackendTexture(desc));
478 SkSurface::TextRenderMode text_render_mode = 464 SkSurface::TextRenderMode text_render_mode =
479 use_distance_field_text_ ? SkSurface::kDistanceField_TextRenderMode 465 use_distance_field_text_ ? SkSurface::kDistanceField_TextRenderMode
480 : SkSurface::kStandard_TextRenderMode; 466 : SkSurface::kStandard_TextRenderMode;
481 return skia::AdoptRef(SkSurface::NewRenderTargetDirect( 467 return skia::AdoptRef(SkSurface::NewRenderTargetDirect(
482 gr_texture->asRenderTarget(), text_render_mode)); 468 gr_texture->asRenderTarget(), text_render_mode));
483 } 469 }
484 470
485 ResourceProvider::BitmapRasterBuffer::BitmapRasterBuffer( 471 ResourceProvider::BitmapRasterBuffer::BitmapRasterBuffer(
486 const Resource* resource, 472 const Resource* resource,
487 ResourceProvider* resource_provider) 473 ResourceProvider* resource_provider)
488 : RasterBuffer(resource, resource_provider), 474 : resource_(resource),
475 resource_provider_(resource_provider),
476 canvas_save_count_(0),
489 mapped_buffer_(NULL), 477 mapped_buffer_(NULL),
490 raster_bitmap_generation_id_(0u) {} 478 raster_bitmap_generation_id_(0u) {
479 }
491 480
492 ResourceProvider::BitmapRasterBuffer::~BitmapRasterBuffer() {} 481 ResourceProvider::BitmapRasterBuffer::~BitmapRasterBuffer() {}
493 482
494 SkCanvas* ResourceProvider::BitmapRasterBuffer::DoLockForWrite() { 483 void ResourceProvider::BitmapRasterBuffer::LockForWrite() {
484 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
485 "ResourceProvider::BitmapRasterBuffer::LockForWrite");
486
495 DCHECK(!mapped_buffer_); 487 DCHECK(!mapped_buffer_);
496 DCHECK(!raster_canvas_); 488 DCHECK(!raster_canvas_);
497 489
498 int stride = 0; 490 int stride = 0;
499 mapped_buffer_ = MapBuffer(&stride); 491 mapped_buffer_ = MapBuffer(&stride);
500 if (!mapped_buffer_) 492 if (!mapped_buffer_)
501 return NULL; 493 return;
502 494
503 switch (resource()->format) { 495 switch (resource()->format) {
504 case RGBA_4444: 496 case RGBA_4444:
505 // Use the default stride if we will eventually convert this 497 // Use the default stride if we will eventually convert this
506 // bitmap to 4444. 498 // bitmap to 4444.
507 raster_bitmap_.allocN32Pixels(resource()->size.width(), 499 raster_bitmap_.allocN32Pixels(resource()->size.width(),
508 resource()->size.height()); 500 resource()->size.height());
509 break; 501 break;
510 case RGBA_8888: 502 case RGBA_8888:
511 case BGRA_8888: { 503 case BGRA_8888: {
512 SkImageInfo info = SkImageInfo::MakeN32Premul(resource()->size.width(), 504 SkImageInfo info = SkImageInfo::MakeN32Premul(resource()->size.width(),
513 resource()->size.height()); 505 resource()->size.height());
514 if (0 == stride) 506 if (0 == stride)
515 stride = info.minRowBytes(); 507 stride = info.minRowBytes();
516 raster_bitmap_.installPixels(info, mapped_buffer_, stride); 508 raster_bitmap_.installPixels(info, mapped_buffer_, stride);
517 break; 509 break;
518 } 510 }
519 case LUMINANCE_8: 511 case LUMINANCE_8:
520 case RGB_565: 512 case RGB_565:
521 case ETC1: 513 case ETC1:
522 NOTREACHED(); 514 NOTREACHED();
523 break; 515 break;
524 } 516 }
517
525 raster_canvas_ = skia::AdoptRef(new SkCanvas(raster_bitmap_)); 518 raster_canvas_ = skia::AdoptRef(new SkCanvas(raster_bitmap_));
526 raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID(); 519 raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID();
527 return raster_canvas_.get(); 520 canvas_save_count_ = raster_canvas_->save();
528 } 521 }
529 522
530 bool ResourceProvider::BitmapRasterBuffer::DoUnlockForWrite() { 523 bool ResourceProvider::BitmapRasterBuffer::UnlockForWrite() {
531 raster_canvas_.clear(); 524 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
525 "ResourceProvider::BitmapRasterBuffer::UnlockForWrite");
532 526
533 // getGenerationID returns a non-zero, unique value corresponding to the 527 if (raster_canvas_) {
534 // pixels in bitmap. Hence, a change since DoLockForWrite was called means the 528 raster_canvas_->restoreToCount(canvas_save_count_);
535 // bitmap has changed. 529 raster_canvas_.clear();
530 }
531
536 bool raster_bitmap_changed = 532 bool raster_bitmap_changed =
537 raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID(); 533 raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID();
538
539 if (raster_bitmap_changed) {
540 SkColorType buffer_colorType =
541 ResourceFormatToSkColorType(resource()->format);
542 if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType()))
543 CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType);
544 }
545 raster_bitmap_.reset(); 534 raster_bitmap_.reset();
546 535
547 UnmapBuffer(); 536 UnmapBuffer();
548 mapped_buffer_ = NULL; 537 mapped_buffer_ = NULL;
549 return raster_bitmap_changed; 538 return raster_bitmap_changed;
550 } 539 }
551 540
541 SkCanvas* ResourceProvider::BitmapRasterBuffer::GetSkCanvas() {
542 return raster_canvas_.get();
543 }
544
545 void ResourceProvider::BitmapRasterBuffer::Flush() {
546 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
547 "ResourceProvider::BitmapRasterBuffer::Flush");
548 // Note that this function is called from a worker thread.
549
550 // getGenerationID returns a non-zero, unique value corresponding to the
551 // pixels in bitmap. Hence, a change since DoLockForWrite was called means the
552 // bitmap has changed.
553 bool raster_bitmap_changed =
554 raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID();
555 if (raster_bitmap_changed) {
556 SkColorType buffer_colorType =
557 ResourceFormatToSkColorType(resource()->format);
558 if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType()))
559 CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType);
560 }
561 }
562
552 ResourceProvider::ImageRasterBuffer::ImageRasterBuffer( 563 ResourceProvider::ImageRasterBuffer::ImageRasterBuffer(
553 const Resource* resource, 564 const Resource* resource,
554 ResourceProvider* resource_provider) 565 ResourceProvider* resource_provider)
555 : BitmapRasterBuffer(resource, resource_provider) {} 566 : BitmapRasterBuffer(resource, resource_provider) {}
556 567
557 ResourceProvider::ImageRasterBuffer::~ImageRasterBuffer() {} 568 ResourceProvider::ImageRasterBuffer::~ImageRasterBuffer() {}
558 569
559 uint8_t* ResourceProvider::ImageRasterBuffer::MapBuffer(int* stride) { 570 uint8_t* ResourceProvider::ImageRasterBuffer::MapBuffer(int* stride) {
560 return resource_provider()->MapImage(resource(), stride); 571 return resource_provider()->MapImage(resource(), stride);
561 } 572 }
(...skipping 1158 matching lines...) Expand 10 before | Expand all | Expand 10 after
1720 if (!to_return.empty()) 1731 if (!to_return.empty())
1721 child_info->return_callback.Run(to_return); 1732 child_info->return_callback.Run(to_return);
1722 1733
1723 if (child_info->marked_for_deletion && 1734 if (child_info->marked_for_deletion &&
1724 child_info->parent_to_child_map.empty()) { 1735 child_info->parent_to_child_map.empty()) {
1725 DCHECK(child_info->child_to_parent_map.empty()); 1736 DCHECK(child_info->child_to_parent_map.empty());
1726 children_.erase(child_it); 1737 children_.erase(child_it);
1727 } 1738 }
1728 } 1739 }
1729 1740
1730 SkCanvas* ResourceProvider::MapGpuRasterBuffer(ResourceId id) { 1741 RasterBuffer* ResourceProvider::MapGpuRasterBuffer(ResourceId id) {
1731 // Resource needs to be locked for write since GpuRasterBuffer writes 1742 // Resource needs to be locked for write since GpuRasterBuffer writes
1732 // directly to it. 1743 // directly to it.
1733 LockForWrite(id); 1744 LockForWrite(id);
1734 Resource* resource = GetResource(id); 1745 Resource* resource = GetResource(id);
1735 if (!resource->gpu_raster_buffer.get()) { 1746 if (!resource->gpu_raster_buffer.get()) {
1736 resource->gpu_raster_buffer.reset( 1747 resource->gpu_raster_buffer.reset(
1737 new GpuRasterBuffer(resource, this, use_distance_field_text_)); 1748 new GpuRasterBuffer(resource, this, use_distance_field_text_));
1738 } 1749 }
1739 return resource->gpu_raster_buffer->LockForWrite(); 1750 resource->gpu_raster_buffer->LockForWrite();
1751 return resource->gpu_raster_buffer.get();
1740 } 1752 }
1741 1753
1742 void ResourceProvider::UnmapGpuRasterBuffer(ResourceId id) { 1754 void ResourceProvider::UnmapGpuRasterBuffer(ResourceId id) {
1743 Resource* resource = GetResource(id); 1755 Resource* resource = GetResource(id);
1744 DCHECK(resource->gpu_raster_buffer.get()); 1756 DCHECK(resource->gpu_raster_buffer.get());
1745 resource->gpu_raster_buffer->UnlockForWrite(); 1757 resource->gpu_raster_buffer->UnlockForWrite();
1746 UnlockForWrite(id); 1758 UnlockForWrite(id);
1747 } 1759 }
1748 1760
1749 SkCanvas* ResourceProvider::MapImageRasterBuffer(ResourceId id) { 1761 RasterBuffer* ResourceProvider::MapImageRasterBuffer(ResourceId id) {
1750 Resource* resource = GetResource(id); 1762 Resource* resource = GetResource(id);
1751 AcquireImage(resource); 1763 AcquireImage(resource);
1752 if (!resource->image_raster_buffer.get()) 1764 if (!resource->image_raster_buffer.get())
1753 resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this)); 1765 resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this));
1754 return resource->image_raster_buffer->LockForWrite(); 1766 resource->image_raster_buffer->LockForWrite();
1767 return resource->image_raster_buffer.get();
1755 } 1768 }
1756 1769
1757 bool ResourceProvider::UnmapImageRasterBuffer(ResourceId id) { 1770 bool ResourceProvider::UnmapImageRasterBuffer(ResourceId id) {
1758 Resource* resource = GetResource(id); 1771 Resource* resource = GetResource(id);
1759 resource->dirty_image = true; 1772 resource->dirty_image = true;
1760 return resource->image_raster_buffer->UnlockForWrite(); 1773 return resource->image_raster_buffer->UnlockForWrite();
1761 } 1774 }
1762 1775
1763 void ResourceProvider::AcquirePixelRasterBuffer(ResourceId id) { 1776 void ResourceProvider::AcquirePixelRasterBuffer(ResourceId id) {
1764 Resource* resource = GetResource(id); 1777 Resource* resource = GetResource(id);
1765 AcquirePixelBuffer(resource); 1778 AcquirePixelBuffer(resource);
1766 resource->pixel_raster_buffer.reset(new PixelRasterBuffer(resource, this)); 1779 resource->pixel_raster_buffer.reset(new PixelRasterBuffer(resource, this));
1767 } 1780 }
1768 1781
1769 void ResourceProvider::ReleasePixelRasterBuffer(ResourceId id) { 1782 void ResourceProvider::ReleasePixelRasterBuffer(ResourceId id) {
1770 Resource* resource = GetResource(id); 1783 Resource* resource = GetResource(id);
1771 resource->pixel_raster_buffer.reset(); 1784 resource->pixel_raster_buffer.reset();
1772 ReleasePixelBuffer(resource); 1785 ReleasePixelBuffer(resource);
1773 } 1786 }
1774 1787
1775 SkCanvas* ResourceProvider::MapPixelRasterBuffer(ResourceId id) { 1788 RasterBuffer* ResourceProvider::MapPixelRasterBuffer(ResourceId id) {
1776 Resource* resource = GetResource(id); 1789 Resource* resource = GetResource(id);
1777 DCHECK(resource->pixel_raster_buffer.get()); 1790 DCHECK(resource->pixel_raster_buffer.get());
1778 return resource->pixel_raster_buffer->LockForWrite(); 1791 resource->pixel_raster_buffer->LockForWrite();
1792 return resource->pixel_raster_buffer.get();
1779 } 1793 }
1780 1794
1781 bool ResourceProvider::UnmapPixelRasterBuffer(ResourceId id) { 1795 bool ResourceProvider::UnmapPixelRasterBuffer(ResourceId id) {
1782 Resource* resource = GetResource(id); 1796 Resource* resource = GetResource(id);
1783 DCHECK(resource->pixel_raster_buffer.get()); 1797 DCHECK(resource->pixel_raster_buffer.get());
1784 return resource->pixel_raster_buffer->UnlockForWrite(); 1798 return resource->pixel_raster_buffer->UnlockForWrite();
1785 } 1799 }
1786 1800
1787 void ResourceProvider::AcquirePixelBuffer(Resource* resource) { 1801 void ResourceProvider::AcquirePixelBuffer(Resource* resource) {
1788 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), 1802 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
(...skipping 463 matching lines...) Expand 10 before | Expand all | Expand 10 after
2252 ContextProvider* context_provider = output_surface_->context_provider(); 2266 ContextProvider* context_provider = output_surface_->context_provider();
2253 return context_provider ? context_provider->ContextGL() : NULL; 2267 return context_provider ? context_provider->ContextGL() : NULL;
2254 } 2268 }
2255 2269
2256 class GrContext* ResourceProvider::GrContext() const { 2270 class GrContext* ResourceProvider::GrContext() const {
2257 ContextProvider* context_provider = output_surface_->context_provider(); 2271 ContextProvider* context_provider = output_surface_->context_provider();
2258 return context_provider ? context_provider->GrContext() : NULL; 2272 return context_provider ? context_provider->GrContext() : NULL;
2259 } 2273 }
2260 2274
2261 } // namespace cc 2275 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698