cc/tiles/tile_manager.cc - Issue 1866043006: cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

Unified Diff: cc/tiles/tile_manager.cc

Issue 1866043006: cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread(). (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: nits Created 4 years, 8 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

Index: cc/tiles/tile_manager.cc

diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc

index e2f362d4ed457eb0bd8eaea353a57514ed3933b2..ecd7dbabbbaa5a88698ccecb2df0b61e331eb343 100644

--- a/cc/tiles/tile_manager.cc

+++ b/cc/tiles/tile_manager.cc

@@ -44,7 +44,7 @@ DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(

class RasterTaskImpl : public RasterTask {

public:

- RasterTaskImpl(const Resource* resource,

+ RasterTaskImpl(Resource* resource,

scoped_refptr<RasterSource> raster_source,

const gfx::Rect& content_rect,

const gfx::Rect& invalid_content_rect,

@@ -53,12 +53,12 @@ class RasterTaskImpl : public RasterTask {

TileResolution tile_resolution,

int layer_id,

uint64_t source_prepare_tiles_id,

- const void* tile,

+ Tile* tile,

uint64_t new_content_id,

uint64_t previous_content_id,

uint64_t resource_content_id,

int source_frame_number,

- const base::Callback<void(bool)>& reply,

+ std::unique_ptr<RasterBuffer> raster_buffer,

ImageDecodeTask::Vector* dependencies)

: RasterTask(dependencies),

resource_(resource),

@@ -75,7 +75,9 @@ class RasterTaskImpl : public RasterTask {

previous_content_id_(previous_content_id),

resource_content_id_(resource_content_id),

source_frame_number_(source_frame_number),

- reply_(reply) {}

+ raster_buffer_(std::move(raster_buffer)) {

+ SetTaskTypeId(TASK_TYPE_RASTER);

+ }

// Overridden from Task:

void RunOnWorkerThread() override {

@@ -97,22 +99,11 @@ class RasterTaskImpl : public RasterTask {

contents_scale_, playback_settings_);

}

- // Overridden from TileTask:

- void ScheduleOnOriginThread(TileTaskClient* client) override {

- DCHECK(!raster_buffer_);

- raster_buffer_ = client->AcquireBufferForRaster(

- resource_, resource_content_id_, previous_content_id_);

- }

- void CompleteOnOriginThread(TileTaskClient* client) override {

- client->ReleaseBufferForRaster(std::move(raster_buffer_));

- reply_.Run(!HasFinishedRunning());

- }

protected:

- ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }

+ ~RasterTaskImpl() override {}

- private:

- const Resource* resource_;

+ public:

+ Resource* resource_;

scoped_refptr<RasterSource> raster_source_;

gfx::Rect content_rect_;

gfx::Rect invalid_content_rect_;

@@ -121,14 +112,14 @@ class RasterTaskImpl : public RasterTask {

TileResolution tile_resolution_;

int layer_id_;

uint64_t source_prepare_tiles_id_;

- const void* tile_;

+ Tile* tile_;

uint64_t new_content_id_;

uint64_t previous_content_id_;

uint64_t resource_content_id_;

int source_frame_number_;

- const base::Callback<void(bool)> reply_;

std::unique_ptr<RasterBuffer> raster_buffer_;

+ private:

DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);

};

@@ -251,10 +242,6 @@ class TaskSetFinishedTaskImpl : public TileTask {

TaskSetFinished();

}

- // Overridden from TileTask:

- void ScheduleOnOriginThread(TileTaskClient* client) override {}

- void CompleteOnOriginThread(TileTaskClient* client) override {}

protected:

~TaskSetFinishedTaskImpl() override {}

@@ -310,7 +297,7 @@ TileManager::TileManager(TileManagerClient* client,

use_partial_raster_(use_partial_raster),

use_gpu_rasterization_(false),

all_tiles_that_need_to_be_rasterized_are_scheduled_(true),

- did_check_for_completed_tasks_since_last_schedule_tasks_(true),

+ did_check_and_process_completed_tasks_since_last_schedule_tasks_(true),

did_oom_on_last_assign_(false),

more_tiles_need_prepare_check_notifier_(

task_runner_.get(),

@@ -342,7 +329,7 @@ void TileManager::FinishTasksAndCleanUp() {

// |orphan_tasks_|.

orphan_tasks_.clear();

- tile_task_runner_->CheckForCompletedTasks();

+ CheckAndProcessCompletedTasks();

FreeResourcesForReleasedTiles();

CleanUpReleasedTiles();

@@ -452,12 +439,10 @@ bool TileManager::PrepareTiles(

signals_.reset();

global_state_ = state;

- // We need to call CheckForCompletedTasks() once in-between each call

+ // We need to call CheckAndProcessCompletedTasks() once in-between each call

// to ScheduleTasks() to prevent canceled tasks from being scheduled.

- if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {

- tile_task_runner_->CheckForCompletedTasks();

- did_check_for_completed_tasks_since_last_schedule_tasks_ = true;

- }

+ if (!did_check_and_process_completed_tasks_since_last_schedule_tasks_)

+ CheckAndProcessCompletedTasks();

FreeResourcesForReleasedTiles();

CleanUpReleasedTiles();

@@ -492,9 +477,7 @@ void TileManager::Flush() {

return;

}

- tile_task_runner_->CheckForCompletedTasks();

- did_check_for_completed_tasks_since_last_schedule_tasks_ = true;

+ CheckAndProcessCompletedTasks();

TRACE_EVENT_INSTANT1("cc", "DidFlush", TRACE_EVENT_SCOPE_THREAD, "stats",

RasterTaskCompletionStatsAsValue(flush_stats_));

@@ -736,7 +719,7 @@ void TileManager::ScheduleTasks(

TRACE_EVENT1("cc", "TileManager::ScheduleTasks", "count",

tiles_that_need_to_be_rasterized.size());

- DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);

+ DCHECK(did_check_and_process_completed_tasks_since_last_schedule_tasks_);

if (!has_scheduled_tile_tasks_) {

TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);

@@ -839,7 +822,7 @@ void TileManager::ScheduleTasks(

required_for_draw_done_task_ = std::move(required_for_draw_done_task);

all_done_task_ = std::move(all_done_task);

- did_check_for_completed_tasks_since_last_schedule_tasks_ = false;

+ did_check_and_process_completed_tasks_since_last_schedule_tasks_ = false;

TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",

ScheduledTasksStateAsValue());

@@ -897,57 +880,84 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(

it = images.erase(it);

}

+ std::unique_ptr<RasterBuffer> raster_buffer =

+ tile_task_runner_->AsTileTaskClient()->AcquireBufferForRaster(

+ resource, resource_content_id, tile->invalidated_id());

return make_scoped_refptr(new RasterTaskImpl(

resource, prioritized_tile.raster_source(), tile->content_rect(),

tile->invalidated_content_rect(), tile->contents_scale(),

playback_settings, prioritized_tile.priority().resolution,

- tile->layer_id(), prepare_tiles_count_, static_cast<const void*>(tile),

- tile->id(), tile->invalidated_id(), resource_content_id,

- tile->source_frame_number(),

- base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),

- tile->id(), resource),

- &decode_tasks));

+ tile->layer_id(), prepare_tiles_count_, tile, tile->id(),

+ tile->invalidated_id(), resource_content_id, tile->source_frame_number(),

+ std::move(raster_buffer), &decode_tasks));

}

-void TileManager::OnRasterTaskCompleted(

- Tile::Id tile_id,

- Resource* resource,

- bool was_canceled) {

- DCHECK(tiles_.find(tile_id) != tiles_.end());

+void TileManager::CheckAndProcessCompletedTasks() {

+ Task::Vector completed_tasks;

+ tile_task_runner_->CollectCompletedTasks(&completed_tasks);

+ for (auto task : completed_tasks) {

+ switch (task->GetTaskTypeId()) {

+ case TASK_TYPE_IMAGE_DECODE:

+ image_decode_controller_->ImageDecodeTaskCompleted(task.get());

+ break;

+ case TASK_TYPE_IMAGE_UPLOAD:

+ image_decode_controller_->ImageUploadTaskCompleted(task.get());

+ break;

+ case TASK_TYPE_RASTER:

+ RasterTaskCompleted(task.get());

+ break;

+ }

- Tile* tile = tiles_[tile_id];

- TileDrawInfo& draw_info = tile->draw_info();

- DCHECK(tile->raster_task_.get());

- orphan_tasks_.push_back(tile->raster_task_);

- tile->raster_task_ = nullptr;

+ static_cast<TileTask*>(task.get())->DidComplete();

+ }

+ completed_tasks.clear();

+ did_check_and_process_completed_tasks_since_last_schedule_tasks_ = true;

+void TileManager::RasterTaskCompleted(Task* task) {

+ DCHECK(task);

+ RasterTaskImpl* raster_task = static_cast<RasterTaskImpl*>(task);

+ tile_task_runner_->AsTileTaskClient()->ReleaseBufferForRaster(

+ std::move(raster_task->raster_buffer_));

+ DCHECK(tiles_.find(raster_task->tile_->id()) == tiles_.end());

prashant.n 2016/04/13 12:04:51 The check should be !=

+ TileDrawInfo& draw_info = raster_task->tile_->draw_info();

+ DCHECK(raster_task->tile_->raster_task_.get());

+ orphan_tasks_.push_back(raster_task->tile_->raster_task_);

+ raster_task->tile_->raster_task_ = nullptr;

// Unref all the images.

- auto images_it = scheduled_draw_images_.find(tile->id());

+ auto images_it = scheduled_draw_images_.find(raster_task->tile_->id());

const std::vector<DrawImage>& images = images_it->second;

for (const auto& image : images)

image_decode_controller_->UnrefImage(image);

scheduled_draw_images_.erase(images_it);

- if (was_canceled) {

+ // Task was cancelled.

+ if (!raster_task->HasFinishedRunning()) {

++flush_stats_.canceled_count;

// TODO(ericrk): If more partial raster work is done in the future, it may

// be worth returning the resource to the pool with its previous ID (not

// currently tracked). crrev.com/1370333002/#ps40001 has a possible method

// of achieving this.

- resource_pool_->ReleaseResource(resource, 0 /* content_id */);

+ resource_pool_->ReleaseResource(raster_task->resource_, 0 /* content_id */);

return;

}

++flush_stats_.completed_count;

draw_info.set_use_resource();

- draw_info.resource_ = resource;

- draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);

+ draw_info.resource_ = raster_task->resource_;

+ draw_info.contents_swizzled_ =

+ DetermineResourceRequiresSwizzle(raster_task->tile_);

DCHECK(draw_info.IsReadyToDraw());

draw_info.set_was_ever_ready_to_draw();

- client_->NotifyTileStateChanged(tile);

+ client_->NotifyTileStateChanged(raster_task->tile_);

}

ScopedTilePtr TileManager::CreateTile(const Tile::CreateInfo& info,

@@ -1010,8 +1020,7 @@ bool TileManager::IsReadyToDraw() const {

void TileManager::CheckAndIssueSignals() {

TRACE_EVENT0("cc", "TileManager::CheckAndIssueSignals");

- tile_task_runner_->CheckForCompletedTasks();

- did_check_for_completed_tasks_since_last_schedule_tasks_ = true;

+ CheckAndProcessCompletedTasks();

// Ready to activate.

if (signals_.ready_to_activate && !signals_.did_notify_ready_to_activate) {

@@ -1050,8 +1059,7 @@ void TileManager::CheckAndIssueSignals() {

}

void TileManager::CheckIfMoreTilesNeedToBePrepared() {

- tile_task_runner_->CheckForCompletedTasks();

- did_check_for_completed_tasks_since_last_schedule_tasks_ = true;

+ CheckAndProcessCompletedTasks();

// When OOM, keep re-assigning memory until we reach a steady state

// where top-priority tiles are initialized.

« no previous file with comments | « cc/tiles/tile_manager.h ('k') | cc/tiles/tile_manager_perftest.cc » ('j') | no next file with comments »