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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/tile_manager.cc

Issue 12353003: cc: Refactored Tile::GetResourceId (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 9 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 side-by-side diff with in-line comments
Download patch
« cc/tile.h ('K') | « cc/tile_manager.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/tile_manager.cc
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index 8b49b15a75226e899e2a29543d5b4a05c94f1b9b..1079b67c85b0de08ba895a96ff4f9b4ceb1332ff 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -12,7 +12,6 @@
#include "base/logging.h"
#include "base/metrics/histogram.h"
#include "cc/devtools_instrumentation.h"
-#include "cc/math_util.h"
#include "cc/platform_color.h"
#include "cc/raster_worker_pool.h"
#include "cc/resource_pool.h"
@@ -145,49 +144,6 @@ scoped_ptr<base::Value> TileRasterStateAsValue(
}
}
-ManagedTileState::ManagedTileState()
- : can_use_gpu_memory(false),
- can_be_freed(true),
- resource_is_being_initialized(false),
- contents_swizzled(false),
- need_to_gather_pixel_refs(true),
- gpu_memmgr_stats_bin(NEVER_BIN),
- raster_state(IDLE_STATE),
- resolution(NON_IDEAL_RESOLUTION),
- time_to_needed_in_seconds(std::numeric_limits<float>::infinity()),
- distance_to_visible_in_pixels(std::numeric_limits<float>::infinity()),
- picture_pile_analyzed(false) {
- for (int i = 0; i < NUM_TREES; ++i) {
- tree_bin[i] = NEVER_BIN;
- bin[i] = NEVER_BIN;
- }
-}
-
-ManagedTileState::~ManagedTileState() {
- DCHECK(!resource);
- DCHECK(!resource_is_being_initialized);
-}
-
-scoped_ptr<base::Value> ManagedTileState::AsValue() const {
- scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
- state->SetBoolean("can_use_gpu_memory", can_use_gpu_memory);
- state->SetBoolean("can_be_freed", can_be_freed);
- state->SetBoolean("has_resource", resource.get() != 0);
- state->SetBoolean("resource_is_being_initialized", resource_is_being_initialized);
- state->Set("raster_state", TileRasterStateAsValue(raster_state).release());
- state->Set("bin.0", TileManagerBinAsValue(bin[ACTIVE_TREE]).release());
- state->Set("bin.1", TileManagerBinAsValue(bin[PENDING_TREE]).release());
- state->Set("gpu_memmgr_stats_bin", TileManagerBinAsValue(bin[ACTIVE_TREE]).release());
- state->Set("resolution", TileResolutionAsValue(resolution).release());
- state->Set("time_to_needed_in_seconds", MathUtil::asValueSafely(time_to_needed_in_seconds).release());
- state->Set("distance_to_visible_in_pixels", MathUtil::asValueSafely(distance_to_visible_in_pixels).release());
- state->SetBoolean("is_picture_pile_analyzed", picture_pile_analyzed);
- state->SetBoolean("is_cheap_to_raster", picture_pile_analysis.is_cheap_to_raster);
- state->SetBoolean("is_transparent", picture_pile_analysis.is_transparent);
- state->SetBoolean("is_solid_color", picture_pile_analysis.is_solid_color);
- return state.PassAs<base::Value>();
-}
-
TileManager::TileManager(
TileManagerClient* client,
ResourceProvider* resource_provider,
@@ -392,8 +348,8 @@ void TileManager::ManageTiles() {
for (int i = 0; i < NUM_BIN_PRIORITIES; ++i)
mts.bin[i] = bin_map[mts.bin[i]];
- if (!tile->managed_state().resource &&
- !tile->managed_state().resource_is_being_initialized &&
+ if (!mts.drawing_info.resource_ &&
+ !mts.drawing_info.resource_is_being_initialized_ &&
!tile->priority(ACTIVE_TREE).is_live &&
!tile->priority(PENDING_TREE).is_live)
continue;
@@ -418,11 +374,12 @@ void TileManager::ManageTiles() {
void TileManager::CheckForCompletedTileUploads() {
while (!tiles_with_pending_upload_.empty()) {
Tile* tile = tiles_with_pending_upload_.front();
- DCHECK(tile->managed_state().resource);
+ ManagedTileState& managed_tile_state = tile->managed_state();
+ DCHECK(managed_tile_state.drawing_info.resource_);
// Set pixel tasks complete in the order they are posted.
if (!resource_pool_->resource_provider()->DidSetPixelsComplete(
- tile->managed_state().resource->id())) {
+ managed_tile_state.drawing_info.resource_->id())) {
break;
}
@@ -432,7 +389,7 @@ void TileManager::CheckForCompletedTileUploads() {
// It's now safe to release the pixel buffer.
resource_pool_->resource_provider()->ReleasePixelBuffer(
- tile->managed_state().resource->id());
+ managed_tile_state.drawing_info.resource_->id());
DidFinishTileInitialization(tile);
@@ -448,15 +405,15 @@ void TileManager::AbortPendingTileUploads() {
while (!tiles_with_pending_upload_.empty()) {
Tile* tile = tiles_with_pending_upload_.front();
ManagedTileState& managed_tile_state = tile->managed_state();
- DCHECK(managed_tile_state.resource);
+ DCHECK(managed_tile_state.drawing_info.resource_);
resource_pool_->resource_provider()->AbortSetPixels(
- managed_tile_state.resource->id());
+ managed_tile_state.drawing_info.resource_->id());
resource_pool_->resource_provider()->ReleasePixelBuffer(
- managed_tile_state.resource->id());
+ managed_tile_state.drawing_info.resource_->id());
- managed_tile_state.resource_is_being_initialized = false;
- managed_tile_state.can_be_freed = true;
+ managed_tile_state.drawing_info.resource_is_being_initialized_ = false;
+ managed_tile_state.drawing_info.can_be_freed_ = true;
managed_tile_state.can_use_gpu_memory = false;
FreeResourcesForTile(tile);
@@ -481,7 +438,9 @@ void TileManager::GetMemoryStats(
for (size_t i = 0; i < live_or_allocated_tiles_.size(); i++) {
const Tile* tile = live_or_allocated_tiles_[i];
const ManagedTileState& mts = tile->managed_state();
- if (tile->is_transparent() || tile->is_solid_color())
+ ManagedTileState::DrawingInfo::Mode mode = mts.drawing_info.mode();
+ if (mode == ManagedTileState::DrawingInfo::SOLID_COLOR_MODE ||
+ mode == ManagedTileState::DrawingInfo::TRANSPARENT_MODE)
continue;
size_t tile_bytes = tile->bytes_consumed_if_allocated();
@@ -604,13 +563,15 @@ void TileManager::AssignGpuMemoryToTiles() {
for (TileVector::iterator it = live_or_allocated_tiles_.begin();
it != live_or_allocated_tiles_.end(); ++it) {
Tile* tile = *it;
- if (tile->is_solid_color() || tile->is_transparent())
+ ManagedTileState& mts = tile->managed_state();
+ ManagedTileState::DrawingInfo::Mode mode = mts.drawing_info.mode();
+ if (mode == ManagedTileState::DrawingInfo::SOLID_COLOR_MODE ||
+ mode == ManagedTileState::DrawingInfo::TRANSPARENT_MODE)
continue;
- ManagedTileState& managed_tile_state = tile->managed_state();
- if (!managed_tile_state.can_be_freed)
+ if (!mts.drawing_info.can_be_freed_)
unreleasable_bytes += tile->bytes_consumed_if_allocated();
- if (managed_tile_state.raster_state == WAITING_FOR_RASTER_STATE)
+ if (mts.raster_state == WAITING_FOR_RASTER_STATE)
DidTileRasterStateChange(tile, IDLE_STATE);
}
@@ -619,31 +580,33 @@ void TileManager::AssignGpuMemoryToTiles() {
size_t bytes_left = bytes_allocatable;
for (TileVector::iterator it = live_or_allocated_tiles_.begin(); it != live_or_allocated_tiles_.end(); ++it) {
Tile* tile = *it;
- if (tile->is_solid_color() || tile->is_transparent())
+ ManagedTileState& mts = tile->managed_state();
+ ManagedTileState::DrawingInfo::Mode mode = mts.drawing_info.mode();
+ if (mode == ManagedTileState::DrawingInfo::SOLID_COLOR_MODE ||
+ mode == ManagedTileState::DrawingInfo::TRANSPARENT_MODE)
continue;
- ManagedTileState& managed_tile_state = tile->managed_state();
size_t tile_bytes = tile->bytes_consumed_if_allocated();
- if (!managed_tile_state.can_be_freed)
+ if (!mts.drawing_info.can_be_freed_)
continue;
- if (managed_tile_state.bin[HIGH_PRIORITY_BIN] == NEVER_BIN &&
- managed_tile_state.bin[LOW_PRIORITY_BIN] == NEVER_BIN) {
- managed_tile_state.can_use_gpu_memory = false;
+ if (mts.bin[HIGH_PRIORITY_BIN] == NEVER_BIN &&
+ mts.bin[LOW_PRIORITY_BIN] == NEVER_BIN) {
+ mts.can_use_gpu_memory = false;
FreeResourcesForTile(tile);
continue;
}
if (tile_bytes > bytes_left) {
- managed_tile_state.can_use_gpu_memory = false;
- if (managed_tile_state.bin[HIGH_PRIORITY_BIN] == NOW_BIN ||
- managed_tile_state.bin[LOW_PRIORITY_BIN] == NOW_BIN)
+ mts.can_use_gpu_memory = false;
+ if (mts.bin[HIGH_PRIORITY_BIN] == NOW_BIN ||
+ mts.bin[LOW_PRIORITY_BIN] == NOW_BIN)
bytes_that_exceeded_memory_budget_in_now_bin += tile_bytes;
FreeResourcesForTile(tile);
continue;
}
bytes_left -= tile_bytes;
- managed_tile_state.can_use_gpu_memory = true;
- if (!managed_tile_state.resource &&
- !managed_tile_state.resource_is_being_initialized) {
+ mts.can_use_gpu_memory = true;
+ if (!mts.drawing_info.resource_ &&
+ !mts.drawing_info.resource_is_being_initialized_) {
tiles_that_need_to_be_rasterized_.push_back(tile);
DidTileRasterStateChange(tile, WAITING_FOR_RASTER_STATE);
}
@@ -673,9 +636,10 @@ void TileManager::AssignGpuMemoryToTiles() {
void TileManager::FreeResourcesForTile(Tile* tile) {
ManagedTileState& managed_tile_state = tile->managed_state();
- DCHECK(managed_tile_state.can_be_freed);
- if (managed_tile_state.resource)
- resource_pool_->ReleaseResource(managed_tile_state.resource.Pass());
+ DCHECK(managed_tile_state.drawing_info.can_be_freed_);
+ if (managed_tile_state.drawing_info.resource_)
+ resource_pool_->ReleaseResource(
+ managed_tile_state.drawing_info.resource_.Pass());
}
bool TileManager::CanDispatchRasterTask(Tile* tile) const {
@@ -715,17 +679,19 @@ void TileManager::DispatchMoreTasks() {
// of the image decoding list.
while (!tiles_that_need_to_be_rasterized_.empty()) {
Tile* tile = tiles_that_need_to_be_rasterized_.back();
- ManagedTileState& managed_tile_state = tile->managed_state();
+ ManagedTileState& mts = tile->managed_state();
AnalyzeTile(tile);
- if (tile->is_solid_color() || tile->is_transparent()) {
+ ManagedTileState::DrawingInfo::Mode mode = mts.drawing_info.mode();
+ if (mode == ManagedTileState::DrawingInfo::SOLID_COLOR_MODE ||
+ mode == ManagedTileState::DrawingInfo::TRANSPARENT_MODE) {
DidTileRasterStateChange(tile, IDLE_STATE);
tiles_that_need_to_be_rasterized_.pop_back();
continue;
}
DispatchImageDecodeTasksForTile(tile);
- if (!managed_tile_state.pending_pixel_refs.empty()) {
+ if (!mts.pending_pixel_refs.empty()) {
tiles_with_image_decoding_tasks_.push_back(tile);
} else {
if (!CanDispatchRasterTask(tile))
@@ -751,6 +717,12 @@ void TileManager::AnalyzeTile(Tile* tile) {
managed_tile_state.picture_pile_analysis.is_transparent &=
use_color_estimator_;
managed_tile_state.picture_pile_analyzed = true;
+
+ if (managed_tile_state.picture_pile_analysis.is_solid_color)
+ tile->drawing_info().set_solid_color(
+ managed_tile_state.picture_pile_analysis.solid_color);
+ else if (managed_tile_state.picture_pile_analysis.is_transparent)
+ tile->drawing_info().set_transparent();
}
}
@@ -843,8 +815,8 @@ scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
resource_pool_->resource_provider()->AcquirePixelBuffer(resource->id());
- managed_tile_state.resource_is_being_initialized = true;
- managed_tile_state.can_be_freed = false;
+ managed_tile_state.drawing_info.resource_is_being_initialized_ = true;
+ managed_tile_state.drawing_info.can_be_freed_ = false;
DidTileRasterStateChange(tile, RASTER_STATE);
return resource.Pass();
@@ -910,7 +882,7 @@ void TileManager::OnRasterTaskCompleted(
resource_pool_->resource_provider()->UnmapPixelBuffer(resource->id());
ManagedTileState& managed_tile_state = tile->managed_state();
- managed_tile_state.can_be_freed = true;
+ managed_tile_state.drawing_info.can_be_freed_ = true;
// Tile can be freed after the completion of the raster task. Call
// AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
@@ -926,16 +898,16 @@ void TileManager::OnRasterTaskCompleted(
// The component order may be bgra if we're uploading bgra pixels to rgba
// texture. Mark contents as swizzled if image component order is
// different than texture format.
- managed_tile_state.contents_swizzled =
+ managed_tile_state.drawing_info.contents_swizzled_ =
!PlatformColor::sameComponentOrder(tile->format_);
// Tile resources can't be freed until upload has completed.
- managed_tile_state.can_be_freed = false;
+ managed_tile_state.drawing_info.can_be_freed_ = false;
resource_pool_->resource_provider()->BeginSetPixels(resource->id());
has_performed_uploads_since_last_flush_ = true;
- managed_tile_state.resource = resource.Pass();
+ managed_tile_state.drawing_info.resource_ = resource.Pass();
bytes_pending_upload_ += tile->bytes_consumed_if_allocated();
DidTileRasterStateChange(tile, UPLOAD_STATE);
@@ -943,16 +915,16 @@ void TileManager::OnRasterTaskCompleted(
} else {
resource_pool_->resource_provider()->ReleasePixelBuffer(resource->id());
resource_pool_->ReleaseResource(resource.Pass());
- managed_tile_state.resource_is_being_initialized = false;
+ managed_tile_state.drawing_info.resource_is_being_initialized_ = false;
DidTileRasterStateChange(tile, IDLE_STATE);
}
}
void TileManager::DidFinishTileInitialization(Tile* tile) {
- ManagedTileState& managed_tile_state = tile->managed_state();
- DCHECK(managed_tile_state.resource);
- managed_tile_state.resource_is_being_initialized = false;
- managed_tile_state.can_be_freed = true;
+ ManagedTileState& managed_state = tile->managed_state();
+ DCHECK(managed_state.drawing_info.resource_);
+ managed_state.drawing_info.resource_is_being_initialized_ = false;
+ managed_state.drawing_info.can_be_freed_ = true;
}
void TileManager::DidTileRasterStateChange(Tile* tile, TileRasterState state) {
« cc/tile.h ('K') | « cc/tile_manager.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698