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/tile_manager.h" | 5 #include "cc/resources/tile_manager.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 #include <string> | 9 #include <string> |
10 | 10 |
(...skipping 263 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
274 void TileManager::CleanUpReleasedTiles() { | 274 void TileManager::CleanUpReleasedTiles() { |
275 std::vector<Tile*>::iterator it = released_tiles_.begin(); | 275 std::vector<Tile*>::iterator it = released_tiles_.begin(); |
276 while (it != released_tiles_.end()) { | 276 while (it != released_tiles_.end()) { |
277 Tile* tile = *it; | 277 Tile* tile = *it; |
278 | 278 |
279 if (tile->HasRasterTask()) { | 279 if (tile->HasRasterTask()) { |
280 ++it; | 280 ++it; |
281 continue; | 281 continue; |
282 } | 282 } |
283 | 283 |
284 DCHECK(!tile->HasResources()); | 284 DCHECK(!tile->HasResource()); |
285 DCHECK(tiles_.find(tile->id()) != tiles_.end()); | 285 DCHECK(tiles_.find(tile->id()) != tiles_.end()); |
286 tiles_.erase(tile->id()); | 286 tiles_.erase(tile->id()); |
287 | 287 |
288 LayerCountMap::iterator layer_it = | 288 LayerCountMap::iterator layer_it = |
289 used_layer_counts_.find(tile->layer_id()); | 289 used_layer_counts_.find(tile->layer_id()); |
290 DCHECK_GT(layer_it->second, 0); | 290 DCHECK_GT(layer_it->second, 0); |
291 if (--layer_it->second == 0) { | 291 if (--layer_it->second == 0) { |
292 used_layer_counts_.erase(layer_it); | 292 used_layer_counts_.erase(layer_it); |
293 image_decode_tasks_.erase(tile->layer_id()); | 293 image_decode_tasks_.erase(tile->layer_id()); |
294 } | 294 } |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
346 // been been assigned memory after reaching a steady memory state. This | 346 // been been assigned memory after reaching a steady memory state. This |
347 // ensures that we activate even when OOM. Note that we have to rebuilt | 347 // ensures that we activate even when OOM. Note that we have to rebuilt |
348 // the | 348 // the |
349 // queue in case the last AssignGpuMemoryToTiles evicted some tiles that | 349 // queue in case the last AssignGpuMemoryToTiles evicted some tiles that |
350 // would otherwise not be picked up by the old raster queue. | 350 // would otherwise not be picked up by the old raster queue. |
351 client_->BuildRasterQueue(&raster_priority_queue_, | 351 client_->BuildRasterQueue(&raster_priority_queue_, |
352 global_state_.tree_priority); | 352 global_state_.tree_priority); |
353 bool ready_to_activate = true; | 353 bool ready_to_activate = true; |
354 while (!raster_priority_queue_.IsEmpty()) { | 354 while (!raster_priority_queue_.IsEmpty()) { |
355 Tile* tile = raster_priority_queue_.Top(); | 355 Tile* tile = raster_priority_queue_.Top(); |
356 ManagedTileState& mts = tile->managed_state(); | 356 TileDrawInfo& draw_info = tile->draw_info(); |
357 | 357 |
358 if (tile->required_for_activation() && !mts.draw_info.IsReadyToDraw()) { | 358 if (tile->required_for_activation() && !draw_info.IsReadyToDraw()) { |
359 // If we can't raster on demand, give up early (and don't activate). | 359 // If we can't raster on demand, give up early (and don't activate). |
360 if (!allow_rasterize_on_demand) { | 360 if (!allow_rasterize_on_demand) { |
361 ready_to_activate = false; | 361 ready_to_activate = false; |
362 break; | 362 break; |
363 } | 363 } |
364 | 364 |
365 mts.draw_info.set_rasterize_on_demand(); | 365 draw_info.set_rasterize_on_demand(); |
366 client_->NotifyTileStateChanged(tile); | 366 client_->NotifyTileStateChanged(tile); |
367 } | 367 } |
368 raster_priority_queue_.Pop(); | 368 raster_priority_queue_.Pop(); |
369 } | 369 } |
370 | 370 |
371 if (ready_to_activate) { | 371 if (ready_to_activate) { |
372 DCHECK(IsReadyToActivate()); | 372 DCHECK(IsReadyToActivate()); |
373 ready_to_activate_check_notifier_.Schedule(); | 373 ready_to_activate_check_notifier_.Schedule(); |
374 } | 374 } |
375 raster_priority_queue_.Reset(); | 375 raster_priority_queue_.Reset(); |
(...skipping 183 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
559 break; | 559 break; |
560 } | 560 } |
561 | 561 |
562 // We won't be able to schedule this tile, so break out early. | 562 // We won't be able to schedule this tile, so break out early. |
563 if (tiles_that_need_to_be_rasterized->size() >= | 563 if (tiles_that_need_to_be_rasterized->size() >= |
564 scheduled_raster_task_limit_) { | 564 scheduled_raster_task_limit_) { |
565 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false; | 565 all_tiles_that_need_to_be_rasterized_are_scheduled_ = false; |
566 break; | 566 break; |
567 } | 567 } |
568 | 568 |
569 ManagedTileState& mts = tile->managed_state(); | 569 TileDrawInfo& draw_info = tile->draw_info(); |
570 mts.scheduled_priority = schedule_priority++; | 570 tile->scheduled_priority_ = schedule_priority++; |
571 mts.resolution = priority.resolution; | |
572 | 571 |
573 DCHECK(mts.draw_info.mode() == | 572 DCHECK(draw_info.mode() == TileDrawInfo::PICTURE_PILE_MODE || |
574 ManagedTileState::DrawInfo::PICTURE_PILE_MODE || | 573 !draw_info.IsReadyToDraw()); |
575 !mts.draw_info.IsReadyToDraw()); | |
576 | 574 |
577 // If the tile already has a raster_task, then the memory used by it is | 575 // If the tile already has a raster_task, then the memory used by it is |
578 // already accounted for in memory_usage. Otherwise, we'll have to acquire | 576 // already accounted for in memory_usage. Otherwise, we'll have to acquire |
579 // more memory to create a raster task. | 577 // more memory to create a raster task. |
580 MemoryUsage memory_required_by_tile_to_be_scheduled; | 578 MemoryUsage memory_required_by_tile_to_be_scheduled; |
581 if (!mts.raster_task.get()) { | 579 if (!tile->raster_task_.get()) { |
582 memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig( | 580 memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig( |
583 tile->size(), resource_pool_->resource_format()); | 581 tile->size(), resource_pool_->resource_format()); |
584 } | 582 } |
585 | 583 |
586 bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW; | 584 bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW; |
587 | 585 |
588 // This is the memory limit that will be used by this tile. Depending on | 586 // This is the memory limit that will be used by this tile. Depending on |
589 // the tile priority, it will be one of hard_memory_limit or | 587 // the tile priority, it will be one of hard_memory_limit or |
590 // soft_memory_limit. | 588 // soft_memory_limit. |
591 MemoryUsage& tile_memory_limit = | 589 MemoryUsage& tile_memory_limit = |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
630 | 628 |
631 TRACE_EVENT_END2("cc", | 629 TRACE_EVENT_END2("cc", |
632 "TileManager::AssignGpuMemoryToTiles", | 630 "TileManager::AssignGpuMemoryToTiles", |
633 "all_tiles_that_need_to_be_rasterized_are_scheduled", | 631 "all_tiles_that_need_to_be_rasterized_are_scheduled", |
634 all_tiles_that_need_to_be_rasterized_are_scheduled_, | 632 all_tiles_that_need_to_be_rasterized_are_scheduled_, |
635 "had_enough_memory_to_schedule_tiles_needed_now", | 633 "had_enough_memory_to_schedule_tiles_needed_now", |
636 had_enough_memory_to_schedule_tiles_needed_now); | 634 had_enough_memory_to_schedule_tiles_needed_now); |
637 } | 635 } |
638 | 636 |
639 void TileManager::FreeResourcesForTile(Tile* tile) { | 637 void TileManager::FreeResourcesForTile(Tile* tile) { |
640 ManagedTileState& mts = tile->managed_state(); | 638 TileDrawInfo& draw_info = tile->draw_info(); |
641 if (mts.draw_info.resource_) | 639 if (draw_info.resource_) |
642 resource_pool_->ReleaseResource(mts.draw_info.resource_.Pass()); | 640 resource_pool_->ReleaseResource(draw_info.resource_.Pass()); |
643 } | 641 } |
644 | 642 |
645 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw( | 643 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw( |
646 Tile* tile) { | 644 Tile* tile) { |
647 bool was_ready_to_draw = tile->IsReadyToDraw(); | 645 bool was_ready_to_draw = tile->IsReadyToDraw(); |
648 FreeResourcesForTile(tile); | 646 FreeResourcesForTile(tile); |
649 if (was_ready_to_draw) | 647 if (was_ready_to_draw) |
650 client_->NotifyTileStateChanged(tile); | 648 client_->NotifyTileStateChanged(tile); |
651 } | 649 } |
652 | 650 |
653 void TileManager::ScheduleTasks( | 651 void TileManager::ScheduleTasks( |
654 const TileVector& tiles_that_need_to_be_rasterized) { | 652 const TileVector& tiles_that_need_to_be_rasterized) { |
655 TRACE_EVENT1("cc", | 653 TRACE_EVENT1("cc", |
656 "TileManager::ScheduleTasks", | 654 "TileManager::ScheduleTasks", |
657 "count", | 655 "count", |
658 tiles_that_need_to_be_rasterized.size()); | 656 tiles_that_need_to_be_rasterized.size()); |
659 | 657 |
660 DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_); | 658 DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_); |
661 | 659 |
662 raster_queue_.Reset(); | 660 raster_queue_.Reset(); |
663 | 661 |
664 // Build a new task queue containing all task currently needed. Tasks | 662 // Build a new task queue containing all task currently needed. Tasks |
665 // are added in order of priority, highest priority task first. | 663 // are added in order of priority, highest priority task first. |
666 for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin(); | 664 for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin(); |
667 it != tiles_that_need_to_be_rasterized.end(); | 665 it != tiles_that_need_to_be_rasterized.end(); |
668 ++it) { | 666 ++it) { |
669 Tile* tile = *it; | 667 Tile* tile = *it; |
670 ManagedTileState& mts = tile->managed_state(); | 668 TileDrawInfo& draw_info = tile->draw_info(); |
671 | 669 |
672 DCHECK(mts.draw_info.requires_resource()); | 670 DCHECK(draw_info.requires_resource()); |
673 DCHECK(!mts.draw_info.resource_); | 671 DCHECK(!draw_info.resource_); |
674 | 672 |
675 if (!mts.raster_task.get()) | 673 if (!tile->raster_task_.get()) |
676 mts.raster_task = CreateRasterTask(tile); | 674 tile->raster_task_ = CreateRasterTask(tile); |
677 | 675 |
678 TaskSetCollection task_sets; | 676 TaskSetCollection task_sets; |
679 if (tile->required_for_activation()) | 677 if (tile->required_for_activation()) |
680 task_sets.set(REQUIRED_FOR_ACTIVATION); | 678 task_sets.set(REQUIRED_FOR_ACTIVATION); |
681 if (tile->required_for_draw()) | 679 if (tile->required_for_draw()) |
682 task_sets.set(REQUIRED_FOR_DRAW); | 680 task_sets.set(REQUIRED_FOR_DRAW); |
683 task_sets.set(ALL); | 681 task_sets.set(ALL); |
684 raster_queue_.items.push_back( | 682 raster_queue_.items.push_back( |
685 TileTaskQueue::Item(mts.raster_task.get(), task_sets)); | 683 TileTaskQueue::Item(tile->raster_task_.get(), task_sets)); |
686 } | 684 } |
687 | 685 |
688 // We must reduce the amount of unused resoruces before calling | 686 // We must reduce the amount of unused resoruces before calling |
689 // ScheduleTasks to prevent usage from rising above limits. | 687 // ScheduleTasks to prevent usage from rising above limits. |
690 resource_pool_->ReduceResourceUsage(); | 688 resource_pool_->ReduceResourceUsage(); |
691 | 689 |
692 // Schedule running of |raster_queue_|. This replaces any previously | 690 // Schedule running of |raster_queue_|. This replaces any previously |
693 // scheduled tasks and effectively cancels all tasks not present | 691 // scheduled tasks and effectively cancels all tasks not present |
694 // in |raster_queue_|. | 692 // in |raster_queue_|. |
695 tile_task_runner_->ScheduleTasks(&raster_queue_); | 693 tile_task_runner_->ScheduleTasks(&raster_queue_); |
(...skipping 12 matching lines...) Expand all Loading... |
708 return make_scoped_refptr(new ImageDecodeTaskImpl( | 706 return make_scoped_refptr(new ImageDecodeTaskImpl( |
709 pixel_ref, | 707 pixel_ref, |
710 tile->layer_id(), | 708 tile->layer_id(), |
711 base::Bind(&TileManager::OnImageDecodeTaskCompleted, | 709 base::Bind(&TileManager::OnImageDecodeTaskCompleted, |
712 base::Unretained(this), | 710 base::Unretained(this), |
713 tile->layer_id(), | 711 tile->layer_id(), |
714 base::Unretained(pixel_ref)))); | 712 base::Unretained(pixel_ref)))); |
715 } | 713 } |
716 | 714 |
717 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) { | 715 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) { |
718 ManagedTileState& mts = tile->managed_state(); | |
719 | |
720 scoped_ptr<ScopedResource> resource = | 716 scoped_ptr<ScopedResource> resource = |
721 resource_pool_->AcquireResource(tile->size()); | 717 resource_pool_->AcquireResource(tile->size()); |
722 const ScopedResource* const_resource = resource.get(); | 718 const ScopedResource* const_resource = resource.get(); |
723 | 719 |
724 // Create and queue all image decode tasks that this tile depends on. | 720 // Create and queue all image decode tasks that this tile depends on. |
725 ImageDecodeTask::Vector decode_tasks; | 721 ImageDecodeTask::Vector decode_tasks; |
726 PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()]; | 722 PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()]; |
727 std::vector<SkPixelRef*> pixel_refs; | 723 std::vector<SkPixelRef*> pixel_refs; |
728 tile->raster_source()->GatherPixelRefs( | 724 tile->raster_source()->GatherPixelRefs( |
729 tile->content_rect(), tile->contents_scale(), &pixel_refs); | 725 tile->content_rect(), tile->contents_scale(), &pixel_refs); |
730 for (SkPixelRef* pixel_ref : pixel_refs) { | 726 for (SkPixelRef* pixel_ref : pixel_refs) { |
731 uint32_t id = pixel_ref->getGenerationID(); | 727 uint32_t id = pixel_ref->getGenerationID(); |
732 | 728 |
733 // Append existing image decode task if available. | 729 // Append existing image decode task if available. |
734 PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id); | 730 PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id); |
735 if (decode_task_it != existing_pixel_refs.end()) { | 731 if (decode_task_it != existing_pixel_refs.end()) { |
736 decode_tasks.push_back(decode_task_it->second); | 732 decode_tasks.push_back(decode_task_it->second); |
737 continue; | 733 continue; |
738 } | 734 } |
739 | 735 |
740 // Create and append new image decode task for this pixel ref. | 736 // Create and append new image decode task for this pixel ref. |
741 scoped_refptr<ImageDecodeTask> decode_task = | 737 scoped_refptr<ImageDecodeTask> decode_task = |
742 CreateImageDecodeTask(tile, pixel_ref); | 738 CreateImageDecodeTask(tile, pixel_ref); |
743 decode_tasks.push_back(decode_task); | 739 decode_tasks.push_back(decode_task); |
744 existing_pixel_refs[id] = decode_task; | 740 existing_pixel_refs[id] = decode_task; |
745 } | 741 } |
746 | 742 |
747 return make_scoped_refptr( | 743 return make_scoped_refptr(new RasterTaskImpl( |
748 new RasterTaskImpl(const_resource, | 744 const_resource, tile->raster_source(), tile->content_rect(), |
749 tile->raster_source(), | 745 tile->contents_scale(), tile->combined_priority().resolution, |
750 tile->content_rect(), | 746 tile->layer_id(), static_cast<const void*>(tile), |
751 tile->contents_scale(), | 747 tile->source_frame_number(), tile->use_picture_analysis(), |
752 mts.resolution, | 748 base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this), |
753 tile->layer_id(), | 749 tile->id(), base::Passed(&resource)), |
754 static_cast<const void*>(tile), | 750 &decode_tasks)); |
755 tile->source_frame_number(), | |
756 tile->use_picture_analysis(), | |
757 base::Bind(&TileManager::OnRasterTaskCompleted, | |
758 base::Unretained(this), | |
759 tile->id(), | |
760 base::Passed(&resource)), | |
761 &decode_tasks)); | |
762 } | 751 } |
763 | 752 |
764 void TileManager::OnImageDecodeTaskCompleted(int layer_id, | 753 void TileManager::OnImageDecodeTaskCompleted(int layer_id, |
765 SkPixelRef* pixel_ref, | 754 SkPixelRef* pixel_ref, |
766 bool was_canceled) { | 755 bool was_canceled) { |
767 // If the task was canceled, we need to clean it up | 756 // If the task was canceled, we need to clean it up |
768 // from |image_decode_tasks_|. | 757 // from |image_decode_tasks_|. |
769 if (!was_canceled) | 758 if (!was_canceled) |
770 return; | 759 return; |
771 | 760 |
(...skipping 10 matching lines...) Expand all Loading... |
782 } | 771 } |
783 | 772 |
784 void TileManager::OnRasterTaskCompleted( | 773 void TileManager::OnRasterTaskCompleted( |
785 Tile::Id tile_id, | 774 Tile::Id tile_id, |
786 scoped_ptr<ScopedResource> resource, | 775 scoped_ptr<ScopedResource> resource, |
787 const RasterSource::SolidColorAnalysis& analysis, | 776 const RasterSource::SolidColorAnalysis& analysis, |
788 bool was_canceled) { | 777 bool was_canceled) { |
789 DCHECK(tiles_.find(tile_id) != tiles_.end()); | 778 DCHECK(tiles_.find(tile_id) != tiles_.end()); |
790 | 779 |
791 Tile* tile = tiles_[tile_id]; | 780 Tile* tile = tiles_[tile_id]; |
792 ManagedTileState& mts = tile->managed_state(); | 781 TileDrawInfo& draw_info = tile->draw_info(); |
793 DCHECK(mts.raster_task.get()); | 782 DCHECK(tile->raster_task_.get()); |
794 orphan_raster_tasks_.push_back(mts.raster_task); | 783 orphan_raster_tasks_.push_back(tile->raster_task_); |
795 mts.raster_task = NULL; | 784 tile->raster_task_ = NULL; |
796 | 785 |
797 if (was_canceled) { | 786 if (was_canceled) { |
798 ++update_visible_tiles_stats_.canceled_count; | 787 ++update_visible_tiles_stats_.canceled_count; |
799 resource_pool_->ReleaseResource(resource.Pass()); | 788 resource_pool_->ReleaseResource(resource.Pass()); |
800 return; | 789 return; |
801 } | 790 } |
802 | 791 |
803 ++update_visible_tiles_stats_.completed_count; | 792 ++update_visible_tiles_stats_.completed_count; |
804 | 793 |
805 if (analysis.is_solid_color) { | 794 if (analysis.is_solid_color) { |
806 mts.draw_info.set_solid_color(analysis.solid_color); | 795 draw_info.set_solid_color(analysis.solid_color); |
807 resource_pool_->ReleaseResource(resource.Pass()); | 796 resource_pool_->ReleaseResource(resource.Pass()); |
808 } else { | 797 } else { |
809 mts.draw_info.set_use_resource(); | 798 draw_info.set_use_resource(); |
810 mts.draw_info.resource_ = resource.Pass(); | 799 draw_info.resource_ = resource.Pass(); |
811 } | 800 } |
812 | 801 |
813 client_->NotifyTileStateChanged(tile); | 802 client_->NotifyTileStateChanged(tile); |
814 } | 803 } |
815 | 804 |
816 scoped_refptr<Tile> TileManager::CreateTile(RasterSource* raster_source, | 805 scoped_refptr<Tile> TileManager::CreateTile(RasterSource* raster_source, |
817 const gfx::Size& tile_size, | 806 const gfx::Size& tile_size, |
818 const gfx::Rect& content_rect, | 807 const gfx::Rect& content_rect, |
819 float contents_scale, | 808 float contents_scale, |
820 int layer_id, | 809 int layer_id, |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
903 | 892 |
904 // static | 893 // static |
905 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig( | 894 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig( |
906 const gfx::Size& size, | 895 const gfx::Size& size, |
907 ResourceFormat format) { | 896 ResourceFormat format) { |
908 return MemoryUsage(Resource::MemorySizeBytes(size, format), 1); | 897 return MemoryUsage(Resource::MemorySizeBytes(size, format), 1); |
909 } | 898 } |
910 | 899 |
911 // static | 900 // static |
912 TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) { | 901 TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) { |
913 const ManagedTileState& mts = tile->managed_state(); | 902 const TileDrawInfo& draw_info = tile->draw_info(); |
914 if (mts.draw_info.resource_) { | 903 if (draw_info.resource_) { |
915 return MemoryUsage::FromConfig(tile->size(), | 904 return MemoryUsage::FromConfig(tile->size(), draw_info.resource_->format()); |
916 mts.draw_info.resource_->format()); | |
917 } | 905 } |
918 return MemoryUsage(); | 906 return MemoryUsage(); |
919 } | 907 } |
920 | 908 |
921 TileManager::MemoryUsage& TileManager::MemoryUsage::operator+=( | 909 TileManager::MemoryUsage& TileManager::MemoryUsage::operator+=( |
922 const MemoryUsage& other) { | 910 const MemoryUsage& other) { |
923 memory_bytes_ += other.memory_bytes_; | 911 memory_bytes_ += other.memory_bytes_; |
924 resource_count_ += other.resource_count_; | 912 resource_count_ += other.resource_count_; |
925 return *this; | 913 return *this; |
926 } | 914 } |
(...skipping 11 matching lines...) Expand all Loading... |
938 result -= other; | 926 result -= other; |
939 return result; | 927 return result; |
940 } | 928 } |
941 | 929 |
942 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const { | 930 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const { |
943 return memory_bytes_ > limit.memory_bytes_ || | 931 return memory_bytes_ > limit.memory_bytes_ || |
944 resource_count_ > limit.resource_count_; | 932 resource_count_ > limit.resource_count_; |
945 } | 933 } |
946 | 934 |
947 } // namespace cc | 935 } // namespace cc |
OLD | NEW |