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 #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 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
104 return kBGRA_8888_GrPixelConfig; | 104 return kBGRA_8888_GrPixelConfig; |
105 case RGBA_4444: | 105 case RGBA_4444: |
106 return kRGBA_4444_GrPixelConfig; | 106 return kRGBA_4444_GrPixelConfig; |
107 default: | 107 default: |
108 break; | 108 break; |
109 } | 109 } |
110 DCHECK(false) << "Unsupported resource format."; | 110 DCHECK(false) << "Unsupported resource format."; |
111 return kSkia8888_GrPixelConfig; | 111 return kSkia8888_GrPixelConfig; |
112 } | 112 } |
113 | 113 |
| 114 void MakeBitmap(SkBitmap* bitmap, |
| 115 uint8_t* buffer, |
| 116 ResourceFormat format, |
| 117 const gfx::Size& size, |
| 118 int stride) { |
| 119 switch (format) { |
| 120 case RGBA_4444: |
| 121 // Use the default stride if we will eventually convert this |
| 122 // bitmap to 4444. |
| 123 bitmap->allocN32Pixels(size.width(), size.height()); |
| 124 break; |
| 125 case RGBA_8888: |
| 126 case BGRA_8888: { |
| 127 SkImageInfo info = |
| 128 SkImageInfo::MakeN32Premul(size.width(), size.height()); |
| 129 if (0 == stride) |
| 130 stride = info.minRowBytes(); |
| 131 bitmap->installPixels(info, buffer, stride); |
| 132 break; |
| 133 } |
| 134 case ALPHA_8: |
| 135 case LUMINANCE_8: |
| 136 case RGB_565: |
| 137 case ETC1: |
| 138 NOTREACHED(); |
| 139 break; |
| 140 } |
| 141 } |
| 142 |
114 void CopyBitmap(const SkBitmap& src, uint8_t* dst, SkColorType dst_color_type) { | 143 void CopyBitmap(const SkBitmap& src, uint8_t* dst, SkColorType dst_color_type) { |
115 SkImageInfo dst_info = src.info(); | 144 SkImageInfo dst_info = src.info(); |
116 dst_info.fColorType = dst_color_type; | 145 dst_info.fColorType = dst_color_type; |
117 // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the | 146 // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the |
118 // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728 | 147 // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728 |
119 // is fixed. | 148 // is fixed. |
120 const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes()); | 149 const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes()); |
121 CHECK_EQ(0u, dst_row_bytes % 4); | 150 CHECK_EQ(0u, dst_row_bytes % 4); |
122 bool success = src.readPixels(dst_info, dst, dst_row_bytes, 0, 0); | 151 bool success = src.readPixels(dst_info, dst, dst_row_bytes, 0, 0); |
123 CHECK_EQ(true, success); | 152 CHECK_EQ(true, success); |
(...skipping 258 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
382 texture_pool(0), | 411 texture_pool(0), |
383 wrap_mode(wrap_mode), | 412 wrap_mode(wrap_mode), |
384 hint(TextureHintImmutable), | 413 hint(TextureHintImmutable), |
385 type(Bitmap), | 414 type(Bitmap), |
386 format(RGBA_8888), | 415 format(RGBA_8888), |
387 shared_bitmap_id(bitmap_id), | 416 shared_bitmap_id(bitmap_id), |
388 shared_bitmap(NULL) { | 417 shared_bitmap(NULL) { |
389 DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT); | 418 DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT); |
390 } | 419 } |
391 | 420 |
392 ResourceProvider::RasterBuffer::RasterBuffer( | |
393 const Resource* resource, | |
394 ResourceProvider* resource_provider) | |
395 : resource_(resource), | |
396 resource_provider_(resource_provider), | |
397 locked_canvas_(NULL), | |
398 canvas_save_count_(0) { | |
399 DCHECK(resource_); | |
400 DCHECK(resource_provider_); | |
401 } | |
402 | |
403 ResourceProvider::RasterBuffer::~RasterBuffer() {} | |
404 | |
405 SkCanvas* ResourceProvider::RasterBuffer::LockForWrite() { | |
406 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | |
407 "ResourceProvider::RasterBuffer::LockForWrite"); | |
408 | |
409 DCHECK(!locked_canvas_); | |
410 | |
411 locked_canvas_ = DoLockForWrite(); | |
412 canvas_save_count_ = locked_canvas_ ? locked_canvas_->save() : 0; | |
413 return locked_canvas_; | |
414 } | |
415 | |
416 bool ResourceProvider::RasterBuffer::UnlockForWrite() { | |
417 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | |
418 "ResourceProvider::RasterBuffer::UnlockForWrite"); | |
419 | |
420 if (locked_canvas_) { | |
421 locked_canvas_->restoreToCount(canvas_save_count_); | |
422 locked_canvas_ = NULL; | |
423 } | |
424 return DoUnlockForWrite(); | |
425 } | |
426 | |
427 ResourceProvider::GpuRasterBuffer::GpuRasterBuffer( | 421 ResourceProvider::GpuRasterBuffer::GpuRasterBuffer( |
428 const Resource* resource, | 422 const Resource* resource, |
429 ResourceProvider* resource_provider, | 423 ResourceProvider* resource_provider, |
430 bool use_distance_field_text) | 424 bool use_distance_field_text) |
431 : RasterBuffer(resource, resource_provider), | 425 : resource_(resource), resource_provider_(resource_provider) { |
432 surface_generation_id_(0u), | 426 DCHECK_EQ(GLTexture, resource_->type); |
433 use_distance_field_text_(use_distance_field_text) { | 427 DCHECK(resource_->gl_id); |
| 428 |
| 429 class GrContext* gr_context = resource_provider_->GrContext(); |
| 430 // TODO(alokp): Implement TestContextProvider::GrContext(). |
| 431 if (gr_context) { |
| 432 GrBackendTextureDesc desc; |
| 433 desc.fFlags = kRenderTarget_GrBackendTextureFlag; |
| 434 desc.fWidth = resource_->size.width(); |
| 435 desc.fHeight = resource_->size.height(); |
| 436 desc.fConfig = ToGrPixelConfig(resource_->format); |
| 437 desc.fOrigin = kTopLeft_GrSurfaceOrigin; |
| 438 desc.fTextureHandle = resource_->gl_id; |
| 439 skia::RefPtr<GrTexture> gr_texture = |
| 440 skia::AdoptRef(gr_context->wrapBackendTexture(desc)); |
| 441 SkSurface::TextRenderMode text_render_mode = |
| 442 use_distance_field_text ? SkSurface::kDistanceField_TextRenderMode |
| 443 : SkSurface::kStandard_TextRenderMode; |
| 444 surface_ = skia::AdoptRef(SkSurface::NewRenderTargetDirect( |
| 445 gr_texture->asRenderTarget(), text_render_mode)); |
| 446 } |
434 } | 447 } |
435 | 448 |
436 ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() { | 449 ResourceProvider::GpuRasterBuffer::~GpuRasterBuffer() { |
437 } | 450 } |
438 | 451 |
439 SkCanvas* ResourceProvider::GpuRasterBuffer::DoLockForWrite() { | 452 skia::RefPtr<SkCanvas> ResourceProvider::GpuRasterBuffer::AcquireSkCanvas() { |
440 if (!surface_) | 453 // Note that this function is called from a worker thread. |
441 surface_ = CreateSurface(); | 454 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
442 surface_generation_id_ = surface_ ? surface_->generationID() : 0u; | 455 "ResourceProvider::GpuRasterBuffer::AcquireSkCanvas"); |
443 return surface_ ? surface_->getCanvas() : NULL; | 456 |
| 457 return surface_ ? skia::SharePtr(surface_->getCanvas()) |
| 458 : skia::RefPtr<SkCanvas>(); |
444 } | 459 } |
445 | 460 |
446 bool ResourceProvider::GpuRasterBuffer::DoUnlockForWrite() { | 461 void ResourceProvider::GpuRasterBuffer::ReleaseSkCanvas( |
447 // generationID returns a non-zero, unique value corresponding to the content | 462 const skia::RefPtr<SkCanvas>& canvas) { |
448 // of surface. Hence, a change since DoLockForWrite was called means the | 463 // Note that this function is called from a worker thread. |
449 // surface has changed. | 464 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
450 return surface_ ? surface_generation_id_ != surface_->generationID() : false; | 465 "ResourceProvider::GpuRasterBuffer::ReleaseSkCanvas"); |
451 } | |
452 | |
453 skia::RefPtr<SkSurface> ResourceProvider::GpuRasterBuffer::CreateSurface() { | |
454 DCHECK_EQ(GLTexture, resource()->type); | |
455 DCHECK(resource()->gl_id); | |
456 | |
457 class GrContext* gr_context = resource_provider()->GrContext(); | |
458 // TODO(alokp): Implement TestContextProvider::GrContext(). | |
459 if (!gr_context) | |
460 return skia::RefPtr<SkSurface>(); | |
461 | |
462 GrBackendTextureDesc desc; | |
463 desc.fFlags = kRenderTarget_GrBackendTextureFlag; | |
464 desc.fWidth = resource()->size.width(); | |
465 desc.fHeight = resource()->size.height(); | |
466 desc.fConfig = ToGrPixelConfig(resource()->format); | |
467 desc.fOrigin = kTopLeft_GrSurfaceOrigin; | |
468 desc.fTextureHandle = resource()->gl_id; | |
469 skia::RefPtr<GrTexture> gr_texture = | |
470 skia::AdoptRef(gr_context->wrapBackendTexture(desc)); | |
471 SkSurface::TextRenderMode text_render_mode = | |
472 use_distance_field_text_ ? SkSurface::kDistanceField_TextRenderMode | |
473 : SkSurface::kStandard_TextRenderMode; | |
474 return skia::AdoptRef(SkSurface::NewRenderTargetDirect( | |
475 gr_texture->asRenderTarget(), text_render_mode)); | |
476 } | |
477 | |
478 ResourceProvider::BitmapRasterBuffer::BitmapRasterBuffer( | |
479 const Resource* resource, | |
480 ResourceProvider* resource_provider) | |
481 : RasterBuffer(resource, resource_provider), | |
482 mapped_buffer_(NULL), | |
483 raster_bitmap_generation_id_(0u) {} | |
484 | |
485 ResourceProvider::BitmapRasterBuffer::~BitmapRasterBuffer() {} | |
486 | |
487 SkCanvas* ResourceProvider::BitmapRasterBuffer::DoLockForWrite() { | |
488 DCHECK(!mapped_buffer_); | |
489 DCHECK(!raster_canvas_); | |
490 | |
491 int stride = 0; | |
492 mapped_buffer_ = MapBuffer(&stride); | |
493 if (!mapped_buffer_) | |
494 return NULL; | |
495 | |
496 switch (resource()->format) { | |
497 case RGBA_4444: | |
498 // Use the default stride if we will eventually convert this | |
499 // bitmap to 4444. | |
500 raster_bitmap_.allocN32Pixels(resource()->size.width(), | |
501 resource()->size.height()); | |
502 break; | |
503 case RGBA_8888: | |
504 case BGRA_8888: { | |
505 SkImageInfo info = SkImageInfo::MakeN32Premul(resource()->size.width(), | |
506 resource()->size.height()); | |
507 if (0 == stride) | |
508 stride = info.minRowBytes(); | |
509 raster_bitmap_.installPixels(info, mapped_buffer_, stride); | |
510 break; | |
511 } | |
512 case ALPHA_8: | |
513 case LUMINANCE_8: | |
514 case RGB_565: | |
515 case ETC1: | |
516 NOTREACHED(); | |
517 break; | |
518 } | |
519 raster_canvas_ = skia::AdoptRef(new SkCanvas(raster_bitmap_)); | |
520 raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID(); | |
521 return raster_canvas_.get(); | |
522 } | |
523 | |
524 bool ResourceProvider::BitmapRasterBuffer::DoUnlockForWrite() { | |
525 raster_canvas_.clear(); | |
526 | |
527 // getGenerationID returns a non-zero, unique value corresponding to the | |
528 // pixels in bitmap. Hence, a change since DoLockForWrite was called means the | |
529 // bitmap has changed. | |
530 bool raster_bitmap_changed = | |
531 raster_bitmap_generation_id_ != raster_bitmap_.getGenerationID(); | |
532 | |
533 if (raster_bitmap_changed) { | |
534 SkColorType buffer_colorType = | |
535 ResourceFormatToSkColorType(resource()->format); | |
536 if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType())) | |
537 CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType); | |
538 } | |
539 raster_bitmap_.reset(); | |
540 | |
541 UnmapBuffer(); | |
542 mapped_buffer_ = NULL; | |
543 return raster_bitmap_changed; | |
544 } | 466 } |
545 | 467 |
546 ResourceProvider::ImageRasterBuffer::ImageRasterBuffer( | 468 ResourceProvider::ImageRasterBuffer::ImageRasterBuffer( |
547 const Resource* resource, | 469 const Resource* resource, |
548 ResourceProvider* resource_provider) | 470 ResourceProvider* resource_provider) |
549 : BitmapRasterBuffer(resource, resource_provider) {} | 471 : resource_(resource), |
550 | 472 resource_provider_(resource_provider), |
551 ResourceProvider::ImageRasterBuffer::~ImageRasterBuffer() {} | 473 mapped_buffer_(NULL), |
552 | 474 raster_bitmap_changed_(false), |
553 uint8_t* ResourceProvider::ImageRasterBuffer::MapBuffer(int* stride) { | 475 stride_(0) { |
554 return resource_provider()->MapImage(resource(), stride); | |
555 } | 476 } |
556 | 477 |
557 void ResourceProvider::ImageRasterBuffer::UnmapBuffer() { | 478 ResourceProvider::ImageRasterBuffer::~ImageRasterBuffer() { |
558 resource_provider()->UnmapImage(resource()); | 479 } |
| 480 |
| 481 void ResourceProvider::ImageRasterBuffer::MapBuffer() { |
| 482 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 483 "ResourceProvider::ImageRasterBuffer::MapBuffer"); |
| 484 |
| 485 DCHECK(!mapped_buffer_); |
| 486 |
| 487 stride_ = 0; |
| 488 mapped_buffer_ = resource_provider_->MapImage(resource_, &stride_); |
| 489 raster_bitmap_changed_ = false; |
| 490 } |
| 491 |
| 492 bool ResourceProvider::ImageRasterBuffer::UnmapBuffer() { |
| 493 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 494 "ResourceProvider::ImageRasterBuffer::UnmapBuffer"); |
| 495 |
| 496 if (mapped_buffer_) { |
| 497 resource_provider_->UnmapImage(resource_); |
| 498 mapped_buffer_ = NULL; |
| 499 } |
| 500 return raster_bitmap_changed_; |
| 501 } |
| 502 |
| 503 skia::RefPtr<SkCanvas> ResourceProvider::ImageRasterBuffer::AcquireSkCanvas() { |
| 504 // Note that this function is called from a worker thread. |
| 505 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 506 "ResourceProvider::ImageRasterBuffer::AcquireSkCanvas"); |
| 507 |
| 508 if (!mapped_buffer_) |
| 509 return skia::RefPtr<SkCanvas>(); |
| 510 |
| 511 MakeBitmap(&raster_bitmap_, |
| 512 mapped_buffer_, |
| 513 resource_->format, |
| 514 resource_->size, |
| 515 stride_); |
| 516 raster_bitmap_changed_ = true; |
| 517 return skia::AdoptRef(new SkCanvas(raster_bitmap_)); |
| 518 } |
| 519 |
| 520 void ResourceProvider::ImageRasterBuffer::ReleaseSkCanvas( |
| 521 const skia::RefPtr<SkCanvas>& canvas) { |
| 522 // Note that this function is called from a worker thread. |
| 523 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 524 "ResourceProvider::ImageRasterBuffer::ReleaseSkCanvas"); |
| 525 |
| 526 SkColorType buffer_colorType = ResourceFormatToSkColorType(resource_->format); |
| 527 if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType())) |
| 528 CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType); |
| 529 raster_bitmap_.reset(); |
559 } | 530 } |
560 | 531 |
561 ResourceProvider::PixelRasterBuffer::PixelRasterBuffer( | 532 ResourceProvider::PixelRasterBuffer::PixelRasterBuffer( |
562 const Resource* resource, | 533 const Resource* resource, |
563 ResourceProvider* resource_provider) | 534 ResourceProvider* resource_provider) |
564 : BitmapRasterBuffer(resource, resource_provider) {} | 535 : resource_(resource), |
565 | 536 resource_provider_(resource_provider), |
566 ResourceProvider::PixelRasterBuffer::~PixelRasterBuffer() {} | 537 mapped_buffer_(NULL), |
567 | 538 raster_bitmap_changed_(false), |
568 uint8_t* ResourceProvider::PixelRasterBuffer::MapBuffer(int* stride) { | 539 stride_(0) { |
569 return resource_provider()->MapPixelBuffer(resource(), stride); | |
570 } | 540 } |
571 | 541 |
572 void ResourceProvider::PixelRasterBuffer::UnmapBuffer() { | 542 ResourceProvider::PixelRasterBuffer::~PixelRasterBuffer() { |
573 resource_provider()->UnmapPixelBuffer(resource()); | 543 } |
| 544 |
| 545 void ResourceProvider::PixelRasterBuffer::MapBuffer() { |
| 546 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 547 "ResourceProvider::PixelRasterBuffer::MapBuffer"); |
| 548 |
| 549 DCHECK(!mapped_buffer_); |
| 550 |
| 551 stride_ = 0; |
| 552 mapped_buffer_ = resource_provider_->MapPixelBuffer(resource_, &stride_); |
| 553 raster_bitmap_changed_ = false; |
| 554 } |
| 555 |
| 556 bool ResourceProvider::PixelRasterBuffer::UnmapBuffer() { |
| 557 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 558 "ResourceProvider::PixelRasterBuffer::UnmapBuffer"); |
| 559 |
| 560 if (mapped_buffer_) { |
| 561 resource_provider_->UnmapPixelBuffer(resource_); |
| 562 mapped_buffer_ = NULL; |
| 563 } |
| 564 return raster_bitmap_changed_; |
| 565 } |
| 566 |
| 567 skia::RefPtr<SkCanvas> ResourceProvider::PixelRasterBuffer::AcquireSkCanvas() { |
| 568 // Note that this function is called from a worker thread. |
| 569 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 570 "ResourceProvider::PixelRasterBuffer::AcquireSkCanvas"); |
| 571 |
| 572 if (!mapped_buffer_) |
| 573 return skia::RefPtr<SkCanvas>(); |
| 574 |
| 575 MakeBitmap(&raster_bitmap_, |
| 576 mapped_buffer_, |
| 577 resource_->format, |
| 578 resource_->size, |
| 579 stride_); |
| 580 raster_bitmap_changed_ = true; |
| 581 return skia::AdoptRef(new SkCanvas(raster_bitmap_)); |
| 582 } |
| 583 |
| 584 void ResourceProvider::PixelRasterBuffer::ReleaseSkCanvas( |
| 585 const skia::RefPtr<SkCanvas>& canvas) { |
| 586 // Note that this function is called from a worker thread. |
| 587 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| 588 "ResourceProvider::PixelRasterBuffer::ReleaseSkCanvas"); |
| 589 |
| 590 SkColorType buffer_colorType = ResourceFormatToSkColorType(resource_->format); |
| 591 if (mapped_buffer_ && (buffer_colorType != raster_bitmap_.colorType())) |
| 592 CopyBitmap(raster_bitmap_, mapped_buffer_, buffer_colorType); |
| 593 raster_bitmap_.reset(); |
574 } | 594 } |
575 | 595 |
576 ResourceProvider::Child::Child() : marked_for_deletion(false) {} | 596 ResourceProvider::Child::Child() : marked_for_deletion(false) {} |
577 | 597 |
578 ResourceProvider::Child::~Child() {} | 598 ResourceProvider::Child::~Child() {} |
579 | 599 |
580 scoped_ptr<ResourceProvider> ResourceProvider::Create( | 600 scoped_ptr<ResourceProvider> ResourceProvider::Create( |
581 OutputSurface* output_surface, | 601 OutputSurface* output_surface, |
582 SharedBitmapManager* shared_bitmap_manager, | 602 SharedBitmapManager* shared_bitmap_manager, |
583 int highp_threshold_min, | 603 int highp_threshold_min, |
(...skipping 1131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1715 if (!to_return.empty()) | 1735 if (!to_return.empty()) |
1716 child_info->return_callback.Run(to_return); | 1736 child_info->return_callback.Run(to_return); |
1717 | 1737 |
1718 if (child_info->marked_for_deletion && | 1738 if (child_info->marked_for_deletion && |
1719 child_info->parent_to_child_map.empty()) { | 1739 child_info->parent_to_child_map.empty()) { |
1720 DCHECK(child_info->child_to_parent_map.empty()); | 1740 DCHECK(child_info->child_to_parent_map.empty()); |
1721 children_.erase(child_it); | 1741 children_.erase(child_it); |
1722 } | 1742 } |
1723 } | 1743 } |
1724 | 1744 |
1725 SkCanvas* ResourceProvider::MapGpuRasterBuffer(ResourceId id) { | 1745 RasterBuffer* ResourceProvider::AcquireGpuRasterBuffer(ResourceId id) { |
1726 // Resource needs to be locked for write since GpuRasterBuffer writes | 1746 // Resource needs to be locked for write since GpuRasterBuffer writes |
1727 // directly to it. | 1747 // directly to it. |
1728 LockForWrite(id); | 1748 LockForWrite(id); |
1729 Resource* resource = GetResource(id); | 1749 Resource* resource = GetResource(id); |
1730 if (!resource->gpu_raster_buffer.get()) { | 1750 if (!resource->gpu_raster_buffer.get()) { |
1731 resource->gpu_raster_buffer.reset( | 1751 resource->gpu_raster_buffer.reset( |
1732 new GpuRasterBuffer(resource, this, use_distance_field_text_)); | 1752 new GpuRasterBuffer(resource, this, use_distance_field_text_)); |
1733 } | 1753 } |
1734 return resource->gpu_raster_buffer->LockForWrite(); | 1754 return resource->gpu_raster_buffer.get(); |
1735 } | 1755 } |
1736 | 1756 |
1737 void ResourceProvider::UnmapGpuRasterBuffer(ResourceId id) { | 1757 void ResourceProvider::ReleaseGpuRasterBuffer(ResourceId id) { |
1738 Resource* resource = GetResource(id); | 1758 Resource* resource = GetResource(id); |
1739 DCHECK(resource->gpu_raster_buffer.get()); | 1759 DCHECK(resource->gpu_raster_buffer.get()); |
1740 resource->gpu_raster_buffer->UnlockForWrite(); | |
1741 UnlockForWrite(id); | 1760 UnlockForWrite(id); |
1742 } | 1761 } |
1743 | 1762 |
1744 SkCanvas* ResourceProvider::MapImageRasterBuffer(ResourceId id) { | 1763 RasterBuffer* ResourceProvider::AcquireImageRasterBuffer(ResourceId id) { |
1745 Resource* resource = GetResource(id); | 1764 Resource* resource = GetResource(id); |
1746 AcquireImage(resource); | 1765 AcquireImage(resource); |
1747 if (!resource->image_raster_buffer.get()) | 1766 if (!resource->image_raster_buffer.get()) |
1748 resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this)); | 1767 resource->image_raster_buffer.reset(new ImageRasterBuffer(resource, this)); |
1749 return resource->image_raster_buffer->LockForWrite(); | 1768 resource->image_raster_buffer->MapBuffer(); |
| 1769 return resource->image_raster_buffer.get(); |
1750 } | 1770 } |
1751 | 1771 |
1752 bool ResourceProvider::UnmapImageRasterBuffer(ResourceId id) { | 1772 bool ResourceProvider::ReleaseImageRasterBuffer(ResourceId id) { |
1753 Resource* resource = GetResource(id); | 1773 Resource* resource = GetResource(id); |
1754 resource->dirty_image = true; | 1774 resource->dirty_image = true; |
1755 return resource->image_raster_buffer->UnlockForWrite(); | 1775 return resource->image_raster_buffer->UnmapBuffer(); |
1756 } | 1776 } |
1757 | 1777 |
1758 void ResourceProvider::AcquirePixelRasterBuffer(ResourceId id) { | 1778 RasterBuffer* ResourceProvider::AcquirePixelRasterBuffer(ResourceId id) { |
1759 Resource* resource = GetResource(id); | 1779 Resource* resource = GetResource(id); |
1760 AcquirePixelBuffer(resource); | 1780 AcquirePixelBuffer(resource); |
1761 resource->pixel_raster_buffer.reset(new PixelRasterBuffer(resource, this)); | 1781 resource->pixel_raster_buffer.reset(new PixelRasterBuffer(resource, this)); |
| 1782 resource->pixel_raster_buffer->MapBuffer(); |
| 1783 return resource->pixel_raster_buffer.get(); |
1762 } | 1784 } |
1763 | 1785 |
1764 void ResourceProvider::ReleasePixelRasterBuffer(ResourceId id) { | 1786 bool ResourceProvider::ReleasePixelRasterBuffer(ResourceId id) { |
1765 Resource* resource = GetResource(id); | 1787 Resource* resource = GetResource(id); |
| 1788 DCHECK(resource->pixel_raster_buffer.get()); |
| 1789 bool raster_bitmap_changed = resource->pixel_raster_buffer->UnmapBuffer(); |
1766 resource->pixel_raster_buffer.reset(); | 1790 resource->pixel_raster_buffer.reset(); |
1767 ReleasePixelBuffer(resource); | 1791 ReleasePixelBuffer(resource); |
1768 } | 1792 return raster_bitmap_changed; |
1769 | |
1770 SkCanvas* ResourceProvider::MapPixelRasterBuffer(ResourceId id) { | |
1771 Resource* resource = GetResource(id); | |
1772 DCHECK(resource->pixel_raster_buffer.get()); | |
1773 return resource->pixel_raster_buffer->LockForWrite(); | |
1774 } | |
1775 | |
1776 bool ResourceProvider::UnmapPixelRasterBuffer(ResourceId id) { | |
1777 Resource* resource = GetResource(id); | |
1778 DCHECK(resource->pixel_raster_buffer.get()); | |
1779 return resource->pixel_raster_buffer->UnlockForWrite(); | |
1780 } | 1793 } |
1781 | 1794 |
1782 void ResourceProvider::AcquirePixelBuffer(Resource* resource) { | 1795 void ResourceProvider::AcquirePixelBuffer(Resource* resource) { |
1783 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 1796 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
1784 "ResourceProvider::AcquirePixelBuffer"); | 1797 "ResourceProvider::AcquirePixelBuffer"); |
1785 | 1798 |
1786 DCHECK(resource->origin == Resource::Internal); | 1799 DCHECK(resource->origin == Resource::Internal); |
1787 DCHECK_EQ(resource->exported_count, 0); | 1800 DCHECK_EQ(resource->exported_count, 0); |
1788 DCHECK(!resource->image_id); | 1801 DCHECK(!resource->image_id); |
1789 DCHECK_NE(ETC1, resource->format); | 1802 DCHECK_NE(ETC1, resource->format); |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1905 return target; | 1918 return target; |
1906 } | 1919 } |
1907 | 1920 |
1908 void ResourceProvider::BeginSetPixels(ResourceId id) { | 1921 void ResourceProvider::BeginSetPixels(ResourceId id) { |
1909 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 1922 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
1910 "ResourceProvider::BeginSetPixels"); | 1923 "ResourceProvider::BeginSetPixels"); |
1911 | 1924 |
1912 Resource* resource = GetResource(id); | 1925 Resource* resource = GetResource(id); |
1913 DCHECK(!resource->pending_set_pixels); | 1926 DCHECK(!resource->pending_set_pixels); |
1914 | 1927 |
| 1928 DCHECK(resource->pixel_raster_buffer.get()); |
| 1929 bool raster_bitmap_changed = resource->pixel_raster_buffer->UnmapBuffer(); |
| 1930 if (!raster_bitmap_changed) |
| 1931 return; |
| 1932 |
1915 LazyCreate(resource); | 1933 LazyCreate(resource); |
1916 DCHECK(resource->origin == Resource::Internal); | 1934 DCHECK(resource->origin == Resource::Internal); |
1917 DCHECK(resource->gl_id || resource->allocated); | 1935 DCHECK(resource->gl_id || resource->allocated); |
1918 DCHECK(ReadLockFenceHasPassed(resource)); | 1936 DCHECK(ReadLockFenceHasPassed(resource)); |
1919 DCHECK(!resource->image_id); | 1937 DCHECK(!resource->image_id); |
1920 | 1938 |
1921 bool allocate = !resource->allocated; | 1939 bool allocate = !resource->allocated; |
1922 resource->allocated = true; | 1940 resource->allocated = true; |
1923 LockForWrite(id); | 1941 LockForWrite(id); |
1924 | 1942 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1961 | 1979 |
1962 resource->pending_set_pixels = true; | 1980 resource->pending_set_pixels = true; |
1963 resource->set_pixels_completion_forced = false; | 1981 resource->set_pixels_completion_forced = false; |
1964 } | 1982 } |
1965 | 1983 |
1966 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) { | 1984 void ResourceProvider::ForceSetPixelsToComplete(ResourceId id) { |
1967 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 1985 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
1968 "ResourceProvider::ForceSetPixelsToComplete"); | 1986 "ResourceProvider::ForceSetPixelsToComplete"); |
1969 | 1987 |
1970 Resource* resource = GetResource(id); | 1988 Resource* resource = GetResource(id); |
| 1989 |
| 1990 if (!resource->pending_set_pixels) |
| 1991 return; |
| 1992 |
1971 DCHECK(resource->locked_for_write); | 1993 DCHECK(resource->locked_for_write); |
1972 DCHECK(resource->pending_set_pixels); | |
1973 DCHECK(!resource->set_pixels_completion_forced); | 1994 DCHECK(!resource->set_pixels_completion_forced); |
1974 | 1995 |
1975 if (resource->gl_id) { | 1996 if (resource->gl_id) { |
1976 GLES2Interface* gl = ContextGL(); | 1997 GLES2Interface* gl = ContextGL(); |
1977 GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id)); | 1998 GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id)); |
1978 GLC(gl, gl->WaitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)); | 1999 GLC(gl, gl->WaitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)); |
1979 GLC(gl, gl->BindTexture(GL_TEXTURE_2D, 0)); | 2000 GLC(gl, gl->BindTexture(GL_TEXTURE_2D, 0)); |
1980 } | 2001 } |
1981 | 2002 |
1982 resource->set_pixels_completion_forced = true; | 2003 resource->set_pixels_completion_forced = true; |
1983 } | 2004 } |
1984 | 2005 |
1985 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) { | 2006 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) { |
1986 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), | 2007 TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
1987 "ResourceProvider::DidSetPixelsComplete"); | 2008 "ResourceProvider::DidSetPixelsComplete"); |
1988 | 2009 |
1989 Resource* resource = GetResource(id); | 2010 Resource* resource = GetResource(id); |
| 2011 |
| 2012 // Upload can be avoided as a result of raster bitmap not being modified. |
| 2013 // Assume the upload was completed in that case. |
| 2014 if (!resource->pending_set_pixels) |
| 2015 return true; |
| 2016 |
1990 DCHECK(resource->locked_for_write); | 2017 DCHECK(resource->locked_for_write); |
1991 DCHECK(resource->pending_set_pixels); | |
1992 | 2018 |
1993 if (resource->gl_id) { | 2019 if (resource->gl_id) { |
1994 GLES2Interface* gl = ContextGL(); | 2020 GLES2Interface* gl = ContextGL(); |
1995 DCHECK(gl); | 2021 DCHECK(gl); |
1996 DCHECK(resource->gl_upload_query_id); | 2022 DCHECK(resource->gl_upload_query_id); |
1997 GLuint complete = 1; | 2023 GLuint complete = 1; |
1998 gl->GetQueryObjectuivEXT( | 2024 gl->GetQueryObjectuivEXT( |
1999 resource->gl_upload_query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &complete); | 2025 resource->gl_upload_query_id, GL_QUERY_RESULT_AVAILABLE_EXT, &complete); |
2000 if (!complete) | 2026 if (!complete) |
2001 return false; | 2027 return false; |
(...skipping 262 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2264 ContextProvider* context_provider = output_surface_->context_provider().get(); | 2290 ContextProvider* context_provider = output_surface_->context_provider().get(); |
2265 return context_provider ? context_provider->ContextGL() : NULL; | 2291 return context_provider ? context_provider->ContextGL() : NULL; |
2266 } | 2292 } |
2267 | 2293 |
2268 class GrContext* ResourceProvider::GrContext() const { | 2294 class GrContext* ResourceProvider::GrContext() const { |
2269 ContextProvider* context_provider = output_surface_->context_provider().get(); | 2295 ContextProvider* context_provider = output_surface_->context_provider().get(); |
2270 return context_provider ? context_provider->GrContext() : NULL; | 2296 return context_provider ? context_provider->GrContext() : NULL; |
2271 } | 2297 } |
2272 | 2298 |
2273 } // namespace cc | 2299 } // namespace cc |
OLD | NEW |