cc: Refactor TileTaskWorkerPool.
This patch moves tile task management from all TileTaskWorkerPool
classes to separate class making them thinner.
New class TileTaskManager now handles running tasks using task graph
runner set. This now puts the logic of raster buffer provider and
running task in different classes. This patch also renames all
TileTaskWorkerPools to RasterBufferProviders to depict what they
really do. New test classes FakeRasterBufferProviderImpl,
FakeTileTaskManagerImpl are added to cut the duplicated code.
Fixed duplicate nodes getting added in task graph in raster buffer
provider perftests.
BUG=599863
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
Review-Url: https://codereview.chromium.org/1910213005
Cr-Commit-Position: refs/heads/master@{#390632}
diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 0d35c95..cf4cd6a2 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -351,16 +351,18 @@
"quads/tile_draw_quad.h",
"quads/yuv_video_draw_quad.cc",
"quads/yuv_video_draw_quad.h",
- "raster/bitmap_tile_task_worker_pool.cc",
- "raster/bitmap_tile_task_worker_pool.h",
+ "raster/bitmap_raster_buffer_provider.cc",
+ "raster/bitmap_raster_buffer_provider.h",
+ "raster/gpu_raster_buffer_provider.cc",
+ "raster/gpu_raster_buffer_provider.h",
"raster/gpu_rasterizer.cc",
"raster/gpu_rasterizer.h",
- "raster/gpu_tile_task_worker_pool.cc",
- "raster/gpu_tile_task_worker_pool.h",
- "raster/one_copy_tile_task_worker_pool.cc",
- "raster/one_copy_tile_task_worker_pool.h",
+ "raster/one_copy_raster_buffer_provider.cc",
+ "raster/one_copy_raster_buffer_provider.h",
"raster/raster_buffer.cc",
"raster/raster_buffer.h",
+ "raster/raster_buffer_provider.cc",
+ "raster/raster_buffer_provider.h",
"raster/scoped_gpu_raster.cc",
"raster/scoped_gpu_raster.h",
"raster/single_thread_task_graph_runner.cc",
@@ -381,10 +383,8 @@
"raster/texture_compressor_etc1.h",
"raster/tile_task.cc",
"raster/tile_task.h",
- "raster/tile_task_worker_pool.cc",
- "raster/tile_task_worker_pool.h",
- "raster/zero_copy_tile_task_worker_pool.cc",
- "raster/zero_copy_tile_task_worker_pool.h",
+ "raster/zero_copy_raster_buffer_provider.cc",
+ "raster/zero_copy_raster_buffer_provider.h",
"resources/memory_history.cc",
"resources/memory_history.h",
"resources/platform_color.h",
@@ -465,6 +465,8 @@
"tiles/tile_manager.h",
"tiles/tile_priority.cc",
"tiles/tile_priority.h",
+ "tiles/tile_task_manager.cc",
+ "tiles/tile_task_manager.h",
"tiles/tiling_set_eviction_queue.cc",
"tiles/tiling_set_eviction_queue.h",
"tiles/tiling_set_raster_queue_all.cc",
@@ -618,6 +620,8 @@
"test/fake_picture_layer_tiling_client.h",
"test/fake_proxy.cc",
"test/fake_proxy.h",
+ "test/fake_raster_buffer_provider.cc",
+ "test/fake_raster_buffer_provider.h",
"test/fake_raster_source.cc",
"test/fake_raster_source.h",
"test/fake_recording_source.cc",
@@ -634,6 +638,8 @@
"test/fake_tile_manager.h",
"test/fake_tile_manager_client.cc",
"test/fake_tile_manager_client.h",
+ "test/fake_tile_task_manager.cc",
+ "test/fake_tile_task_manager.h",
"test/fake_ui_resource_layer_tree_host_impl.cc",
"test/fake_ui_resource_layer_tree_host_impl.h",
"test/fake_video_frame_provider.cc",
@@ -845,11 +851,11 @@
"quads/draw_polygon_unittest.cc",
"quads/draw_quad_unittest.cc",
"quads/render_pass_unittest.cc",
+ "raster/raster_buffer_provider_unittest.cc",
"raster/scoped_gpu_raster_unittest.cc",
"raster/single_thread_task_graph_runner_unittest.cc",
"raster/synchronous_task_graph_runner_unittest.cc",
"raster/texture_compressor_etc1_unittest.cc",
- "raster/tile_task_worker_pool_unittest.cc",
"resources/platform_color_unittest.cc",
"resources/resource_pool_unittest.cc",
"resources/resource_provider_unittest.cc",
@@ -963,9 +969,9 @@
"layers/layer_perftest.cc",
"layers/picture_layer_impl_perftest.cc",
"quads/draw_quad_perftest.cc",
+ "raster/raster_buffer_provider_perftest.cc",
"raster/task_graph_runner_perftest.cc",
"raster/texture_compressor_perftest.cc",
- "raster/tile_task_worker_pool_perftest.cc",
"surfaces/surface_aggregator_perftest.cc",
"test/cc_test_suite.cc",
"test/run_all_perftests.cc",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index f4a0991..b3b0e78 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -412,16 +412,18 @@
'quads/tile_draw_quad.h',
'quads/yuv_video_draw_quad.cc',
'quads/yuv_video_draw_quad.h',
- 'raster/bitmap_tile_task_worker_pool.cc',
- 'raster/bitmap_tile_task_worker_pool.h',
+ 'raster/bitmap_raster_buffer_provider.cc',
+ 'raster/bitmap_raster_buffer_provider.h',
+ 'raster/gpu_raster_buffer_provider.cc',
+ 'raster/gpu_raster_buffer_provider.h',
'raster/gpu_rasterizer.cc',
'raster/gpu_rasterizer.h',
- 'raster/gpu_tile_task_worker_pool.cc',
- 'raster/gpu_tile_task_worker_pool.h',
- 'raster/one_copy_tile_task_worker_pool.cc',
- 'raster/one_copy_tile_task_worker_pool.h',
+ 'raster/one_copy_raster_buffer_provider.cc',
+ 'raster/one_copy_raster_buffer_provider.h',
'raster/raster_buffer.cc',
'raster/raster_buffer.h',
+ 'raster/raster_buffer_provider.cc',
+ 'raster/raster_buffer_provider.h',
'raster/scoped_gpu_raster.cc',
'raster/scoped_gpu_raster.h',
'raster/single_thread_task_graph_runner.cc',
@@ -442,10 +444,8 @@
'raster/texture_compressor_etc1.h',
'raster/tile_task.cc',
'raster/tile_task.h',
- 'raster/tile_task_worker_pool.cc',
- 'raster/tile_task_worker_pool.h',
- 'raster/zero_copy_tile_task_worker_pool.cc',
- 'raster/zero_copy_tile_task_worker_pool.h',
+ 'raster/zero_copy_raster_buffer_provider.cc',
+ 'raster/zero_copy_raster_buffer_provider.h',
'resources/memory_history.cc',
'resources/memory_history.h',
'resources/platform_color.h',
@@ -526,6 +526,8 @@
'tiles/tile_manager.h',
'tiles/tile_priority.cc',
'tiles/tile_priority.h',
+ 'tiles/tile_task_manager.cc',
+ 'tiles/tile_task_manager.h',
'tiles/tiling_set_eviction_queue.cc',
'tiles/tiling_set_eviction_queue.h',
'tiles/tiling_set_raster_queue_all.cc',
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index d9c2fea..06d2f9e 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -94,11 +94,11 @@
'quads/draw_polygon_unittest.cc',
'quads/draw_quad_unittest.cc',
'quads/render_pass_unittest.cc',
+ 'raster/raster_buffer_provider_unittest.cc',
'raster/scoped_gpu_raster_unittest.cc',
'raster/single_thread_task_graph_runner_unittest.cc',
'raster/synchronous_task_graph_runner_unittest.cc',
'raster/texture_compressor_etc1_unittest.cc',
- 'raster/tile_task_worker_pool_unittest.cc',
'resources/platform_color_unittest.cc',
'resources/resource_pool_unittest.cc',
'resources/resource_provider_unittest.cc',
@@ -211,6 +211,8 @@
'test/fake_picture_layer_tiling_client.h',
'test/fake_proxy.cc',
'test/fake_proxy.h',
+ 'test/fake_raster_buffer_provider.cc',
+ 'test/fake_raster_buffer_provider.h',
'test/fake_raster_source.cc',
'test/fake_raster_source.h',
'test/fake_recording_source.cc',
@@ -227,6 +229,8 @@
'test/fake_tile_manager.h',
'test/fake_tile_manager_client.cc',
'test/fake_tile_manager_client.h',
+ 'test/fake_tile_task_manager.cc',
+ 'test/fake_tile_task_manager.h',
'test/fake_ui_resource_layer_tree_host_impl.cc',
'test/fake_ui_resource_layer_tree_host_impl.h',
'test/fake_video_frame_provider.cc',
@@ -378,9 +382,9 @@
'layers/layer_perftest.cc',
'layers/picture_layer_impl_perftest.cc',
'quads/draw_quad_perftest.cc',
+ 'raster/raster_buffer_provider_perftest.cc',
'raster/task_graph_runner_perftest.cc',
'raster/texture_compressor_perftest.cc',
- 'raster/tile_task_worker_pool_perftest.cc',
'surfaces/surface_aggregator_perftest.cc',
'test/cc_test_suite.cc',
'test/run_all_perftests.cc',
diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index 7264d5c..2ba74e3 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -13,7 +13,7 @@
#include "cc/debug/lap_timer.h"
#include "cc/layers/layer_impl.h"
#include "cc/layers/picture_layer_impl.h"
-#include "cc/raster/tile_task_worker_pool.h"
+#include "cc/raster/raster_buffer_provider.h"
#include "cc/trees/layer_tree_host_common.h"
#include "cc/trees/layer_tree_host_impl.h"
#include "cc/trees/layer_tree_impl.h"
diff --git a/cc/raster/bitmap_raster_buffer_provider.cc b/cc/raster/bitmap_raster_buffer_provider.cc
new file mode 100644
index 0000000..b148860b
--- /dev/null
+++ b/cc/raster/bitmap_raster_buffer_provider.cc
@@ -0,0 +1,112 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/raster/bitmap_raster_buffer_provider.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
+#include "cc/debug/traced_value.h"
+#include "cc/playback/raster_source.h"
+#include "cc/resources/platform_color.h"
+#include "cc/resources/resource.h"
+
+namespace cc {
+namespace {
+
+class RasterBufferImpl : public RasterBuffer {
+ public:
+ RasterBufferImpl(ResourceProvider* resource_provider,
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id)
+ : lock_(resource_provider, resource->id()),
+ resource_(resource),
+ resource_has_previous_content_(
+ resource_content_id && resource_content_id == previous_content_id) {
+ }
+
+ // Overridden from RasterBuffer:
+ void Playback(
+ const RasterSource* raster_source,
+ const gfx::Rect& raster_full_rect,
+ const gfx::Rect& raster_dirty_rect,
+ uint64_t new_content_id,
+ float scale,
+ const RasterSource::PlaybackSettings& playback_settings) override {
+ gfx::Rect playback_rect = raster_full_rect;
+ if (resource_has_previous_content_) {
+ playback_rect.Intersect(raster_dirty_rect);
+ }
+ DCHECK(!playback_rect.IsEmpty())
+ << "Why are we rastering a tile that's not dirty?";
+
+ size_t stride = 0u;
+ RasterBufferProvider::PlaybackToMemory(
+ lock_.sk_bitmap().getPixels(), resource_->format(), resource_->size(),
+ stride, raster_source, raster_full_rect, playback_rect, scale,
+ playback_settings);
+ }
+
+ private:
+ ResourceProvider::ScopedWriteLockSoftware lock_;
+ const Resource* resource_;
+ bool resource_has_previous_content_;
+
+ DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
+};
+
+} // namespace
+
+// static
+std::unique_ptr<RasterBufferProvider> BitmapRasterBufferProvider::Create(
+ ResourceProvider* resource_provider) {
+ return base::WrapUnique<RasterBufferProvider>(
+ new BitmapRasterBufferProvider(resource_provider));
+}
+
+BitmapRasterBufferProvider::BitmapRasterBufferProvider(
+ ResourceProvider* resource_provider)
+ : resource_provider_(resource_provider) {}
+
+BitmapRasterBufferProvider::~BitmapRasterBufferProvider() {}
+
+std::unique_ptr<RasterBuffer>
+BitmapRasterBufferProvider::AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) {
+ return std::unique_ptr<RasterBuffer>(new RasterBufferImpl(
+ resource_provider_, resource, resource_content_id, previous_content_id));
+}
+
+void BitmapRasterBufferProvider::ReleaseBufferForRaster(
+ std::unique_ptr<RasterBuffer> buffer) {
+ // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
+}
+
+void BitmapRasterBufferProvider::OrderingBarrier() {
+ // No need to sync resources as this provider does not use GL context.
+}
+
+ResourceFormat BitmapRasterBufferProvider::GetResourceFormat(
+ bool must_support_alpha) const {
+ return resource_provider_->best_texture_format();
+}
+
+bool BitmapRasterBufferProvider::GetResourceRequiresSwizzle(
+ bool must_support_alpha) const {
+ return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
+}
+
+void BitmapRasterBufferProvider::Shutdown() {}
+
+} // namespace cc
diff --git a/cc/raster/bitmap_raster_buffer_provider.h b/cc/raster/bitmap_raster_buffer_provider.h
new file mode 100644
index 0000000..045622626
--- /dev/null
+++ b/cc/raster/bitmap_raster_buffer_provider.h
@@ -0,0 +1,55 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_RASTER_BITMAP_RASTER_BUFFER_PROVIDER_H_
+#define CC_RASTER_BITMAP_RASTER_BUFFER_PROVIDER_H_
+
+#include <stdint.h>
+
+#include "base/macros.h"
+#include "base/values.h"
+#include "cc/raster/raster_buffer_provider.h"
+
+namespace base {
+namespace trace_event {
+class ConvertableToTraceFormat;
+}
+}
+
+namespace cc {
+class ResourceProvider;
+
+class CC_EXPORT BitmapRasterBufferProvider : public RasterBufferProvider {
+ public:
+ ~BitmapRasterBufferProvider() override;
+
+ static std::unique_ptr<RasterBufferProvider> Create(
+ ResourceProvider* resource_provider);
+
+ // Overridden from RasterBufferProvider:
+ std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) override;
+ void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
+ void OrderingBarrier() override;
+ ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+ bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
+ void Shutdown() override;
+
+ protected:
+ explicit BitmapRasterBufferProvider(ResourceProvider* resource_provider);
+
+ private:
+ std::unique_ptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
+ const;
+
+ ResourceProvider* resource_provider_;
+
+ DISALLOW_COPY_AND_ASSIGN(BitmapRasterBufferProvider);
+};
+
+} // namespace cc
+
+#endif // CC_RASTER_BITMAP_RASTER_BUFFER_PROVIDER_H_
diff --git a/cc/raster/bitmap_tile_task_worker_pool.cc b/cc/raster/bitmap_tile_task_worker_pool.cc
deleted file mode 100644
index c08bdcd..0000000
--- a/cc/raster/bitmap_tile_task_worker_pool.cc
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "cc/raster/bitmap_tile_task_worker_pool.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "cc/debug/traced_value.h"
-#include "cc/playback/raster_source.h"
-#include "cc/resources/platform_color.h"
-#include "cc/resources/resource.h"
-
-namespace cc {
-namespace {
-
-class RasterBufferImpl : public RasterBuffer {
- public:
- RasterBufferImpl(ResourceProvider* resource_provider,
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id)
- : lock_(resource_provider, resource->id()),
- resource_(resource),
- resource_has_previous_content_(
- resource_content_id && resource_content_id == previous_content_id) {
- }
-
- // Overridden from RasterBuffer:
- void Playback(
- const RasterSource* raster_source,
- const gfx::Rect& raster_full_rect,
- const gfx::Rect& raster_dirty_rect,
- uint64_t new_content_id,
- float scale,
- const RasterSource::PlaybackSettings& playback_settings) override {
- gfx::Rect playback_rect = raster_full_rect;
- if (resource_has_previous_content_) {
- playback_rect.Intersect(raster_dirty_rect);
- }
- DCHECK(!playback_rect.IsEmpty())
- << "Why are we rastering a tile that's not dirty?";
-
- size_t stride = 0u;
- TileTaskWorkerPool::PlaybackToMemory(
- lock_.sk_bitmap().getPixels(), resource_->format(), resource_->size(),
- stride, raster_source, raster_full_rect, playback_rect, scale,
- playback_settings);
- }
-
- private:
- ResourceProvider::ScopedWriteLockSoftware lock_;
- const Resource* resource_;
- bool resource_has_previous_content_;
-
- DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
-};
-
-} // namespace
-
-// static
-std::unique_ptr<TileTaskWorkerPool> BitmapTileTaskWorkerPool::Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider) {
- return base::WrapUnique<TileTaskWorkerPool>(new BitmapTileTaskWorkerPool(
- task_runner, task_graph_runner, resource_provider));
-}
-
-BitmapTileTaskWorkerPool::BitmapTileTaskWorkerPool(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider)
- : task_runner_(task_runner),
- task_graph_runner_(task_graph_runner),
- namespace_token_(task_graph_runner->GetNamespaceToken()),
- resource_provider_(resource_provider) {}
-
-BitmapTileTaskWorkerPool::~BitmapTileTaskWorkerPool() {
-}
-
-void BitmapTileTaskWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "BitmapTileTaskWorkerPool::Shutdown");
-
- TaskGraph empty;
- task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
- task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-}
-
-void BitmapTileTaskWorkerPool::ScheduleTasks(TaskGraph* graph) {
- TRACE_EVENT0("cc", "BitmapTileTaskWorkerPool::ScheduleTasks");
-
- ScheduleTasksOnOriginThread(this, graph);
- task_graph_runner_->ScheduleTasks(namespace_token_, graph);
-}
-
-void BitmapTileTaskWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "BitmapTileTaskWorkerPool::CheckForCompletedTasks");
-
- task_graph_runner_->CollectCompletedTasks(namespace_token_,
- &completed_tasks_);
- for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end(); ++it) {
- TileTask* task = static_cast<TileTask*>(it->get());
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
- }
- completed_tasks_.clear();
-}
-
-ResourceFormat BitmapTileTaskWorkerPool::GetResourceFormat(
- bool must_support_alpha) const {
- return resource_provider_->best_texture_format();
-}
-
-bool BitmapTileTaskWorkerPool::GetResourceRequiresSwizzle(
- bool must_support_alpha) const {
- return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
-}
-
-RasterBufferProvider* BitmapTileTaskWorkerPool::AsRasterBufferProvider() {
- return this;
-}
-
-std::unique_ptr<RasterBuffer> BitmapTileTaskWorkerPool::AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) {
- return std::unique_ptr<RasterBuffer>(new RasterBufferImpl(
- resource_provider_, resource, resource_content_id, previous_content_id));
-}
-
-void BitmapTileTaskWorkerPool::ReleaseBufferForRaster(
- std::unique_ptr<RasterBuffer> buffer) {
- // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
-}
-
-} // namespace cc
diff --git a/cc/raster/bitmap_tile_task_worker_pool.h b/cc/raster/bitmap_tile_task_worker_pool.h
deleted file mode 100644
index 5d7e409..0000000
--- a/cc/raster/bitmap_tile_task_worker_pool.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CC_RASTER_BITMAP_TILE_TASK_WORKER_POOL_H_
-#define CC_RASTER_BITMAP_TILE_TASK_WORKER_POOL_H_
-
-#include <stdint.h>
-
-#include "base/macros.h"
-#include "base/values.h"
-#include "cc/raster/tile_task_worker_pool.h"
-
-namespace base {
-namespace trace_event {
-class ConvertableToTraceFormat;
-}
-}
-
-namespace cc {
-class ResourceProvider;
-
-class CC_EXPORT BitmapTileTaskWorkerPool : public TileTaskWorkerPool,
- public RasterBufferProvider {
- public:
- ~BitmapTileTaskWorkerPool() override;
-
- static std::unique_ptr<TileTaskWorkerPool> Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider);
-
- // Overridden from TileTaskWorkerPool:
- void Shutdown() override;
- void ScheduleTasks(TaskGraph* graph) override;
- void CheckForCompletedTasks() override;
- ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
- bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
- RasterBufferProvider* AsRasterBufferProvider() override;
-
- // Overridden from RasterBufferProvider:
- std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) override;
- void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
-
- protected:
- BitmapTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider);
-
- private:
- std::unique_ptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
- const;
-
- scoped_refptr<base::SequencedTaskRunner> task_runner_;
- TaskGraphRunner* task_graph_runner_;
- const NamespaceToken namespace_token_;
- ResourceProvider* resource_provider_;
-
- Task::Vector completed_tasks_;
-
- DISALLOW_COPY_AND_ASSIGN(BitmapTileTaskWorkerPool);
-};
-
-} // namespace cc
-
-#endif // CC_RASTER_BITMAP_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/raster/gpu_tile_task_worker_pool.cc b/cc/raster/gpu_raster_buffer_provider.cc
similarity index 65%
rename from cc/raster/gpu_tile_task_worker_pool.cc
rename to cc/raster/gpu_raster_buffer_provider.cc
index c1f82d1..51d8898 100644
--- a/cc/raster/gpu_tile_task_worker_pool.cc
+++ b/cc/raster/gpu_raster_buffer_provider.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/raster/gpu_tile_task_worker_pool.h"
+#include "cc/raster/gpu_raster_buffer_provider.h"
#include <stdint.h>
@@ -89,96 +89,29 @@
} // namespace
// static
-std::unique_ptr<TileTaskWorkerPool> GpuTileTaskWorkerPool::Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
+std::unique_ptr<RasterBufferProvider> GpuRasterBufferProvider::Create(
ContextProvider* context_provider,
ResourceProvider* resource_provider,
bool use_distance_field_text,
int gpu_rasterization_msaa_sample_count) {
- return base::WrapUnique<TileTaskWorkerPool>(new GpuTileTaskWorkerPool(
- task_runner, task_graph_runner, context_provider, resource_provider,
- use_distance_field_text, gpu_rasterization_msaa_sample_count));
+ return base::WrapUnique<RasterBufferProvider>(new GpuRasterBufferProvider(
+ context_provider, resource_provider, use_distance_field_text,
+ gpu_rasterization_msaa_sample_count));
}
-GpuTileTaskWorkerPool::GpuTileTaskWorkerPool(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
+GpuRasterBufferProvider::GpuRasterBufferProvider(
ContextProvider* context_provider,
ResourceProvider* resource_provider,
bool use_distance_field_text,
int gpu_rasterization_msaa_sample_count)
- : task_runner_(task_runner),
- task_graph_runner_(task_graph_runner),
- namespace_token_(task_graph_runner_->GetNamespaceToken()),
- rasterizer_(new GpuRasterizer(context_provider,
+ : rasterizer_(new GpuRasterizer(context_provider,
resource_provider,
use_distance_field_text,
gpu_rasterization_msaa_sample_count)) {}
-GpuTileTaskWorkerPool::~GpuTileTaskWorkerPool() {
- DCHECK_EQ(0u, completed_tasks_.size());
-}
+GpuRasterBufferProvider::~GpuRasterBufferProvider() {}
-void GpuTileTaskWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::Shutdown");
-
- TaskGraph empty;
- task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
- task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-}
-
-void GpuTileTaskWorkerPool::ScheduleTasks(TaskGraph* graph) {
- TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::ScheduleTasks");
-
- ScheduleTasksOnOriginThread(this, graph);
-
- // Barrier to sync any new resources to the worker context.
- rasterizer_->resource_provider()
- ->output_surface()
- ->context_provider()
- ->ContextGL()
- ->OrderingBarrierCHROMIUM();
-
- task_graph_runner_->ScheduleTasks(namespace_token_, graph);
-}
-
-void GpuTileTaskWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "GpuTileTaskWorkerPool::CheckForCompletedTasks");
-
- task_graph_runner_->CollectCompletedTasks(namespace_token_,
- &completed_tasks_);
- CompleteTasks(completed_tasks_);
- completed_tasks_.clear();
-}
-
-ResourceFormat GpuTileTaskWorkerPool::GetResourceFormat(
- bool must_support_alpha) const {
- return rasterizer_->resource_provider()->best_render_buffer_format();
-}
-
-bool GpuTileTaskWorkerPool::GetResourceRequiresSwizzle(
- bool must_support_alpha) const {
- // This doesn't require a swizzle because we rasterize to the correct format.
- return false;
-}
-
-RasterBufferProvider* GpuTileTaskWorkerPool::AsRasterBufferProvider() {
- return this;
-}
-
-void GpuTileTaskWorkerPool::CompleteTasks(const Task::Vector& tasks) {
- for (auto& task : tasks) {
- TileTask* tile_task = static_cast<TileTask*>(task.get());
-
- tile_task->WillComplete();
- tile_task->CompleteOnOriginThread(this);
- tile_task->DidComplete();
- }
- completed_tasks_.clear();
-}
-
-std::unique_ptr<RasterBuffer> GpuTileTaskWorkerPool::AcquireBufferForRaster(
+std::unique_ptr<RasterBuffer> GpuRasterBufferProvider::AcquireBufferForRaster(
const Resource* resource,
uint64_t resource_content_id,
uint64_t previous_content_id) {
@@ -186,9 +119,32 @@
rasterizer_.get(), resource, resource_content_id, previous_content_id));
}
-void GpuTileTaskWorkerPool::ReleaseBufferForRaster(
+void GpuRasterBufferProvider::ReleaseBufferForRaster(
std::unique_ptr<RasterBuffer> buffer) {
// Nothing to do here. RasterBufferImpl destructor cleans up after itself.
}
+void GpuRasterBufferProvider::OrderingBarrier() {
+ TRACE_EVENT0("cc", "GpuRasterBufferProvider::OrderingBarrier");
+
+ rasterizer_->resource_provider()
+ ->output_surface()
+ ->context_provider()
+ ->ContextGL()
+ ->OrderingBarrierCHROMIUM();
+}
+
+ResourceFormat GpuRasterBufferProvider::GetResourceFormat(
+ bool must_support_alpha) const {
+ return rasterizer_->resource_provider()->best_render_buffer_format();
+}
+
+bool GpuRasterBufferProvider::GetResourceRequiresSwizzle(
+ bool must_support_alpha) const {
+ // This doesn't require a swizzle because we rasterize to the correct format.
+ return false;
+}
+
+void GpuRasterBufferProvider::Shutdown() {}
+
} // namespace cc
diff --git a/cc/raster/gpu_raster_buffer_provider.h b/cc/raster/gpu_raster_buffer_provider.h
new file mode 100644
index 0000000..3bbc806
--- /dev/null
+++ b/cc/raster/gpu_raster_buffer_provider.h
@@ -0,0 +1,52 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_RASTER_GPU_RASTER_BUFFER_PROVIDER_H_
+#define CC_RASTER_GPU_RASTER_BUFFER_PROVIDER_H_
+
+#include <stdint.h>
+
+#include "base/macros.h"
+#include "cc/raster/raster_buffer_provider.h"
+
+namespace cc {
+class ContextProvider;
+class GpuRasterizer;
+class ResourceProvider;
+
+class CC_EXPORT GpuRasterBufferProvider : public RasterBufferProvider {
+ public:
+ ~GpuRasterBufferProvider() override;
+
+ static std::unique_ptr<RasterBufferProvider> Create(
+ ContextProvider* context_provider,
+ ResourceProvider* resource_provider,
+ bool use_distance_field_text,
+ int gpu_rasterization_msaa_sample_count);
+
+ // Overridden from RasterBufferProvider:
+ std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) override;
+ void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
+ void OrderingBarrier() override;
+ ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+ bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
+ void Shutdown() override;
+
+ private:
+ GpuRasterBufferProvider(ContextProvider* context_provider,
+ ResourceProvider* resource_provider,
+ bool use_distance_field_text,
+ int gpu_rasterization_msaa_sample_count);
+
+ std::unique_ptr<GpuRasterizer> rasterizer_;
+
+ DISALLOW_COPY_AND_ASSIGN(GpuRasterBufferProvider);
+};
+
+} // namespace cc
+
+#endif // CC_RASTER_GPU_RASTER_BUFFER_PROVIDER_H_
diff --git a/cc/raster/gpu_rasterizer.h b/cc/raster/gpu_rasterizer.h
index d195143..3e2c9e9d 100644
--- a/cc/raster/gpu_rasterizer.h
+++ b/cc/raster/gpu_rasterizer.h
@@ -44,7 +44,7 @@
bool use_distance_field_text_;
int msaa_sample_count_;
- friend class GpuTileTaskWorkerPool;
+ friend class GpuRasterBufferProvider;
DISALLOW_COPY_AND_ASSIGN(GpuRasterizer);
};
diff --git a/cc/raster/gpu_tile_task_worker_pool.h b/cc/raster/gpu_tile_task_worker_pool.h
deleted file mode 100644
index a0a7291..0000000
--- a/cc/raster/gpu_tile_task_worker_pool.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CC_RASTER_GPU_TILE_TASK_WORKER_POOL_H_
-#define CC_RASTER_GPU_TILE_TASK_WORKER_POOL_H_
-
-#include <stdint.h>
-
-#include "base/macros.h"
-#include "cc/raster/tile_task_worker_pool.h"
-
-namespace cc {
-class ContextProvider;
-class GpuRasterizer;
-class ResourceProvider;
-
-class CC_EXPORT GpuTileTaskWorkerPool : public TileTaskWorkerPool,
- public RasterBufferProvider {
- public:
- ~GpuTileTaskWorkerPool() override;
-
- static std::unique_ptr<TileTaskWorkerPool> Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ContextProvider* context_provider,
- ResourceProvider* resource_provider,
- bool use_distance_field_text,
- int gpu_rasterization_msaa_sample_count);
-
- // Overridden from TileTaskWorkerPool:
- void Shutdown() override;
- void ScheduleTasks(TaskGraph* graph) override;
- void CheckForCompletedTasks() override;
- ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
- bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
- RasterBufferProvider* AsRasterBufferProvider() override;
-
- // Overridden from RasterBufferProvider:
- std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) override;
- void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
-
- private:
- GpuTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ContextProvider* context_provider,
- ResourceProvider* resource_provider,
- bool use_distance_field_text,
- int gpu_rasterization_msaa_sample_count);
-
- void CompleteTasks(const Task::Vector& tasks);
-
- scoped_refptr<base::SequencedTaskRunner> task_runner_;
- TaskGraphRunner* task_graph_runner_;
- const NamespaceToken namespace_token_;
- std::unique_ptr<GpuRasterizer> rasterizer_;
-
- Task::Vector completed_tasks_;
-
- DISALLOW_COPY_AND_ASSIGN(GpuTileTaskWorkerPool);
-};
-
-} // namespace cc
-
-#endif // CC_RASTER_GPU_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/raster/one_copy_tile_task_worker_pool.cc b/cc/raster/one_copy_raster_buffer_provider.cc
similarity index 81%
rename from cc/raster/one_copy_tile_task_worker_pool.cc
rename to cc/raster/one_copy_raster_buffer_provider.cc
index 3c12301f..816820b 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.cc
+++ b/cc/raster/one_copy_raster_buffer_provider.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/raster/one_copy_tile_task_worker_pool.h"
+#include "cc/raster/one_copy_raster_buffer_provider.h"
#include <stdint.h>
@@ -27,7 +27,7 @@
class RasterBufferImpl : public RasterBuffer {
public:
- RasterBufferImpl(OneCopyTileTaskWorkerPool* worker_pool,
+ RasterBufferImpl(OneCopyRasterBufferProvider* worker_pool,
ResourceProvider* resource_provider,
ResourceFormat resource_format,
const Resource* resource,
@@ -53,7 +53,7 @@
}
private:
- OneCopyTileTaskWorkerPool* worker_pool_;
+ OneCopyRasterBufferProvider* worker_pool_;
const Resource* resource_;
ResourceProvider::ScopedWriteLockGL lock_;
uint64_t previous_content_id_;
@@ -68,32 +68,28 @@
} // namespace
// static
-std::unique_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
+std::unique_ptr<RasterBufferProvider> OneCopyRasterBufferProvider::Create(
base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
int max_copy_texture_chromium_size,
bool use_partial_raster,
int max_staging_buffer_usage_in_bytes,
ResourceFormat preferred_tile_format) {
- return base::WrapUnique<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool(
- task_runner, task_graph_runner, resource_provider,
- max_copy_texture_chromium_size, use_partial_raster,
- max_staging_buffer_usage_in_bytes, preferred_tile_format));
+ return base::WrapUnique<RasterBufferProvider>(new OneCopyRasterBufferProvider(
+ task_runner, resource_provider, max_copy_texture_chromium_size,
+ use_partial_raster, max_staging_buffer_usage_in_bytes,
+ preferred_tile_format));
}
-OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
+OneCopyRasterBufferProvider::OneCopyRasterBufferProvider(
base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
ResourceProvider* resource_provider,
int max_copy_texture_chromium_size,
bool use_partial_raster,
int max_staging_buffer_usage_in_bytes,
ResourceFormat preferred_tile_format)
- : task_graph_runner_(task_graph_runner),
- namespace_token_(task_graph_runner->GetNamespaceToken()),
- resource_provider_(resource_provider),
+ : resource_provider_(resource_provider),
max_bytes_per_copy_operation_(
max_copy_texture_chromium_size
? std::min(kMaxBytesPerCopyOperation,
@@ -107,71 +103,10 @@
max_staging_buffer_usage_in_bytes);
}
-OneCopyTileTaskWorkerPool::~OneCopyTileTaskWorkerPool() {
-}
+OneCopyRasterBufferProvider::~OneCopyRasterBufferProvider() {}
-void OneCopyTileTaskWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::Shutdown");
-
- TaskGraph empty;
- task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
- task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-
- staging_pool_->Shutdown();
-}
-
-void OneCopyTileTaskWorkerPool::ScheduleTasks(TaskGraph* graph) {
- TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::ScheduleTasks");
-
- ScheduleTasksOnOriginThread(this, graph);
-
- // Barrier to sync any new resources to the worker context.
- resource_provider_->output_surface()
- ->context_provider()
- ->ContextGL()
- ->OrderingBarrierCHROMIUM();
-
- task_graph_runner_->ScheduleTasks(namespace_token_, graph);
-}
-
-void OneCopyTileTaskWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "OneCopyTileTaskWorkerPool::CheckForCompletedTasks");
-
- task_graph_runner_->CollectCompletedTasks(namespace_token_,
- &completed_tasks_);
-
- for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end(); ++it) {
- TileTask* task = static_cast<TileTask*>(it->get());
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
- }
- completed_tasks_.clear();
-}
-
-ResourceFormat OneCopyTileTaskWorkerPool::GetResourceFormat(
- bool must_support_alpha) const {
- if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) &&
- (DoesResourceFormatSupportAlpha(preferred_tile_format_) ||
- !must_support_alpha)) {
- return preferred_tile_format_;
- }
-
- return resource_provider_->best_texture_format();
-}
-
-bool OneCopyTileTaskWorkerPool::GetResourceRequiresSwizzle(
- bool must_support_alpha) const {
- return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
-}
-
-RasterBufferProvider* OneCopyTileTaskWorkerPool::AsRasterBufferProvider() {
- return this;
-}
-
-std::unique_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
+std::unique_ptr<RasterBuffer>
+OneCopyRasterBufferProvider::AcquireBufferForRaster(
const Resource* resource,
uint64_t resource_content_id,
uint64_t previous_content_id) {
@@ -182,12 +117,41 @@
resource, previous_content_id));
}
-void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
+void OneCopyRasterBufferProvider::ReleaseBufferForRaster(
std::unique_ptr<RasterBuffer> buffer) {
// Nothing to do here. RasterBufferImpl destructor cleans up after itself.
}
-void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
+void OneCopyRasterBufferProvider::OrderingBarrier() {
+ TRACE_EVENT0("cc", "OneCopyRasterBufferProvider::OrderingBarrier");
+
+ resource_provider_->output_surface()
+ ->context_provider()
+ ->ContextGL()
+ ->OrderingBarrierCHROMIUM();
+}
+
+ResourceFormat OneCopyRasterBufferProvider::GetResourceFormat(
+ bool must_support_alpha) const {
+ if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) &&
+ (DoesResourceFormatSupportAlpha(preferred_tile_format_) ||
+ !must_support_alpha)) {
+ return preferred_tile_format_;
+ }
+
+ return resource_provider_->best_texture_format();
+}
+
+bool OneCopyRasterBufferProvider::GetResourceRequiresSwizzle(
+ bool must_support_alpha) const {
+ return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
+}
+
+void OneCopyRasterBufferProvider::Shutdown() {
+ staging_pool_->Shutdown();
+}
+
+void OneCopyRasterBufferProvider::PlaybackAndCopyOnWorkerThread(
const Resource* resource,
ResourceProvider::ScopedWriteLockGL* resource_lock,
const RasterSource* raster_source,
@@ -211,7 +175,7 @@
staging_pool_->ReleaseStagingBuffer(std::move(staging_buffer));
}
-void OneCopyTileTaskWorkerPool::PlaybackToStagingBuffer(
+void OneCopyRasterBufferProvider::PlaybackToStagingBuffer(
StagingBuffer* staging_buffer,
const Resource* resource,
const RasterSource* raster_source,
@@ -248,12 +212,12 @@
bool rv = buffer->Map();
DCHECK(rv);
DCHECK(buffer->memory(0));
- // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides.
+ // RasterBufferProvider::PlaybackToMemory only supports unsigned strides.
DCHECK_GE(buffer->stride(0), 0);
DCHECK(!playback_rect.IsEmpty())
<< "Why are we rastering a tile that's not dirty?";
- TileTaskWorkerPool::PlaybackToMemory(
+ RasterBufferProvider::PlaybackToMemory(
buffer->memory(0), resource->format(), staging_buffer->size,
buffer->stride(0), raster_source, raster_full_rect, playback_rect,
scale, playback_settings);
@@ -262,7 +226,7 @@
}
}
-void OneCopyTileTaskWorkerPool::CopyOnWorkerThread(
+void OneCopyRasterBufferProvider::CopyOnWorkerThread(
StagingBuffer* staging_buffer,
const Resource* resource,
ResourceProvider::ScopedWriteLockGL* resource_lock,
diff --git a/cc/raster/one_copy_tile_task_worker_pool.h b/cc/raster/one_copy_raster_buffer_provider.h
similarity index 67%
rename from cc/raster/one_copy_tile_task_worker_pool.h
rename to cc/raster/one_copy_raster_buffer_provider.h
index da41020e..0c129fa 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.h
+++ b/cc/raster/one_copy_raster_buffer_provider.h
@@ -2,14 +2,14 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_
-#define CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_
+#ifndef CC_RASTER_ONE_COPY_RASTER_BUFFER_PROVIDER_H_
+#define CC_RASTER_ONE_COPY_RASTER_BUFFER_PROVIDER_H_
#include <stdint.h>
#include "base/macros.h"
#include "cc/output/context_provider.h"
-#include "cc/raster/tile_task_worker_pool.h"
+#include "cc/raster/raster_buffer_provider.h"
#include "cc/resources/resource_provider.h"
namespace cc {
@@ -17,14 +17,12 @@
class StagingBufferPool;
class ResourcePool;
-class CC_EXPORT OneCopyTileTaskWorkerPool : public TileTaskWorkerPool,
- public RasterBufferProvider {
+class CC_EXPORT OneCopyRasterBufferProvider : public RasterBufferProvider {
public:
- ~OneCopyTileTaskWorkerPool() override;
+ ~OneCopyRasterBufferProvider() override;
- static std::unique_ptr<TileTaskWorkerPool> Create(
+ static std::unique_ptr<RasterBufferProvider> Create(
base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
ContextProvider* context_provider,
ResourceProvider* resource_provider,
int max_copy_texture_chromium_size,
@@ -32,20 +30,16 @@
int max_staging_buffer_usage_in_bytes,
ResourceFormat preferred_tile_format);
- // Overridden from TileTaskWorkerPool:
- void Shutdown() override;
- void ScheduleTasks(TaskGraph* graph) override;
- void CheckForCompletedTasks() override;
- ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
- bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
- RasterBufferProvider* AsRasterBufferProvider() override;
-
// Overridden from RasterBufferProvider:
std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
const Resource* resource,
uint64_t resource_content_id,
uint64_t previous_content_id) override;
void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
+ void OrderingBarrier() override;
+ ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+ bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
+ void Shutdown() override;
// Playback raster source and copy result into |resource|.
void PlaybackAndCopyOnWorkerThread(
@@ -60,13 +54,12 @@
uint64_t new_content_id);
protected:
- OneCopyTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider,
- int max_copy_texture_chromium_size,
- bool use_partial_raster,
- int max_staging_buffer_usage_in_bytes,
- ResourceFormat preferred_tile_format);
+ OneCopyRasterBufferProvider(base::SequencedTaskRunner* task_runner,
+ ResourceProvider* resource_provider,
+ int max_copy_texture_chromium_size,
+ bool use_partial_raster,
+ int max_staging_buffer_usage_in_bytes,
+ ResourceFormat preferred_tile_format);
private:
void PlaybackToStagingBuffer(
@@ -86,8 +79,6 @@
uint64_t previous_content_id,
uint64_t new_content_id);
- TaskGraphRunner* task_graph_runner_;
- const NamespaceToken namespace_token_;
ResourceProvider* const resource_provider_;
const int max_bytes_per_copy_operation_;
bool use_partial_raster_;
@@ -98,11 +89,9 @@
ResourceFormat preferred_tile_format_;
std::unique_ptr<StagingBufferPool> staging_pool_;
- Task::Vector completed_tasks_;
-
- DISALLOW_COPY_AND_ASSIGN(OneCopyTileTaskWorkerPool);
+ DISALLOW_COPY_AND_ASSIGN(OneCopyRasterBufferProvider);
};
} // namespace cc
-#endif // CC_RASTER_ONE_COPY_TILE_TASK_WORKER_POOL_H_
+#endif // CC_RASTER_ONE_COPY_RASTER_BUFFER_PROVIDER_H_
diff --git a/cc/raster/raster_buffer.h b/cc/raster/raster_buffer.h
index 54c5b9e..04972f9d 100644
--- a/cc/raster/raster_buffer.h
+++ b/cc/raster/raster_buffer.h
@@ -12,20 +12,6 @@
#include "ui/gfx/geometry/rect.h"
namespace cc {
-class RasterBuffer;
-class Resource;
-
-class CC_EXPORT RasterBufferProvider {
- public:
- virtual std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) = 0;
- virtual void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) = 0;
-
- protected:
- virtual ~RasterBufferProvider() {}
-};
class CC_EXPORT RasterBuffer {
public:
diff --git a/cc/raster/tile_task_worker_pool.cc b/cc/raster/raster_buffer_provider.cc
similarity index 80%
rename from cc/raster/tile_task_worker_pool.cc
rename to cc/raster/raster_buffer_provider.cc
index b14cd836..67b839c 100644
--- a/cc/raster/tile_task_worker_pool.cc
+++ b/cc/raster/raster_buffer_provider.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/raster/tile_task_worker_pool.h"
+#include "cc/raster/raster_buffer_provider.h"
#include <stddef.h>
@@ -15,28 +15,9 @@
namespace cc {
-TileTaskWorkerPool::TileTaskWorkerPool() {}
+RasterBufferProvider::RasterBufferProvider() {}
-TileTaskWorkerPool::~TileTaskWorkerPool() {}
-
-// static
-void TileTaskWorkerPool::ScheduleTasksOnOriginThread(
- RasterBufferProvider* provider,
- TaskGraph* graph) {
- TRACE_EVENT0("cc", "TileTaskWorkerPool::ScheduleTasksOnOriginThread");
-
- for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
- it != graph->nodes.end(); ++it) {
- TaskGraph::Node& node = *it;
- TileTask* task = static_cast<TileTask*>(node.task);
-
- if (!task->HasBeenScheduled()) {
- task->WillSchedule();
- task->ScheduleOnOriginThread(provider);
- task->DidSchedule();
- }
- }
-}
+RasterBufferProvider::~RasterBufferProvider() {}
namespace {
@@ -61,7 +42,7 @@
} // anonymous namespace
// static
-void TileTaskWorkerPool::PlaybackToMemory(
+void RasterBufferProvider::PlaybackToMemory(
void* memory,
ResourceFormat format,
const gfx::Size& size,
@@ -71,7 +52,7 @@
const gfx::Rect& canvas_playback_rect,
float scale,
const RasterSource::PlaybackSettings& playback_settings) {
- TRACE_EVENT0("cc", "TileTaskWorkerPool::PlaybackToMemory");
+ TRACE_EVENT0("cc", "RasterBufferProvider::PlaybackToMemory");
DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format;
@@ -111,7 +92,7 @@
if (format == ETC1) {
TRACE_EVENT0("cc",
- "TileTaskWorkerPool::PlaybackToMemory::CompressETC1");
+ "RasterBufferProvider::PlaybackToMemory::CompressETC1");
DCHECK_EQ(size.width() % 4, 0);
DCHECK_EQ(size.height() % 4, 0);
std::unique_ptr<TextureCompressor> texture_compressor =
@@ -124,7 +105,7 @@
TextureCompressor::kQualityHigh);
} else {
TRACE_EVENT0("cc",
- "TileTaskWorkerPool::PlaybackToMemory::ConvertRGBA4444");
+ "RasterBufferProvider::PlaybackToMemory::ConvertRGBA4444");
SkImageInfo dst_info =
SkImageInfo::Make(info.width(), info.height(),
ResourceFormatToClosestSkColorType(format),
@@ -146,7 +127,8 @@
NOTREACHED();
}
-bool TileTaskWorkerPool::ResourceFormatRequiresSwizzle(ResourceFormat format) {
+bool RasterBufferProvider::ResourceFormatRequiresSwizzle(
+ ResourceFormat format) {
switch (format) {
case RGBA_8888:
case BGRA_8888:
diff --git a/cc/raster/raster_buffer_provider.h b/cc/raster/raster_buffer_provider.h
new file mode 100644
index 0000000..061740a
--- /dev/null
+++ b/cc/raster/raster_buffer_provider.h
@@ -0,0 +1,75 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_RASTER_RASTER_BUFFER_PROVIDER_H_
+#define CC_RASTER_RASTER_BUFFER_PROVIDER_H_
+
+#include <stddef.h>
+
+#include "cc/playback/raster_source.h"
+#include "cc/raster/raster_buffer.h"
+#include "cc/raster/task_graph_runner.h"
+#include "cc/raster/tile_task.h"
+#include "cc/resources/resource_format.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace base {
+class SequencedTaskRunner;
+}
+
+namespace cc {
+class Resource;
+
+class CC_EXPORT RasterBufferProvider {
+ public:
+ RasterBufferProvider();
+ virtual ~RasterBufferProvider();
+
+ // Utility function that will create a temporary bitmap and copy pixels to
+ // |memory| when necessary. The |canvas_bitmap_rect| is the rect of the bitmap
+ // being played back in the pixel space of the source, ie a rect in the source
+ // that will cover the resulting |memory|. The |canvas_playback_rect| can be a
+ // smaller contained rect inside the |canvas_bitmap_rect| if the |memory| is
+ // already partially complete, and only the subrect needs to be played back.
+ static void PlaybackToMemory(
+ void* memory,
+ ResourceFormat format,
+ const gfx::Size& size,
+ size_t stride,
+ const RasterSource* raster_source,
+ const gfx::Rect& canvas_bitmap_rect,
+ const gfx::Rect& canvas_playback_rect,
+ float scale,
+ const RasterSource::PlaybackSettings& playback_settings);
+
+ // Acquire raster buffer.
+ virtual std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) = 0;
+
+ // Release raster buffer.
+ virtual void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) = 0;
+
+ // Barrier to sync resources to the worker context.
+ virtual void OrderingBarrier() = 0;
+
+ // Returns the format to use for the tiles.
+ virtual ResourceFormat GetResourceFormat(bool must_support_alpha) const = 0;
+
+ // Determine if the resource requires swizzling.
+ virtual bool GetResourceRequiresSwizzle(bool must_support_alpha) const = 0;
+
+ // Shutdown for doing cleanup.
+ virtual void Shutdown() = 0;
+
+ protected:
+ // Check if resource format matches output format.
+ static bool ResourceFormatRequiresSwizzle(ResourceFormat format);
+};
+
+} // namespace cc
+
+#endif // CC_RASTER_RASTER_BUFFER_PROVIDER_H_
diff --git a/cc/raster/tile_task_worker_pool_perftest.cc b/cc/raster/raster_buffer_provider_perftest.cc
similarity index 74%
rename from cc/raster/tile_task_worker_pool_perftest.cc
rename to cc/raster/raster_buffer_provider_perftest.cc
index 41e2c6f..c031b4c 100644
--- a/cc/raster/tile_task_worker_pool_perftest.cc
+++ b/cc/raster/raster_buffer_provider_perftest.cc
@@ -11,13 +11,13 @@
#include "base/time/time.h"
#include "cc/debug/lap_timer.h"
#include "cc/output/context_provider.h"
-#include "cc/raster/bitmap_tile_task_worker_pool.h"
+#include "cc/raster/bitmap_raster_buffer_provider.h"
+#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/gpu_rasterizer.h"
-#include "cc/raster/gpu_tile_task_worker_pool.h"
-#include "cc/raster/one_copy_tile_task_worker_pool.h"
+#include "cc/raster/one_copy_raster_buffer_provider.h"
+#include "cc/raster/raster_buffer_provider.h"
#include "cc/raster/synchronous_task_graph_runner.h"
-#include "cc/raster/tile_task_worker_pool.h"
-#include "cc/raster/zero_copy_tile_task_worker_pool.h"
+#include "cc/raster/zero_copy_raster_buffer_provider.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/scoped_resource.h"
@@ -28,6 +28,7 @@
#include "cc/test/test_gpu_memory_buffer_manager.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_web_graphics_context_3d.h"
+#include "cc/tiles/tile_task_manager.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/perf/perf_test.h"
#include "third_party/khronos/GLES2/gl2.h"
@@ -110,11 +111,11 @@
base::Lock context_lock_;
};
-enum TileTaskWorkerPoolType {
- TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
- TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
- TILE_TASK_WORKER_POOL_TYPE_GPU,
- TILE_TASK_WORKER_POOL_TYPE_BITMAP
+enum RasterBufferProviderType {
+ RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_GPU,
+ RASTER_BUFFER_PROVIDER_TYPE_BITMAP
};
static const int kTimeLimitMillis = 2000;
@@ -180,13 +181,13 @@
DISALLOW_COPY_AND_ASSIGN(PerfRasterTaskImpl);
};
-class TileTaskWorkerPoolPerfTestBase {
+class RasterBufferProviderPerfTestBase {
public:
typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector;
enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
- TileTaskWorkerPoolPerfTestBase()
+ RasterBufferProviderPerfTestBase()
: context_provider_(make_scoped_refptr(new PerfContextProvider)),
task_runner_(new base::TestSimpleTaskRunner),
task_graph_runner_(new SynchronousTaskGraphRunner),
@@ -201,20 +202,19 @@
}
void CreateRasterTasks(unsigned num_raster_tasks,
- unsigned num_image_decode_tasks,
+ const TileTask::Vector& image_decode_tasks,
RasterTaskVector* raster_tasks) {
const gfx::Size size(1, 1);
for (unsigned i = 0; i < num_raster_tasks; ++i) {
- TileTask::Vector image_decode_tasks;
- CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
std::unique_ptr<ScopedResource> resource(
ScopedResource::Create(resource_provider_.get()));
resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
RGBA_8888);
+ TileTask::Vector dependencies = image_decode_tasks;
raster_tasks->push_back(
- new PerfRasterTaskImpl(std::move(resource), &image_decode_tasks));
+ new PerfRasterTaskImpl(std::move(resource), &dependencies));
}
}
@@ -226,8 +226,18 @@
priority++;
for (auto& decode_task : raster_task->dependencies()) {
- graph->nodes.push_back(
- TaskGraph::Node(decode_task.get(), 0u /* group */, priority, 0u));
+ // Add decode task if it doesn't already exist in graph.
+ TaskGraph::Node::Vector::iterator decode_it =
+ std::find_if(graph->nodes.begin(), graph->nodes.end(),
+ [decode_task](const TaskGraph::Node& node) {
+ return node.task == decode_task;
+ });
+
+ if (decode_it == graph->nodes.end()) {
+ graph->nodes.push_back(
+ TaskGraph::Node(decode_task.get(), 0u /* group */, priority, 0u));
+ }
+
graph->edges.push_back(
TaskGraph::Edge(decode_task.get(), raster_task.get()));
}
@@ -248,47 +258,47 @@
LapTimer timer_;
};
-class TileTaskWorkerPoolPerfTest
- : public TileTaskWorkerPoolPerfTestBase,
- public testing::TestWithParam<TileTaskWorkerPoolType> {
+class RasterBufferProviderPerfTest
+ : public RasterBufferProviderPerfTestBase,
+ public testing::TestWithParam<RasterBufferProviderType> {
public:
// Overridden from testing::Test:
void SetUp() override {
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
switch (GetParam()) {
- case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
+ case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
Create3dOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
- task_runner_.get(), task_graph_runner_.get(),
+ raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
resource_provider_.get(), PlatformColor::BestTextureFormat());
break;
- case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
+ case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
Create3dOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
- task_runner_.get(), task_graph_runner_.get(),
- context_provider_.get(), resource_provider_.get(),
- std::numeric_limits<int>::max(), false,
+ raster_buffer_provider = OneCopyRasterBufferProvider::Create(
+ task_runner_.get(), context_provider_.get(),
+ resource_provider_.get(), std::numeric_limits<int>::max(), false,
std::numeric_limits<int>::max(),
PlatformColor::BestTextureFormat());
break;
- case TILE_TASK_WORKER_POOL_TYPE_GPU:
+ case RASTER_BUFFER_PROVIDER_TYPE_GPU:
Create3dOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
- task_runner_.get(), task_graph_runner_.get(),
+ raster_buffer_provider = GpuRasterBufferProvider::Create(
context_provider_.get(), resource_provider_.get(), false, 0);
break;
- case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
+ case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
CreateSoftwareOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create(
- task_runner_.get(), task_graph_runner_.get(),
- resource_provider_.get());
+ raster_buffer_provider =
+ BitmapRasterBufferProvider::Create(resource_provider_.get());
break;
}
- DCHECK(tile_task_worker_pool_);
+ DCHECK(raster_buffer_provider);
+
+ tile_task_manager_ = TileTaskManagerImpl::Create(
+ std::move(raster_buffer_provider), task_graph_runner_.get());
}
void TearDown() override {
- tile_task_worker_pool_->Shutdown();
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->Shutdown();
+ tile_task_manager_->CheckForCompletedTasks();
}
void RunMessageLoopUntilAllTasksHaveCompleted() {
@@ -299,8 +309,10 @@
void RunScheduleTasksTest(const std::string& test_name,
unsigned num_raster_tasks,
unsigned num_image_decode_tasks) {
+ TileTask::Vector image_decode_tasks;
RasterTaskVector raster_tasks;
- CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks);
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
// Avoid unnecessary heap allocations by reusing the same graph.
TaskGraph graph;
@@ -309,13 +321,13 @@
do {
graph.Reset();
BuildTileTaskGraph(&graph, raster_tasks);
- tile_task_worker_pool_->ScheduleTasks(&graph);
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->ScheduleTasks(&graph);
+ tile_task_manager_->CheckForCompletedTasks();
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
TaskGraph empty;
- tile_task_worker_pool_->ScheduleTasks(&empty);
+ tile_task_manager_->ScheduleTasks(&empty);
RunMessageLoopUntilAllTasksHaveCompleted();
perf_test::PrintResult("schedule_tasks", TestModifierString(), test_name,
@@ -326,9 +338,11 @@
unsigned num_raster_tasks,
unsigned num_image_decode_tasks) {
const size_t kNumVersions = 2;
+ TileTask::Vector image_decode_tasks[kNumVersions];
RasterTaskVector raster_tasks[kNumVersions];
for (size_t i = 0; i < kNumVersions; ++i) {
- CreateRasterTasks(num_raster_tasks, num_image_decode_tasks,
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks[i]);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks[i],
&raster_tasks[i]);
}
@@ -340,14 +354,14 @@
do {
graph.Reset();
BuildTileTaskGraph(&graph, raster_tasks[count % kNumVersions]);
- tile_task_worker_pool_->ScheduleTasks(&graph);
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->ScheduleTasks(&graph);
+ tile_task_manager_->CheckForCompletedTasks();
++count;
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
TaskGraph empty;
- tile_task_worker_pool_->ScheduleTasks(&empty);
+ tile_task_manager_->ScheduleTasks(&empty);
RunMessageLoopUntilAllTasksHaveCompleted();
perf_test::PrintResult("schedule_alternate_tasks", TestModifierString(),
@@ -357,8 +371,10 @@
void RunScheduleAndExecuteTasksTest(const std::string& test_name,
unsigned num_raster_tasks,
unsigned num_image_decode_tasks) {
+ TileTask::Vector image_decode_tasks;
RasterTaskVector raster_tasks;
- CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks);
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
// Avoid unnecessary heap allocations by reusing the same graph.
TaskGraph graph;
@@ -367,13 +383,13 @@
do {
graph.Reset();
BuildTileTaskGraph(&graph, raster_tasks);
- tile_task_worker_pool_->ScheduleTasks(&graph);
+ tile_task_manager_->ScheduleTasks(&graph);
RunMessageLoopUntilAllTasksHaveCompleted();
timer_.NextLap();
} while (!timer_.HasTimeLimitExpired());
TaskGraph empty;
- tile_task_worker_pool_->ScheduleTasks(&empty);
+ tile_task_manager_->ScheduleTasks(&empty);
RunMessageLoopUntilAllTasksHaveCompleted();
perf_test::PrintResult("schedule_and_execute_tasks", TestModifierString(),
@@ -398,25 +414,25 @@
std::string TestModifierString() const {
switch (GetParam()) {
- case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
- return std::string("_zero_copy_tile_task_worker_pool");
- case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
- return std::string("_one_copy_tile_task_worker_pool");
- case TILE_TASK_WORKER_POOL_TYPE_GPU:
- return std::string("_gpu_tile_task_worker_pool");
- case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
- return std::string("_bitmap_tile_task_worker_pool");
+ case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
+ return std::string("_zero_copy_raster_buffer_provider");
+ case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
+ return std::string("_one_copy_raster_buffer_provider");
+ case RASTER_BUFFER_PROVIDER_TYPE_GPU:
+ return std::string("_gpu_raster_buffer_provider");
+ case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
+ return std::string("_bitmap_raster_buffer_provider");
}
NOTREACHED();
return std::string();
}
- std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
+ std::unique_ptr<TileTaskManager> tile_task_manager_;
TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
TestSharedBitmapManager shared_bitmap_manager_;
};
-TEST_P(TileTaskWorkerPoolPerfTest, ScheduleTasks) {
+TEST_P(RasterBufferProviderPerfTest, ScheduleTasks) {
RunScheduleTasksTest("1_0", 1, 0);
RunScheduleTasksTest("32_0", 32, 0);
RunScheduleTasksTest("1_1", 1, 1);
@@ -425,7 +441,7 @@
RunScheduleTasksTest("32_4", 32, 4);
}
-TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAlternateTasks) {
+TEST_P(RasterBufferProviderPerfTest, ScheduleAlternateTasks) {
RunScheduleAlternateTasksTest("1_0", 1, 0);
RunScheduleAlternateTasksTest("32_0", 32, 0);
RunScheduleAlternateTasksTest("1_1", 1, 1);
@@ -434,7 +450,7 @@
RunScheduleAlternateTasksTest("32_4", 32, 4);
}
-TEST_P(TileTaskWorkerPoolPerfTest, ScheduleAndExecuteTasks) {
+TEST_P(RasterBufferProviderPerfTest, ScheduleAndExecuteTasks) {
RunScheduleAndExecuteTasksTest("1_0", 1, 0);
RunScheduleAndExecuteTasksTest("32_0", 32, 0);
RunScheduleAndExecuteTasksTest("1_1", 1, 1);
@@ -443,15 +459,16 @@
RunScheduleAndExecuteTasksTest("32_4", 32, 4);
}
-INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolPerfTests,
- TileTaskWorkerPoolPerfTest,
- ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
- TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
- TILE_TASK_WORKER_POOL_TYPE_GPU,
- TILE_TASK_WORKER_POOL_TYPE_BITMAP));
+INSTANTIATE_TEST_CASE_P(RasterBufferProviderPerfTests,
+ RasterBufferProviderPerfTest,
+ ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_GPU,
+ RASTER_BUFFER_PROVIDER_TYPE_BITMAP));
-class TileTaskWorkerPoolCommonPerfTest : public TileTaskWorkerPoolPerfTestBase,
- public testing::Test {
+class RasterBufferProviderCommonPerfTest
+ : public RasterBufferProviderPerfTestBase,
+ public testing::Test {
public:
// Overridden from testing::Test:
void SetUp() override {
@@ -464,8 +481,10 @@
void RunBuildTileTaskGraphTest(const std::string& test_name,
unsigned num_raster_tasks,
unsigned num_image_decode_tasks) {
+ TileTask::Vector image_decode_tasks;
RasterTaskVector raster_tasks;
- CreateRasterTasks(num_raster_tasks, num_image_decode_tasks, &raster_tasks);
+ CreateImageDecodeTasks(num_image_decode_tasks, &image_decode_tasks);
+ CreateRasterTasks(num_raster_tasks, image_decode_tasks, &raster_tasks);
// Avoid unnecessary heap allocations by reusing the same graph.
TaskGraph graph;
@@ -482,7 +501,7 @@
}
};
-TEST_F(TileTaskWorkerPoolCommonPerfTest, BuildTileTaskGraph) {
+TEST_F(RasterBufferProviderCommonPerfTest, BuildTileTaskGraph) {
RunBuildTileTaskGraphTest("1_0", 1, 0);
RunBuildTileTaskGraphTest("32_0", 32, 0);
RunBuildTileTaskGraphTest("1_1", 1, 1);
diff --git a/cc/raster/tile_task_worker_pool_unittest.cc b/cc/raster/raster_buffer_provider_unittest.cc
similarity index 78%
rename from cc/raster/tile_task_worker_pool_unittest.cc
rename to cc/raster/raster_buffer_provider_unittest.cc
index 53c2ae21..6890dd2 100644
--- a/cc/raster/tile_task_worker_pool_unittest.cc
+++ b/cc/raster/raster_buffer_provider_unittest.cc
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/raster/tile_task_worker_pool.h"
+#include "cc/raster/raster_buffer_provider.h"
#include <stddef.h>
#include <stdint.h>
@@ -18,12 +18,12 @@
#include "base/single_thread_task_runner.h"
#include "base/thread_task_runner_handle.h"
#include "cc/base/unique_notifier.h"
-#include "cc/raster/bitmap_tile_task_worker_pool.h"
+#include "cc/raster/bitmap_raster_buffer_provider.h"
+#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/gpu_rasterizer.h"
-#include "cc/raster/gpu_tile_task_worker_pool.h"
-#include "cc/raster/one_copy_tile_task_worker_pool.h"
+#include "cc/raster/one_copy_raster_buffer_provider.h"
#include "cc/raster/synchronous_task_graph_runner.h"
-#include "cc/raster/zero_copy_tile_task_worker_pool.h"
+#include "cc/raster/zero_copy_raster_buffer_provider.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/resource_provider.h"
#include "cc/resources/scoped_resource.h"
@@ -34,6 +34,7 @@
#include "cc/test/test_gpu_memory_buffer_manager.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_web_graphics_context_3d.h"
+#include "cc/tiles/tile_task_manager.h"
#include "gpu/GLES2/gl2extchromium.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -43,11 +44,11 @@
const size_t kMaxBytesPerCopyOperation = 1000U;
const size_t kMaxStagingBuffers = 32U;
-enum TileTaskWorkerPoolType {
- TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
- TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
- TILE_TASK_WORKER_POOL_TYPE_GPU,
- TILE_TASK_WORKER_POOL_TYPE_BITMAP
+enum RasterBufferProviderType {
+ RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_GPU,
+ RASTER_BUFFER_PROVIDER_TYPE_BITMAP
};
class TestRasterTaskImpl : public TileTask {
@@ -116,8 +117,8 @@
DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl);
};
-class TileTaskWorkerPoolTest
- : public testing::TestWithParam<TileTaskWorkerPoolType> {
+class RasterBufferProviderTest
+ : public testing::TestWithParam<RasterBufferProviderType> {
public:
struct RasterTaskResult {
unsigned id;
@@ -128,64 +129,63 @@
enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
- TileTaskWorkerPoolTest()
+ RasterBufferProviderTest()
: context_provider_(TestContextProvider::Create()),
worker_context_provider_(TestContextProvider::CreateWorker()),
all_tile_tasks_finished_(
- base::ThreadTaskRunnerHandle::Get()
- .get(),
- base::Bind(&TileTaskWorkerPoolTest::AllTileTasksFinished,
+ base::ThreadTaskRunnerHandle::Get().get(),
+ base::Bind(&RasterBufferProviderTest::AllTileTasksFinished,
base::Unretained(this))),
timeout_seconds_(5),
timed_out_(false) {}
// Overridden from testing::Test:
void SetUp() override {
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
switch (GetParam()) {
- case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY:
+ case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
Create3dOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create(
- base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
+ raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
resource_provider_.get(), PlatformColor::BestTextureFormat());
break;
- case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY:
+ case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
Create3dOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
- base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
- context_provider_.get(), resource_provider_.get(),
- kMaxBytesPerCopyOperation, false, kMaxStagingBuffers,
- PlatformColor::BestTextureFormat());
+ raster_buffer_provider = OneCopyRasterBufferProvider::Create(
+ base::ThreadTaskRunnerHandle::Get().get(), context_provider_.get(),
+ resource_provider_.get(), kMaxBytesPerCopyOperation, false,
+ kMaxStagingBuffers, PlatformColor::BestTextureFormat());
break;
- case TILE_TASK_WORKER_POOL_TYPE_GPU:
+ case RASTER_BUFFER_PROVIDER_TYPE_GPU:
Create3dOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
- base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
+ raster_buffer_provider = GpuRasterBufferProvider::Create(
context_provider_.get(), resource_provider_.get(), false, 0);
break;
- case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
+ case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
CreateSoftwareOutputSurfaceAndResourceProvider();
- tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create(
- base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_,
- resource_provider_.get());
+ raster_buffer_provider =
+ BitmapRasterBufferProvider::Create(resource_provider_.get());
break;
}
- DCHECK(tile_task_worker_pool_);
+ DCHECK(raster_buffer_provider);
+
+ tile_task_manager_ = TileTaskManagerImpl::Create(
+ std::move(raster_buffer_provider), &task_graph_runner_);
}
void TearDown() override {
- tile_task_worker_pool_->Shutdown();
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->Shutdown();
+ tile_task_manager_->CheckForCompletedTasks();
}
void AllTileTasksFinished() {
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->CheckForCompletedTasks();
base::MessageLoop::current()->QuitWhenIdle();
}
void RunMessageLoopUntilAllTasksHaveCompleted() {
task_graph_runner_.RunUntilIdle();
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->CheckForCompletedTasks();
}
void ScheduleTasks() {
@@ -199,7 +199,7 @@
0 /* dependencies */);
}
- tile_task_worker_pool_->ScheduleTasks(&graph_);
+ tile_task_manager_->ScheduleTasks(&graph_);
}
void AppendTask(unsigned id, const gfx::Size& size) {
@@ -212,7 +212,7 @@
TileTask::Vector empty;
tasks_.push_back(new TestRasterTaskImpl(
const_resource,
- base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted,
+ base::Bind(&RasterBufferProviderTest::OnTaskCompleted,
base::Unretained(this), base::Passed(&resource), id),
&empty));
}
@@ -231,7 +231,7 @@
TileTask::Vector empty;
tasks_.push_back(new BlockingTestRasterTaskImpl(
const_resource,
- base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted,
+ base::Bind(&RasterBufferProviderTest::OnTaskCompleted,
base::Unretained(this), base::Passed(&resource), id),
lock, &empty));
}
@@ -287,7 +287,7 @@
FakeOutputSurfaceClient output_surface_client_;
std::unique_ptr<FakeOutputSurface> output_surface_;
std::unique_ptr<ResourceProvider> resource_provider_;
- std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
+ std::unique_ptr<TileTaskManager> tile_task_manager_;
TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
TestSharedBitmapManager shared_bitmap_manager_;
SynchronousTaskGraphRunner task_graph_runner_;
@@ -300,7 +300,7 @@
TaskGraph graph_;
};
-TEST_P(TileTaskWorkerPoolTest, Basic) {
+TEST_P(RasterBufferProviderTest, Basic) {
AppendTask(0u);
AppendTask(1u);
ScheduleTasks();
@@ -312,8 +312,8 @@
EXPECT_FALSE(completed_tasks()[1].canceled);
}
-TEST_P(TileTaskWorkerPoolTest, FailedMapResource) {
- if (GetParam() == TILE_TASK_WORKER_POOL_TYPE_BITMAP)
+TEST_P(RasterBufferProviderTest, FailedMapResource) {
+ if (GetParam() == RASTER_BUFFER_PROVIDER_TYPE_BITMAP)
return;
TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
@@ -329,7 +329,7 @@
// This test checks that replacing a pending raster task with another does
// not prevent the DidFinishRunningTileTasks notification from being sent.
-TEST_P(TileTaskWorkerPoolTest, FalseThrottling) {
+TEST_P(RasterBufferProviderTest, FalseThrottling) {
base::Lock lock;
// Schedule a task that is prevented from completing with a lock.
@@ -351,7 +351,7 @@
RunMessageLoopUntilAllTasksHaveCompleted();
}
-TEST_P(TileTaskWorkerPoolTest, LostContext) {
+TEST_P(RasterBufferProviderTest, LostContext) {
LoseContext(output_surface_->context_provider());
LoseContext(output_surface_->worker_context_provider());
@@ -366,12 +366,12 @@
EXPECT_FALSE(completed_tasks()[1].canceled);
}
-INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests,
- TileTaskWorkerPoolTest,
- ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
- TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
- TILE_TASK_WORKER_POOL_TYPE_GPU,
- TILE_TASK_WORKER_POOL_TYPE_BITMAP));
+INSTANTIATE_TEST_CASE_P(RasterBufferProviderTests,
+ RasterBufferProviderTest,
+ ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_GPU,
+ RASTER_BUFFER_PROVIDER_TYPE_BITMAP));
} // namespace
} // namespace cc
diff --git a/cc/raster/tile_task_worker_pool.h b/cc/raster/tile_task_worker_pool.h
deleted file mode 100644
index 9542d02..0000000
--- a/cc/raster/tile_task_worker_pool.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CC_RASTER_TILE_TASK_WORKER_POOL_H_
-#define CC_RASTER_TILE_TASK_WORKER_POOL_H_
-
-#include <stddef.h>
-
-#include "cc/playback/raster_source.h"
-#include "cc/raster/raster_buffer.h"
-#include "cc/raster/task_graph_runner.h"
-#include "cc/raster/tile_task.h"
-#include "cc/resources/resource_format.h"
-#include "ui/gfx/geometry/rect.h"
-#include "ui/gfx/geometry/size.h"
-
-namespace base {
-class SequencedTaskRunner;
-}
-
-namespace cc {
-class RenderingStatsInstrumentation;
-
-// This class provides the wrapper over TaskGraphRunner for scheduling and
-// collecting tasks. The client can call CheckForCompletedTasks() at any time to
-// process all completed tasks at the moment that have finished running or
-// cancelled.
-class CC_EXPORT TileTaskWorkerPool {
- public:
- TileTaskWorkerPool();
- virtual ~TileTaskWorkerPool();
-
- // Utility function that can be used to call ::ScheduleOnOriginThread() for
- // each task in |graph|.
- static void ScheduleTasksOnOriginThread(RasterBufferProvider* provider,
- TaskGraph* graph);
-
- // Utility function that will create a temporary bitmap and copy pixels to
- // |memory| when necessary. The |canvas_bitmap_rect| is the rect of the bitmap
- // being played back in the pixel space of the source, ie a rect in the source
- // that will cover the resulting |memory|. The |canvas_playback_rect| can be a
- // smaller contained rect inside the |canvas_bitmap_rect| if the |memory| is
- // already partially complete, and only the subrect needs to be played back.
- static void PlaybackToMemory(
- void* memory,
- ResourceFormat format,
- const gfx::Size& size,
- size_t stride,
- const RasterSource* raster_source,
- const gfx::Rect& canvas_bitmap_rect,
- const gfx::Rect& canvas_playback_rect,
- float scale,
- const RasterSource::PlaybackSettings& playback_settings);
-
- // Tells the worker pool to shutdown after canceling all previously scheduled
- // tasks. Reply callbacks are still guaranteed to run when
- // CheckForCompletedTasks() is called.
- virtual void Shutdown() = 0;
-
- // Schedule running of tile tasks in |graph| and all dependencies.
- // Previously scheduled tasks that are not in |graph| will be canceled unless
- // already running. Once scheduled, reply callbacks are guaranteed to run for
- // all tasks even if they later get canceled by another call to
- // ScheduleTasks().
- virtual void ScheduleTasks(TaskGraph* graph) = 0;
-
- // Check for completed tasks and dispatch reply callbacks.
- virtual void CheckForCompletedTasks() = 0;
-
- // Returns the format to use for the tiles.
- virtual ResourceFormat GetResourceFormat(bool must_support_alpha) const = 0;
-
- // Determine if the resource requires swizzling.
- virtual bool GetResourceRequiresSwizzle(bool must_support_alpha) const = 0;
-
- // Downcasting routine for RasterBufferProvider interface.
- virtual RasterBufferProvider* AsRasterBufferProvider() = 0;
-
- protected:
- // Check if resource format matches output format.
- static bool ResourceFormatRequiresSwizzle(ResourceFormat format);
-};
-
-} // namespace cc
-
-#endif // CC_RASTER_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/raster/zero_copy_raster_buffer_provider.cc b/cc/raster/zero_copy_raster_buffer_provider.cc
new file mode 100644
index 0000000..93e8d7e
--- /dev/null
+++ b/cc/raster/zero_copy_raster_buffer_provider.cc
@@ -0,0 +1,120 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/raster/zero_copy_raster_buffer_provider.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
+#include "cc/debug/traced_value.h"
+#include "cc/resources/platform_color.h"
+#include "cc/resources/resource.h"
+#include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/gpu_memory_buffer.h"
+
+namespace cc {
+namespace {
+
+class RasterBufferImpl : public RasterBuffer {
+ public:
+ RasterBufferImpl(ResourceProvider* resource_provider,
+ const Resource* resource)
+ : lock_(resource_provider, resource->id()), resource_(resource) {}
+
+ // Overridden from RasterBuffer:
+ void Playback(
+ const RasterSource* raster_source,
+ const gfx::Rect& raster_full_rect,
+ const gfx::Rect& raster_dirty_rect,
+ uint64_t new_content_id,
+ float scale,
+ const RasterSource::PlaybackSettings& playback_settings) override {
+ gfx::GpuMemoryBuffer* buffer = lock_.GetGpuMemoryBuffer();
+ if (!buffer)
+ return;
+
+ DCHECK_EQ(1u, gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
+ bool rv = buffer->Map();
+ DCHECK(rv);
+ DCHECK(buffer->memory(0));
+ // RasterBufferProvider::PlaybackToMemory only supports unsigned strides.
+ DCHECK_GE(buffer->stride(0), 0);
+
+ // TODO(danakj): Implement partial raster with raster_dirty_rect.
+ RasterBufferProvider::PlaybackToMemory(
+ buffer->memory(0), resource_->format(), resource_->size(),
+ buffer->stride(0), raster_source, raster_full_rect, raster_full_rect,
+ scale, playback_settings);
+ buffer->Unmap();
+ }
+
+ private:
+ ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock_;
+ const Resource* resource_;
+
+ DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
+};
+
+} // namespace
+
+// static
+std::unique_ptr<RasterBufferProvider> ZeroCopyRasterBufferProvider::Create(
+ ResourceProvider* resource_provider,
+ ResourceFormat preferred_tile_format) {
+ return base::WrapUnique<RasterBufferProvider>(
+ new ZeroCopyRasterBufferProvider(resource_provider,
+ preferred_tile_format));
+}
+
+ZeroCopyRasterBufferProvider::ZeroCopyRasterBufferProvider(
+ ResourceProvider* resource_provider,
+ ResourceFormat preferred_tile_format)
+ : resource_provider_(resource_provider),
+ preferred_tile_format_(preferred_tile_format) {}
+
+ZeroCopyRasterBufferProvider::~ZeroCopyRasterBufferProvider() {}
+
+std::unique_ptr<RasterBuffer>
+ZeroCopyRasterBufferProvider::AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) {
+ return base::WrapUnique<RasterBuffer>(
+ new RasterBufferImpl(resource_provider_, resource));
+}
+
+void ZeroCopyRasterBufferProvider::ReleaseBufferForRaster(
+ std::unique_ptr<RasterBuffer> buffer) {
+ // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
+}
+
+void ZeroCopyRasterBufferProvider::OrderingBarrier() {
+ // No need to sync resources as this provider does not use GL context.
+}
+
+ResourceFormat ZeroCopyRasterBufferProvider::GetResourceFormat(
+ bool must_support_alpha) const {
+ if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) &&
+ (DoesResourceFormatSupportAlpha(preferred_tile_format_) ||
+ !must_support_alpha)) {
+ return preferred_tile_format_;
+ }
+
+ return resource_provider_->best_texture_format();
+}
+
+bool ZeroCopyRasterBufferProvider::GetResourceRequiresSwizzle(
+ bool must_support_alpha) const {
+ return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
+}
+
+void ZeroCopyRasterBufferProvider::Shutdown() {}
+
+} // namespace cc
diff --git a/cc/raster/zero_copy_raster_buffer_provider.h b/cc/raster/zero_copy_raster_buffer_provider.h
new file mode 100644
index 0000000..f813a59b
--- /dev/null
+++ b/cc/raster/zero_copy_raster_buffer_provider.h
@@ -0,0 +1,59 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_RASTER_ZERO_COPY_RASTER_BUFFER_PROVIDER_H_
+#define CC_RASTER_ZERO_COPY_RASTER_BUFFER_PROVIDER_H_
+
+#include <stdint.h>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/values.h"
+#include "cc/raster/raster_buffer_provider.h"
+
+namespace base {
+namespace trace_event {
+class ConvertableToTraceFormat;
+}
+}
+
+namespace cc {
+class ResourceProvider;
+
+class CC_EXPORT ZeroCopyRasterBufferProvider : public RasterBufferProvider {
+ public:
+ ~ZeroCopyRasterBufferProvider() override;
+
+ static std::unique_ptr<RasterBufferProvider> Create(
+ ResourceProvider* resource_provider,
+ ResourceFormat preferred_tile_format);
+
+ // Overridden from RasterBufferProvider:
+ std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) override;
+ void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
+ void OrderingBarrier() override;
+ ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+ bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
+ void Shutdown() override;
+
+ protected:
+ ZeroCopyRasterBufferProvider(ResourceProvider* resource_provider,
+ ResourceFormat preferred_tile_format);
+
+ private:
+ std::unique_ptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
+ const;
+
+ ResourceProvider* resource_provider_;
+ ResourceFormat preferred_tile_format_;
+
+ DISALLOW_COPY_AND_ASSIGN(ZeroCopyRasterBufferProvider);
+};
+
+} // namespace cc
+
+#endif // CC_RASTER_ZERO_COPY_RASTER_BUFFER_PROVIDER_H_
diff --git a/cc/raster/zero_copy_tile_task_worker_pool.cc b/cc/raster/zero_copy_tile_task_worker_pool.cc
deleted file mode 100644
index e423450b..0000000
--- a/cc/raster/zero_copy_tile_task_worker_pool.cc
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "cc/raster/zero_copy_tile_task_worker_pool.h"
-
-#include <stdint.h>
-
-#include <algorithm>
-
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event.h"
-#include "base/trace_event/trace_event_argument.h"
-#include "cc/debug/traced_value.h"
-#include "cc/resources/platform_color.h"
-#include "cc/resources/resource.h"
-#include "ui/gfx/buffer_format_util.h"
-#include "ui/gfx/gpu_memory_buffer.h"
-
-namespace cc {
-namespace {
-
-class RasterBufferImpl : public RasterBuffer {
- public:
- RasterBufferImpl(ResourceProvider* resource_provider,
- const Resource* resource)
- : lock_(resource_provider, resource->id()), resource_(resource) {}
-
- // Overridden from RasterBuffer:
- void Playback(
- const RasterSource* raster_source,
- const gfx::Rect& raster_full_rect,
- const gfx::Rect& raster_dirty_rect,
- uint64_t new_content_id,
- float scale,
- const RasterSource::PlaybackSettings& playback_settings) override {
- gfx::GpuMemoryBuffer* buffer = lock_.GetGpuMemoryBuffer();
- if (!buffer)
- return;
-
- DCHECK_EQ(1u, gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
- bool rv = buffer->Map();
- DCHECK(rv);
- DCHECK(buffer->memory(0));
- // TileTaskWorkerPool::PlaybackToMemory only supports unsigned strides.
- DCHECK_GE(buffer->stride(0), 0);
-
- // TODO(danakj): Implement partial raster with raster_dirty_rect.
- TileTaskWorkerPool::PlaybackToMemory(
- buffer->memory(0), resource_->format(), resource_->size(),
- buffer->stride(0), raster_source, raster_full_rect, raster_full_rect,
- scale, playback_settings);
- buffer->Unmap();
- }
-
- private:
- ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock_;
- const Resource* resource_;
-
- DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
-};
-
-} // namespace
-
-// static
-std::unique_ptr<TileTaskWorkerPool> ZeroCopyTileTaskWorkerPool::Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider,
- ResourceFormat preferred_tile_format) {
- return base::WrapUnique<TileTaskWorkerPool>(
- new ZeroCopyTileTaskWorkerPool(task_runner, task_graph_runner,
- resource_provider, preferred_tile_format));
-}
-
-ZeroCopyTileTaskWorkerPool::ZeroCopyTileTaskWorkerPool(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider,
- ResourceFormat preferred_tile_format)
- : task_runner_(task_runner),
- task_graph_runner_(task_graph_runner),
- namespace_token_(task_graph_runner->GetNamespaceToken()),
- resource_provider_(resource_provider),
- preferred_tile_format_(preferred_tile_format) {}
-
-ZeroCopyTileTaskWorkerPool::~ZeroCopyTileTaskWorkerPool() {
-}
-
-void ZeroCopyTileTaskWorkerPool::Shutdown() {
- TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::Shutdown");
-
- TaskGraph empty;
- task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
- task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-}
-
-void ZeroCopyTileTaskWorkerPool::ScheduleTasks(TaskGraph* graph) {
- TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::ScheduleTasks");
-
- ScheduleTasksOnOriginThread(this, graph);
- task_graph_runner_->ScheduleTasks(namespace_token_, graph);
-}
-
-void ZeroCopyTileTaskWorkerPool::CheckForCompletedTasks() {
- TRACE_EVENT0("cc", "ZeroCopyTileTaskWorkerPool::CheckForCompletedTasks");
-
- task_graph_runner_->CollectCompletedTasks(namespace_token_,
- &completed_tasks_);
- for (Task::Vector::const_iterator it = completed_tasks_.begin();
- it != completed_tasks_.end(); ++it) {
- TileTask* task = static_cast<TileTask*>(it->get());
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
- }
- completed_tasks_.clear();
-}
-
-ResourceFormat ZeroCopyTileTaskWorkerPool::GetResourceFormat(
- bool must_support_alpha) const {
- if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) &&
- (DoesResourceFormatSupportAlpha(preferred_tile_format_) ||
- !must_support_alpha)) {
- return preferred_tile_format_;
- }
-
- return resource_provider_->best_texture_format();
-}
-
-bool ZeroCopyTileTaskWorkerPool::GetResourceRequiresSwizzle(
- bool must_support_alpha) const {
- return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
-}
-
-RasterBufferProvider* ZeroCopyTileTaskWorkerPool::AsRasterBufferProvider() {
- return this;
-}
-
-std::unique_ptr<RasterBuffer>
-ZeroCopyTileTaskWorkerPool::AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) {
- return base::WrapUnique<RasterBuffer>(
- new RasterBufferImpl(resource_provider_, resource));
-}
-
-void ZeroCopyTileTaskWorkerPool::ReleaseBufferForRaster(
- std::unique_ptr<RasterBuffer> buffer) {
- // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
-}
-
-} // namespace cc
diff --git a/cc/raster/zero_copy_tile_task_worker_pool.h b/cc/raster/zero_copy_tile_task_worker_pool.h
deleted file mode 100644
index 7a78233..0000000
--- a/cc/raster/zero_copy_tile_task_worker_pool.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CC_RASTER_ZERO_COPY_TILE_TASK_WORKER_POOL_H_
-#define CC_RASTER_ZERO_COPY_TILE_TASK_WORKER_POOL_H_
-
-#include <stdint.h>
-
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/values.h"
-#include "cc/raster/tile_task_worker_pool.h"
-
-namespace base {
-namespace trace_event {
-class ConvertableToTraceFormat;
-}
-}
-
-namespace cc {
-class ResourceProvider;
-
-class CC_EXPORT ZeroCopyTileTaskWorkerPool : public TileTaskWorkerPool,
- public RasterBufferProvider {
- public:
- ~ZeroCopyTileTaskWorkerPool() override;
-
- static std::unique_ptr<TileTaskWorkerPool> Create(
- base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider,
- ResourceFormat preferred_tile_format);
-
- // Overridden from TileTaskWorkerPool:
- void Shutdown() override;
- void ScheduleTasks(TaskGraph* graph) override;
- void CheckForCompletedTasks() override;
- ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
- bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
- RasterBufferProvider* AsRasterBufferProvider() override;
-
- // Overridden from RasterBufferProvider:
- std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) override;
- void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
-
- protected:
- ZeroCopyTileTaskWorkerPool(base::SequencedTaskRunner* task_runner,
- TaskGraphRunner* task_graph_runner,
- ResourceProvider* resource_provider,
- ResourceFormat preferred_tile_format);
-
- private:
- std::unique_ptr<base::trace_event::ConvertableToTraceFormat> StateAsValue()
- const;
-
- scoped_refptr<base::SequencedTaskRunner> task_runner_;
- TaskGraphRunner* task_graph_runner_;
- const NamespaceToken namespace_token_;
- ResourceProvider* resource_provider_;
-
- ResourceFormat preferred_tile_format_;
-
- Task::Vector completed_tasks_;
-
- DISALLOW_COPY_AND_ASSIGN(ZeroCopyTileTaskWorkerPool);
-};
-
-} // namespace cc
-
-#endif // CC_RASTER_ZERO_COPY_TILE_TASK_WORKER_POOL_H_
diff --git a/cc/test/fake_raster_buffer_provider.cc b/cc/test/fake_raster_buffer_provider.cc
new file mode 100644
index 0000000..9657b6be
--- /dev/null
+++ b/cc/test/fake_raster_buffer_provider.cc
@@ -0,0 +1,38 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/test/fake_raster_buffer_provider.h"
+
+namespace cc {
+
+FakeRasterBufferProviderImpl::FakeRasterBufferProviderImpl() {}
+
+FakeRasterBufferProviderImpl::~FakeRasterBufferProviderImpl() {}
+
+std::unique_ptr<RasterBuffer>
+FakeRasterBufferProviderImpl::AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) {
+ return nullptr;
+}
+
+void FakeRasterBufferProviderImpl::ReleaseBufferForRaster(
+ std::unique_ptr<RasterBuffer> buffer) {}
+
+void FakeRasterBufferProviderImpl::OrderingBarrier() {}
+
+ResourceFormat FakeRasterBufferProviderImpl::GetResourceFormat(
+ bool must_support_alpha) const {
+ return ResourceFormat::RGBA_8888;
+}
+
+bool FakeRasterBufferProviderImpl::GetResourceRequiresSwizzle(
+ bool must_support_alpha) const {
+ return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
+}
+
+void FakeRasterBufferProviderImpl::Shutdown() {}
+
+} // namespace cc
diff --git a/cc/test/fake_raster_buffer_provider.h b/cc/test/fake_raster_buffer_provider.h
new file mode 100644
index 0000000..00ab04a
--- /dev/null
+++ b/cc/test/fake_raster_buffer_provider.h
@@ -0,0 +1,32 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_TEST_FAKE_RASTER_BUFFER_PROVIDER_H_
+#define CC_TEST_FAKE_RASTER_BUFFER_PROVIDER_H_
+
+#include "cc/raster/raster_buffer_provider.h"
+
+namespace cc {
+
+// Fake RasterBufferProvider that just no-ops all calls.
+class FakeRasterBufferProviderImpl : public RasterBufferProvider {
+ public:
+ FakeRasterBufferProviderImpl();
+ ~FakeRasterBufferProviderImpl() override;
+
+ // RasterBufferProvider methods.
+ std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
+ const Resource* resource,
+ uint64_t resource_content_id,
+ uint64_t previous_content_id) override;
+ void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override;
+ void OrderingBarrier() override;
+ ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
+ bool GetResourceRequiresSwizzle(bool must_support_alpha) const override;
+ void Shutdown() override;
+};
+
+} // namespace cc
+
+#endif // CC_TEST_FAKE_RASTER_BUFFER_PROVIDER_H_
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index 94ca37b..768e518 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -13,60 +13,13 @@
#include "base/lazy_instance.h"
#include "base/thread_task_runner_handle.h"
#include "cc/raster/raster_buffer.h"
-#include "cc/raster/tile_task_worker_pool.h"
+#include "cc/test/fake_tile_task_manager.h"
namespace cc {
namespace {
-class FakeTileTaskWorkerPoolImpl : public TileTaskWorkerPool,
- public RasterBufferProvider {
- public:
- // Overridden from TileTaskWorkerPool:
- void Shutdown() override {}
- void ScheduleTasks(TaskGraph* graph) override {
- for (const auto& node : graph->nodes) {
- TileTask* task = static_cast<TileTask*>(node.task);
-
- task->WillSchedule();
- task->ScheduleOnOriginThread(this);
- task->DidSchedule();
-
- completed_tasks_.push_back(task);
- }
- }
- void CheckForCompletedTasks() override {
- for (TileTask::Vector::iterator it = completed_tasks_.begin();
- it != completed_tasks_.end(); ++it) {
- TileTask* task = it->get();
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
- }
- completed_tasks_.clear();
- }
- ResourceFormat GetResourceFormat(bool must_support_alpha) const override {
- return RGBA_8888;
- }
- bool GetResourceRequiresSwizzle(bool must_support_alpha) const override {
- return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
- }
- RasterBufferProvider* AsRasterBufferProvider() override { return this; }
-
- // Overridden from RasterBufferProvider:
- std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) override {
- return nullptr;
- }
- void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {}
-
- private:
- TileTask::Vector completed_tasks_;
-};
-base::LazyInstance<FakeTileTaskWorkerPoolImpl> g_fake_tile_task_worker_pool =
+base::LazyInstance<FakeTileTaskManagerImpl> g_fake_tile_task_manager =
LAZY_INSTANCE_INITIALIZER;
} // namespace
@@ -76,9 +29,9 @@
base::ThreadTaskRunnerHandle::Get(),
std::numeric_limits<size_t>::max(),
false /* use_partial_raster */) {
- SetResources(nullptr, g_fake_tile_task_worker_pool.Pointer(),
- &image_decode_controller_, std::numeric_limits<size_t>::max(),
- false /* use_gpu_rasterization */);
+ SetResources(
+ nullptr, &image_decode_controller_, g_fake_tile_task_manager.Pointer(),
+ std::numeric_limits<size_t>::max(), false /* use_gpu_rasterization */);
}
FakeTileManager::FakeTileManager(TileManagerClient* client,
@@ -87,8 +40,9 @@
base::ThreadTaskRunnerHandle::Get(),
std::numeric_limits<size_t>::max(),
false /* use_partial_raster */) {
- SetResources(resource_pool, g_fake_tile_task_worker_pool.Pointer(),
- &image_decode_controller_, std::numeric_limits<size_t>::max(),
+ SetResources(resource_pool, &image_decode_controller_,
+ g_fake_tile_task_manager.Pointer(),
+ std::numeric_limits<size_t>::max(),
false /* use_gpu_rasterization */);
}
diff --git a/cc/test/fake_tile_task_manager.cc b/cc/test/fake_tile_task_manager.cc
new file mode 100644
index 0000000..9b28d55
--- /dev/null
+++ b/cc/test/fake_tile_task_manager.cc
@@ -0,0 +1,51 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/test/fake_tile_task_manager.h"
+
+#include "base/memory/ptr_util.h"
+
+namespace cc {
+
+FakeTileTaskManagerImpl::FakeTileTaskManagerImpl()
+ : raster_buffer_provider_(base::WrapUnique<RasterBufferProvider>(
+ new FakeRasterBufferProviderImpl)) {}
+
+FakeTileTaskManagerImpl::FakeTileTaskManagerImpl(
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider)
+ : raster_buffer_provider_(std::move(raster_buffer_provider)) {}
+
+FakeTileTaskManagerImpl::~FakeTileTaskManagerImpl() {}
+
+void FakeTileTaskManagerImpl::ScheduleTasks(TaskGraph* graph) {
+ for (const auto& node : graph->nodes) {
+ TileTask* task = static_cast<TileTask*>(node.task);
+
+ task->WillSchedule();
+ task->ScheduleOnOriginThread(raster_buffer_provider_.get());
+ task->DidSchedule();
+
+ completed_tasks_.push_back(task);
+ }
+}
+
+void FakeTileTaskManagerImpl::CheckForCompletedTasks() {
+ for (Task::Vector::iterator it = completed_tasks_.begin();
+ it != completed_tasks_.end(); ++it) {
+ TileTask* task = static_cast<TileTask*>(it->get());
+
+ task->WillComplete();
+ task->CompleteOnOriginThread(raster_buffer_provider_.get());
+ task->DidComplete();
+ }
+ completed_tasks_.clear();
+}
+
+void FakeTileTaskManagerImpl::Shutdown() {}
+
+RasterBufferProvider* FakeTileTaskManagerImpl::GetRasterBufferProvider() const {
+ return raster_buffer_provider_.get();
+}
+
+} // namespace cc
diff --git a/cc/test/fake_tile_task_manager.h b/cc/test/fake_tile_task_manager.h
new file mode 100644
index 0000000..7fb6af6
--- /dev/null
+++ b/cc/test/fake_tile_task_manager.h
@@ -0,0 +1,35 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_TEST_FAKE_TILE_TASK_MANAGER_H_
+#define CC_TEST_FAKE_TILE_TASK_MANAGER_H_
+
+#include "cc/test/fake_raster_buffer_provider.h"
+#include "cc/tiles/tile_task_manager.h"
+
+namespace cc {
+
+// Fake TileTaskManager.
+class FakeTileTaskManagerImpl : public TileTaskManager {
+ public:
+ FakeTileTaskManagerImpl();
+ // Ctor for custom raster buffer provider.
+ FakeTileTaskManagerImpl(
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider);
+ ~FakeTileTaskManagerImpl() override;
+
+ // Overridden from TileTaskManager:
+ void ScheduleTasks(TaskGraph* graph) override;
+ void CheckForCompletedTasks() override;
+ void Shutdown() override;
+ RasterBufferProvider* GetRasterBufferProvider() const override;
+
+ protected:
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
+ Task::Vector completed_tasks_;
+};
+
+} // namespace cc
+
+#endif // CC_TEST_FAKE_TILE_TASK_MANAGER_H_
diff --git a/cc/test/layer_tree_pixel_resource_test.cc b/cc/test/layer_tree_pixel_resource_test.cc
index 7da328f..b4f48e4d 100644
--- a/cc/test/layer_tree_pixel_resource_test.cc
+++ b/cc/test/layer_tree_pixel_resource_test.cc
@@ -5,12 +5,12 @@
#include "cc/test/layer_tree_pixel_resource_test.h"
#include "cc/layers/layer.h"
-#include "cc/raster/bitmap_tile_task_worker_pool.h"
+#include "cc/raster/bitmap_raster_buffer_provider.h"
+#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/gpu_rasterizer.h"
-#include "cc/raster/gpu_tile_task_worker_pool.h"
-#include "cc/raster/one_copy_tile_task_worker_pool.h"
-#include "cc/raster/tile_task_worker_pool.h"
-#include "cc/raster/zero_copy_tile_task_worker_pool.h"
+#include "cc/raster/one_copy_raster_buffer_provider.h"
+#include "cc/raster/raster_buffer_provider.h"
+#include "cc/raster/zero_copy_raster_buffer_provider.h"
#include "cc/resources/resource_pool.h"
#include "cc/test/fake_output_surface.h"
#include "gpu/GLES2/gl2extchromium.h"
@@ -44,7 +44,7 @@
LayerTreeHostPixelResourceTest::LayerTreeHostPixelResourceTest(
PixelResourceTestCase test_case)
: draw_texture_target_(GL_INVALID_VALUE),
- resource_pool_option_(BITMAP_TILE_TASK_WORKER_POOL),
+ raster_buffer_provider_type_(RASTER_BUFFER_PROVIDER_TYPE_BITMAP),
initialized_(false),
test_case_(test_case) {
InitializeFromTestCase(test_case);
@@ -52,7 +52,7 @@
LayerTreeHostPixelResourceTest::LayerTreeHostPixelResourceTest()
: draw_texture_target_(GL_INVALID_VALUE),
- resource_pool_option_(BITMAP_TILE_TASK_WORKER_POOL),
+ raster_buffer_provider_type_(RASTER_BUFFER_PROVIDER_TYPE_BITMAP),
initialized_(false),
test_case_(SOFTWARE) {}
@@ -64,50 +64,50 @@
case SOFTWARE:
test_type_ = PIXEL_TEST_SOFTWARE;
draw_texture_target_ = GL_INVALID_VALUE;
- resource_pool_option_ = BITMAP_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_BITMAP;
return;
case GL_GPU_RASTER_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = GPU_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_GPU;
return;
case GL_ONE_COPY_2D_STAGING_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ONE_COPY_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY;
return;
case GL_ONE_COPY_RECT_STAGING_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ONE_COPY_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY;
return;
case GL_ONE_COPY_EXTERNAL_STAGING_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ONE_COPY_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY;
return;
case GL_ZERO_COPY_2D_DRAW:
test_type_ = PIXEL_TEST_GL;
draw_texture_target_ = GL_TEXTURE_2D;
- resource_pool_option_ = ZERO_COPY_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY;
return;
case GL_ZERO_COPY_RECT_DRAW:
test_type_ = PIXEL_TEST_GL;
draw_texture_target_ = GL_TEXTURE_RECTANGLE_ARB;
- resource_pool_option_ = ZERO_COPY_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY;
return;
case GL_ZERO_COPY_EXTERNAL_DRAW:
test_type_ = PIXEL_TEST_GL;
draw_texture_target_ = GL_TEXTURE_EXTERNAL_OES;
- resource_pool_option_ = ZERO_COPY_TILE_TASK_WORKER_POOL;
+ raster_buffer_provider_type_ = RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY;
return;
}
NOTREACHED();
}
-void LayerTreeHostPixelResourceTest::CreateResourceAndTileTaskWorkerPool(
+void LayerTreeHostPixelResourceTest::CreateResourceAndRasterBufferProvider(
LayerTreeHostImpl* host_impl,
- std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+ std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
std::unique_ptr<ResourcePool>* resource_pool) {
base::SingleThreadTaskRunner* task_runner =
task_runner_provider()->HasImplThread()
@@ -122,42 +122,39 @@
int max_bytes_per_copy_operation = 1024 * 1024;
int max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024;
- switch (resource_pool_option_) {
- case BITMAP_TILE_TASK_WORKER_POOL:
+ // Create resource pool.
+ *resource_pool = ResourcePool::Create(resource_provider, task_runner);
+
+ switch (raster_buffer_provider_type_) {
+ case RASTER_BUFFER_PROVIDER_TYPE_BITMAP:
EXPECT_FALSE(context_provider);
EXPECT_EQ(PIXEL_TEST_SOFTWARE, test_type_);
- *resource_pool = ResourcePool::Create(resource_provider, task_runner);
- *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
- task_runner, task_graph_runner(), resource_provider);
+ *raster_buffer_provider =
+ BitmapRasterBufferProvider::Create(resource_provider);
break;
- case GPU_TILE_TASK_WORKER_POOL:
+ case RASTER_BUFFER_PROVIDER_TYPE_GPU:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
- *resource_pool = ResourcePool::Create(resource_provider, task_runner);
- *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
- task_runner, task_graph_runner(), context_provider, resource_provider,
- false, 0);
+ *raster_buffer_provider = GpuRasterBufferProvider::Create(
+ context_provider, resource_provider, false, 0);
break;
- case ZERO_COPY_TILE_TASK_WORKER_POOL:
+ case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
EXPECT_TRUE(host_impl->GetRendererCapabilities().using_image);
- *resource_pool = ResourcePool::Create(resource_provider, task_runner);
- *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
- task_runner, task_graph_runner(), resource_provider,
- PlatformColor::BestTextureFormat());
+ *raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
+ resource_provider, PlatformColor::BestTextureFormat());
break;
- case ONE_COPY_TILE_TASK_WORKER_POOL:
+ case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY:
EXPECT_TRUE(context_provider);
EXPECT_EQ(PIXEL_TEST_GL, test_type_);
EXPECT_TRUE(host_impl->GetRendererCapabilities().using_image);
- *resource_pool = ResourcePool::Create(resource_provider, task_runner);
- *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
- task_runner, task_graph_runner(), context_provider, resource_provider,
+ *raster_buffer_provider = OneCopyRasterBufferProvider::Create(
+ task_runner, context_provider, resource_provider,
max_bytes_per_copy_operation, false,
max_staging_buffer_usage_in_bytes,
PlatformColor::BestTextureFormat());
diff --git a/cc/test/layer_tree_pixel_resource_test.h b/cc/test/layer_tree_pixel_resource_test.h
index effa9e0d..54339a2 100644
--- a/cc/test/layer_tree_pixel_resource_test.h
+++ b/cc/test/layer_tree_pixel_resource_test.h
@@ -11,7 +11,7 @@
namespace cc {
class LayerTreeHostImpl;
-class TileTaskWorkerPool;
+class RasterBufferProvider;
class ResourcePool;
// Enumerate the various combinations of renderer, resource pool, staging
@@ -34,24 +34,24 @@
explicit LayerTreeHostPixelResourceTest(PixelResourceTestCase test_case);
LayerTreeHostPixelResourceTest();
- void CreateResourceAndTileTaskWorkerPool(
+ void CreateResourceAndRasterBufferProvider(
LayerTreeHostImpl* host_impl,
- std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+ std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
std::unique_ptr<ResourcePool>* resource_pool) override;
void RunPixelResourceTest(scoped_refptr<Layer> content_root,
base::FilePath file_name);
- enum TileTaskWorkerPoolOption {
- BITMAP_TILE_TASK_WORKER_POOL,
- GPU_TILE_TASK_WORKER_POOL,
- ZERO_COPY_TILE_TASK_WORKER_POOL,
- ONE_COPY_TILE_TASK_WORKER_POOL
+ enum RasterBufferProviderType {
+ RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY,
+ RASTER_BUFFER_PROVIDER_TYPE_GPU,
+ RASTER_BUFFER_PROVIDER_TYPE_BITMAP
};
protected:
unsigned draw_texture_target_;
- TileTaskWorkerPoolOption resource_pool_option_;
+ RasterBufferProviderType raster_buffer_provider_type_;
bool initialized_;
void InitializeFromTestCase(PixelResourceTestCase test_case);
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 19762ae..7275ec3a 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -190,11 +190,11 @@
block_notify_ready_to_activate_for_testing_(false),
notify_ready_to_activate_was_blocked_(false) {}
- void CreateResourceAndTileTaskWorkerPool(
- std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+ void CreateResourceAndRasterBufferProvider(
+ std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
std::unique_ptr<ResourcePool>* resource_pool) override {
- test_hooks_->CreateResourceAndTileTaskWorkerPool(
- this, tile_task_worker_pool, resource_pool);
+ test_hooks_->CreateResourceAndRasterBufferProvider(
+ this, raster_buffer_provider, resource_pool);
}
void WillBeginImplFrame(const BeginFrameArgs& args) override {
diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc
index 515faf6..8c56f88f 100644
--- a/cc/test/pixel_test.cc
+++ b/cc/test/pixel_test.cc
@@ -16,7 +16,7 @@
#include "cc/output/output_surface_client.h"
#include "cc/output/software_renderer.h"
#include "cc/output/texture_mailbox_deleter.h"
-#include "cc/raster/tile_task_worker_pool.h"
+#include "cc/raster/raster_buffer_provider.h"
#include "cc/resources/resource_provider.h"
#include "cc/scheduler/begin_frame_source.h"
#include "cc/test/fake_output_surface_client.h"
diff --git a/cc/test/test_hooks.cc b/cc/test/test_hooks.cc
index a6b83002..5850154 100644
--- a/cc/test/test_hooks.cc
+++ b/cc/test/test_hooks.cc
@@ -17,12 +17,12 @@
return draw_result;
}
-void TestHooks::CreateResourceAndTileTaskWorkerPool(
+void TestHooks::CreateResourceAndRasterBufferProvider(
LayerTreeHostImpl* host_impl,
- std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+ std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
std::unique_ptr<ResourcePool>* resource_pool) {
- host_impl->LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
- tile_task_worker_pool, resource_pool);
+ host_impl->LayerTreeHostImpl::CreateResourceAndRasterBufferProvider(
+ raster_buffer_provider, resource_pool);
}
} // namespace cc
diff --git a/cc/test/test_hooks.h b/cc/test/test_hooks.h
index 075bdd1..299729a 100644
--- a/cc/test/test_hooks.h
+++ b/cc/test/test_hooks.h
@@ -24,9 +24,9 @@
void ReadSettings(const LayerTreeSettings& settings);
- virtual void CreateResourceAndTileTaskWorkerPool(
+ virtual void CreateResourceAndRasterBufferProvider(
LayerTreeHostImpl* host_impl,
- std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+ std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
std::unique_ptr<ResourcePool>* resource_pool);
virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
const BeginFrameArgs& args) {}
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index c30f3a3c..3ce24d9 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -210,7 +210,7 @@
dependencies++;
- // Add decode task if it doesn't already exists in graph.
+ // Add decode task if it doesn't already exist in graph.
TaskGraph::Node::Vector::iterator decode_it =
std::find_if(graph->nodes.begin(), graph->nodes.end(),
[decode_task](const TaskGraph::Node& node) {
@@ -308,7 +308,7 @@
: client_(client),
task_runner_(std::move(task_runner)),
resource_pool_(nullptr),
- tile_task_worker_pool_(nullptr),
+ tile_task_manager_(nullptr),
scheduled_raster_task_limit_(scheduled_raster_task_limit),
use_partial_raster_(use_partial_raster),
use_gpu_rasterization_(false),
@@ -332,25 +332,25 @@
}
void TileManager::FinishTasksAndCleanUp() {
- if (!tile_task_worker_pool_)
+ if (!tile_task_manager_)
return;
global_state_ = GlobalStateThatImpactsTilePriority();
// This cancels tasks if possible, finishes pending tasks, and release any
// uninitialized resources.
- tile_task_worker_pool_->Shutdown();
+ tile_task_manager_->Shutdown();
// Now that all tasks have been finished, we can clear any
// |orphan_tasks_|.
orphan_tasks_.clear();
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->CheckForCompletedTasks();
FreeResourcesForReleasedTiles();
CleanUpReleasedTiles();
- tile_task_worker_pool_ = nullptr;
+ tile_task_manager_ = nullptr;
resource_pool_ = nullptr;
more_tiles_need_prepare_check_notifier_.Cancel();
signals_check_notifier_.Cancel();
@@ -358,18 +358,18 @@
}
void TileManager::SetResources(ResourcePool* resource_pool,
- TileTaskWorkerPool* tile_task_worker_pool,
ImageDecodeController* image_decode_controller,
+ TileTaskManager* tile_task_manager,
size_t scheduled_raster_task_limit,
bool use_gpu_rasterization) {
- DCHECK(!tile_task_worker_pool_);
- DCHECK(tile_task_worker_pool);
+ DCHECK(!tile_task_manager_);
+ DCHECK(tile_task_manager);
use_gpu_rasterization_ = use_gpu_rasterization;
scheduled_raster_task_limit_ = scheduled_raster_task_limit;
resource_pool_ = resource_pool;
- tile_task_worker_pool_ = tile_task_worker_pool;
image_decode_controller_ = image_decode_controller;
+ tile_task_manager_ = tile_task_manager;
}
void TileManager::Release(Tile* tile) {
@@ -419,7 +419,7 @@
TRACE_EVENT0("cc", "TileManager::DidFinishRunningAllTileTasks");
TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
DCHECK(resource_pool_);
- DCHECK(tile_task_worker_pool_);
+ DCHECK(tile_task_manager_);
has_scheduled_tile_tasks_ = false;
@@ -446,7 +446,7 @@
TRACE_EVENT1("cc", "TileManager::PrepareTiles", "prepare_tiles_id",
prepare_tiles_count_);
- if (!tile_task_worker_pool_) {
+ if (!tile_task_manager_) {
TRACE_EVENT_INSTANT0("cc", "PrepareTiles aborted",
TRACE_EVENT_SCOPE_THREAD);
return false;
@@ -458,7 +458,7 @@
// We need to call CheckForCompletedTasks() 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_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
}
@@ -490,12 +490,12 @@
void TileManager::Flush() {
TRACE_EVENT0("cc", "TileManager::Flush");
- if (!tile_task_worker_pool_) {
+ if (!tile_task_manager_) {
TRACE_EVENT_INSTANT0("cc", "Flush aborted", TRACE_EVENT_SCOPE_THREAD);
return;
}
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
@@ -592,7 +592,7 @@
TRACE_EVENT_BEGIN0("cc", "TileManager::AssignGpuMemoryToTiles");
DCHECK(resource_pool_);
- DCHECK(tile_task_worker_pool_);
+ DCHECK(tile_task_manager_);
// Maintain the list of released resources that can potentially be re-used
// or deleted. If this operation becomes expensive too, only do this after
@@ -830,7 +830,7 @@
// Schedule running of |raster_queue_|. This replaces any previously
// scheduled tasks and effectively cancels all tasks not present
// in |raster_queue_|.
- tile_task_worker_pool_->ScheduleTasks(&graph_);
+ tile_task_manager_->ScheduleTasks(&graph_);
// It's now safe to clean up orphan tasks as raster worker pool is not
// allowed to keep around unreferenced raster tasks after ScheduleTasks() has
@@ -961,7 +961,7 @@
int flags) {
// We need to have a tile task worker pool to do anything meaningful with
// tiles.
- DCHECK(tile_task_worker_pool_);
+ DCHECK(tile_task_manager_);
ScopedTilePtr tile(
new Tile(this, info, layer_id, source_frame_number, flags));
DCHECK(tiles_.find(tile->id()) == tiles_.end());
@@ -970,9 +970,9 @@
return tile;
}
-void TileManager::SetTileTaskWorkerPoolForTesting(
- TileTaskWorkerPool* tile_task_worker_pool) {
- tile_task_worker_pool_ = tile_task_worker_pool;
+void TileManager::SetTileTaskManagerForTesting(
+ TileTaskManager* tile_task_manager) {
+ tile_task_manager_ = tile_task_manager;
}
bool TileManager::AreRequiredTilesReadyToDraw(
@@ -1015,7 +1015,7 @@
void TileManager::CheckAndIssueSignals() {
TRACE_EVENT0("cc", "TileManager::CheckAndIssueSignals");
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
// Ready to activate.
@@ -1055,7 +1055,7 @@
}
void TileManager::CheckIfMoreTilesNeedToBePrepared() {
- tile_task_worker_pool_->CheckForCompletedTasks();
+ tile_task_manager_->CheckForCompletedTasks();
did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
// When OOM, keep re-assigning memory until we reach a steady state
@@ -1142,11 +1142,13 @@
}
ResourceFormat TileManager::DetermineResourceFormat(const Tile* tile) const {
- return tile_task_worker_pool_->GetResourceFormat(!tile->is_opaque());
+ return tile_task_manager_->GetRasterBufferProvider()->GetResourceFormat(
+ !tile->is_opaque());
}
bool TileManager::DetermineResourceRequiresSwizzle(const Tile* tile) const {
- return tile_task_worker_pool_->GetResourceRequiresSwizzle(!tile->is_opaque());
+ return tile_task_manager_->GetRasterBufferProvider()
+ ->GetResourceRequiresSwizzle(!tile->is_opaque());
}
std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
diff --git a/cc/tiles/tile_manager.h b/cc/tiles/tile_manager.h
index dfcf478..b98c4ec 100644
--- a/cc/tiles/tile_manager.h
+++ b/cc/tiles/tile_manager.h
@@ -18,7 +18,7 @@
#include "base/values.h"
#include "cc/base/unique_notifier.h"
#include "cc/playback/raster_source.h"
-#include "cc/raster/tile_task_worker_pool.h"
+#include "cc/raster/raster_buffer_provider.h"
#include "cc/resources/memory_history.h"
#include "cc/resources/resource_pool.h"
#include "cc/tiles/eviction_tile_priority_queue.h"
@@ -26,6 +26,7 @@
#include "cc/tiles/raster_tile_priority_queue.h"
#include "cc/tiles/tile.h"
#include "cc/tiles/tile_draw_info.h"
+#include "cc/tiles/tile_task_manager.h"
namespace base {
namespace trace_event {
@@ -117,8 +118,8 @@
// FinishTasksAndCleanUp must be called in between consecutive calls to
// SetResources.
void SetResources(ResourcePool* resource_pool,
- TileTaskWorkerPool* tile_task_worker_pool,
ImageDecodeController* image_decode_controller,
+ TileTaskManager* tile_task_manager,
size_t scheduled_raster_task_limit,
bool use_gpu_rasterization);
@@ -147,7 +148,8 @@
TileDrawInfo& draw_info = tiles[i]->draw_info();
draw_info.resource_ = resource_pool_->AcquireResource(
tiles[i]->desired_texture_size(),
- tile_task_worker_pool_->GetResourceFormat(false));
+ tile_task_manager_->GetRasterBufferProvider()->GetResourceFormat(
+ false));
}
}
@@ -163,8 +165,7 @@
global_state_ = state;
}
- void SetTileTaskWorkerPoolForTesting(
- TileTaskWorkerPool* tile_task_worker_pool);
+ void SetTileTaskManagerForTesting(TileTaskManager* tile_task_manager);
void FreeResourcesAndCleanUpReleasedTilesForTesting() {
FreeResourcesForReleasedTiles();
@@ -287,7 +288,7 @@
TileManagerClient* client_;
scoped_refptr<base::SequencedTaskRunner> task_runner_;
ResourcePool* resource_pool_;
- TileTaskWorkerPool* tile_task_worker_pool_;
+ TileTaskManager* tile_task_manager_;
GlobalStateThatImpactsTilePriority global_state_;
size_t scheduled_raster_task_limit_;
const bool use_partial_raster_;
diff --git a/cc/tiles/tile_manager_perftest.cc b/cc/tiles/tile_manager_perftest.cc
index e573c5a..134ec374 100644
--- a/cc/tiles/tile_manager_perftest.cc
+++ b/cc/tiles/tile_manager_perftest.cc
@@ -20,6 +20,7 @@
#include "cc/test/fake_raster_source.h"
#include "cc/test/fake_tile_manager.h"
#include "cc/test/fake_tile_manager_client.h"
+#include "cc/test/fake_tile_task_manager.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_task_graph_runner.h"
#include "cc/test/test_tile_priorities.h"
@@ -37,54 +38,7 @@
static const int kWarmupRuns = 5;
static const int kTimeCheckInterval = 10;
-class FakeTileTaskWorkerPoolImpl : public TileTaskWorkerPool,
- public RasterBufferProvider {
- public:
- // Overridden from TileTaskWorkerPool:
- void Shutdown() override {}
- void ScheduleTasks(TaskGraph* graph) override {
- for (auto& node : graph->nodes) {
- TileTask* task = static_cast<TileTask*>(node.task);
-
- task->WillSchedule();
- task->ScheduleOnOriginThread(this);
- task->DidSchedule();
-
- completed_tasks_.push_back(task);
- }
- }
- void CheckForCompletedTasks() override {
- for (TileTask::Vector::iterator it = completed_tasks_.begin();
- it != completed_tasks_.end(); ++it) {
- TileTask* task = it->get();
-
- task->WillComplete();
- task->CompleteOnOriginThread(this);
- task->DidComplete();
- }
- completed_tasks_.clear();
- }
- ResourceFormat GetResourceFormat(bool must_support_alpha) const override {
- return RGBA_8888;
- }
- bool GetResourceRequiresSwizzle(bool must_support_alpha) const override {
- return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
- }
- RasterBufferProvider* AsRasterBufferProvider() override { return this; }
-
- // Overridden from RasterBufferProvider:
- std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource,
- uint64_t new_content_id,
- uint64_t previous_content_id) override {
- return nullptr;
- }
- void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {}
-
- private:
- TileTask::Vector completed_tasks_;
-};
-base::LazyInstance<FakeTileTaskWorkerPoolImpl> g_fake_tile_task_worker_pool =
+base::LazyInstance<FakeTileTaskManagerImpl> g_fake_tile_task_manager =
LAZY_INSTANCE_INITIALIZER;
class TileManagerPerfTest : public testing::Test {
@@ -127,8 +81,8 @@
virtual void InitializeRenderer() {
host_impl_.SetVisible(true);
host_impl_.InitializeRenderer(output_surface_.get());
- tile_manager()->SetTileTaskWorkerPoolForTesting(
- g_fake_tile_task_worker_pool.Pointer());
+ tile_manager()->SetTileTaskManagerForTesting(
+ g_fake_tile_task_manager.Pointer());
}
void SetupDefaultTrees(const gfx::Size& layer_bounds) {
diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index a691b44..18cdcb83 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc
@@ -23,6 +23,7 @@
#include "cc/test/fake_raster_source.h"
#include "cc/test/fake_recording_source.h"
#include "cc/test/fake_tile_manager.h"
+#include "cc/test/fake_tile_task_manager.h"
#include "cc/test/test_gpu_memory_buffer_manager.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_task_graph_runner.h"
@@ -1907,51 +1908,21 @@
run_loop.Run();
}
-// Fake TileTaskRunner that just no-ops all calls.
-// Fake TileTaskWorkerPool that just no-ops all calls.
-class FakeTileTaskWorkerPool : public TileTaskWorkerPool,
- public RasterBufferProvider {
+// Fake TileTaskManager that just cancels all scheduled tasks immediately.
+class CancellingTileTaskManager : public FakeTileTaskManagerImpl {
public:
- FakeTileTaskWorkerPool() {}
- ~FakeTileTaskWorkerPool() override {}
-
- // TileTaskWorkerPool methods.
- void Shutdown() override {}
- void CheckForCompletedTasks() override {}
- ResourceFormat GetResourceFormat(bool must_support_alpha) const override {
- return ResourceFormat::RGBA_8888;
- }
- bool GetResourceRequiresSwizzle(bool must_support_alpha) const override {
- return false;
- }
- RasterBufferProvider* AsRasterBufferProvider() override { return this; }
-
- void ScheduleTasks(TaskGraph* graph) override {}
-
- // RasterBufferProvider methods.
- std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
- const Resource* resource,
- uint64_t resource_content_id,
- uint64_t previous_content_id) override {
- NOTREACHED();
- return nullptr;
- }
- void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {}
-};
-
-// Fake TileTaskWorkerPool that just cancels all scheduled tasks immediately.
-class CancellingTileTaskWorkerPool : public FakeTileTaskWorkerPool {
- public:
- CancellingTileTaskWorkerPool() {}
- ~CancellingTileTaskWorkerPool() override {}
+ CancellingTileTaskManager() {}
+ ~CancellingTileTaskManager() override {}
void ScheduleTasks(TaskGraph* graph) override {
// Just call CompleteOnOriginThread on each item in the queue. As none of
// these items have run yet, they will be treated as cancelled tasks.
for (const auto& node : graph->nodes) {
- static_cast<TileTask*>(node.task)->CompleteOnOriginThread(this);
+ static_cast<TileTask*>(node.task)->CompleteOnOriginThread(
+ raster_buffer_provider_.get());
}
}
+ void CheckForCompletedTasks() override {}
};
class PartialRasterTileManagerTest : public TileManagerTest {
@@ -1966,9 +1937,9 @@
TEST_F(PartialRasterTileManagerTest, CancelledTasksHaveNoContentId) {
// Create a CancellingTaskRunner and set it on the tile manager so that all
// scheduled work is immediately cancelled.
- CancellingTileTaskWorkerPool cancelling_worker_pool;
- host_impl_->tile_manager()->SetTileTaskWorkerPoolForTesting(
- &cancelling_worker_pool);
+ CancellingTileTaskManager cancelling_task_manager;
+ host_impl_->tile_manager()->SetTileTaskManagerForTesting(
+ &cancelling_task_manager);
// Pick arbitrary IDs - they don't really matter as long as they're constant.
const int kLayerId = 7;
@@ -2001,9 +1972,8 @@
EXPECT_FALSE(queue->IsEmpty());
queue->Top().tile()->SetInvalidated(gfx::Rect(), kInvalidatedId);
- // PrepareTiles to schedule tasks. Due to the CancellingTileTaskWorkerPool,
- // these
- // tasks will immediately be canceled.
+ // PrepareTiles to schedule tasks. Due to the CancellingTileTaskManager,
+ // these tasks will immediately be canceled.
host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
// Make sure that the tile we invalidated above was not returned to the pool
@@ -2012,31 +1982,20 @@
EXPECT_FALSE(host_impl_->resource_pool()->TryAcquireResourceWithContentId(
kInvalidatedId));
- // Free our host_impl_ before the cancelling_worker_pool we passed it, as it
- // will
- // use that class in clean up.
+ // Free our host_impl_ before the cancelling_task_manager we passed it, as it
+ // will use that class in clean up.
host_impl_ = nullptr;
}
-// Fake TileTaskWorkerPool that verifies the resource content ID of raster
+// FakeRasterBufferProviderImpl that verifies the resource content ID of raster
// tasks.
-class VerifyResourceContentIdTileTaskWorkerPool
- : public FakeTileTaskWorkerPool {
+class VerifyResourceContentIdRasterBufferProvider
+ : public FakeRasterBufferProviderImpl {
public:
- explicit VerifyResourceContentIdTileTaskWorkerPool(
+ explicit VerifyResourceContentIdRasterBufferProvider(
uint64_t expected_resource_id)
: expected_resource_id_(expected_resource_id) {}
- ~VerifyResourceContentIdTileTaskWorkerPool() override {}
-
- void ScheduleTasks(TaskGraph* graph) override {
- for (const auto& node : graph->nodes) {
- TileTask* task = static_cast<TileTask*>(node.task);
- // Triggers a call to AcquireBufferForRaster.
- task->ScheduleOnOriginThread(this);
- // Calls TileManager as though task was cancelled.
- task->CompleteOnOriginThread(this);
- }
- }
+ ~VerifyResourceContentIdRasterBufferProvider() override {}
// RasterBufferProvider methods.
std::unique_ptr<RasterBuffer> AcquireBufferForRaster(
@@ -2051,6 +2010,26 @@
uint64_t expected_resource_id_;
};
+class VerifyResourceContentIdTileTaskManager : public FakeTileTaskManagerImpl {
+ public:
+ explicit VerifyResourceContentIdTileTaskManager(uint64_t expected_resource_id)
+ : FakeTileTaskManagerImpl(base::WrapUnique<RasterBufferProvider>(
+ new VerifyResourceContentIdRasterBufferProvider(
+ expected_resource_id))) {}
+ ~VerifyResourceContentIdTileTaskManager() override {}
+
+ void ScheduleTasks(TaskGraph* graph) override {
+ for (const auto& node : graph->nodes) {
+ TileTask* task = static_cast<TileTask*>(node.task);
+ // Triggers a call to AcquireBufferForRaster.
+ task->ScheduleOnOriginThread(raster_buffer_provider_.get());
+ // Calls TileManager as though task was cancelled.
+ task->CompleteOnOriginThread(raster_buffer_provider_.get());
+ }
+ }
+ void CheckForCompletedTasks() override {}
+};
+
// Runs a test to ensure that partial raster is either enabled or disabled,
// depending on |partial_raster_enabled|'s value. Takes ownership of host_impl
// so that cleanup order can be controlled.
@@ -2062,12 +2041,11 @@
const uint64_t kExpectedId = partial_raster_enabled ? kInvalidatedId : 0u;
const gfx::Size kTileSize(128, 128);
- // Create a VerifyResourceContentIdTileTaskWorkerPool to ensure that the
- // raster
- // task we see is created with |kExpectedId|.
- VerifyResourceContentIdTileTaskWorkerPool verifying_worker_pool(kExpectedId);
- host_impl->tile_manager()->SetTileTaskWorkerPoolForTesting(
- &verifying_worker_pool);
+ // Create a VerifyResourceContentIdTileTaskManager to ensure that the
+ // raster task we see is created with |kExpectedId|.
+ VerifyResourceContentIdTileTaskManager verifying_task_manager(kExpectedId);
+ host_impl->tile_manager()->SetTileTaskManagerForTesting(
+ &verifying_task_manager);
// Ensure there's a resource with our |kInvalidatedId| in the resource pool.
host_impl->resource_pool()->ReleaseResource(
@@ -2102,13 +2080,12 @@
queue->Top().tile()->SetInvalidated(gfx::Rect(), kInvalidatedId);
// PrepareTiles to schedule tasks. Due to the
- // VerifyPreviousContentTileTaskWorkerPool, these tasks will verified and
+ // VerifyPreviousContentRasterBufferProvider, these tasks will verified and
// cancelled.
host_impl->tile_manager()->PrepareTiles(host_impl->global_tile_state());
- // Free our host_impl before the cancelling_worker_pool we passed it, as it
- // will
- // use that class in clean up.
+ // Free our host_impl before the verifying_task_manager we passed it, as it
+ // will use that class in clean up.
host_impl = nullptr;
}
diff --git a/cc/tiles/tile_task_manager.cc b/cc/tiles/tile_task_manager.cc
new file mode 100644
index 0000000..9f78d38
--- /dev/null
+++ b/cc/tiles/tile_task_manager.cc
@@ -0,0 +1,86 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/tiles/tile_task_manager.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/trace_event/trace_event.h"
+
+namespace cc {
+
+TileTaskManager::TileTaskManager() {}
+
+TileTaskManager::~TileTaskManager() {}
+
+// static
+std::unique_ptr<TileTaskManagerImpl> TileTaskManagerImpl::Create(
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider,
+ TaskGraphRunner* task_graph_runner) {
+ return base::WrapUnique<TileTaskManagerImpl>(new TileTaskManagerImpl(
+ std::move(raster_buffer_provider), task_graph_runner));
+}
+
+TileTaskManagerImpl::TileTaskManagerImpl(
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider,
+ TaskGraphRunner* task_graph_runner)
+ : raster_buffer_provider_(std::move(raster_buffer_provider)),
+ task_graph_runner_(task_graph_runner),
+ namespace_token_(task_graph_runner->GetNamespaceToken()) {}
+
+TileTaskManagerImpl::~TileTaskManagerImpl() {
+ DCHECK_EQ(0u, completed_tasks_.size());
+}
+
+void TileTaskManagerImpl::ScheduleTasks(TaskGraph* graph) {
+ TRACE_EVENT0("cc", "TileTaskManagerImpl::ScheduleTasks");
+
+ for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
+ it != graph->nodes.end(); ++it) {
+ TaskGraph::Node& node = *it;
+ TileTask* task = static_cast<TileTask*>(node.task);
+
+ if (!task->HasBeenScheduled()) {
+ task->WillSchedule();
+ task->ScheduleOnOriginThread(raster_buffer_provider_.get());
+ task->DidSchedule();
+ }
+ }
+
+ raster_buffer_provider_->OrderingBarrier();
+
+ task_graph_runner_->ScheduleTasks(namespace_token_, graph);
+}
+
+void TileTaskManagerImpl::CheckForCompletedTasks() {
+ TRACE_EVENT0("cc", "TileTaskManagerImpl::CheckForCompletedTasks");
+
+ task_graph_runner_->CollectCompletedTasks(namespace_token_,
+ &completed_tasks_);
+ for (Task::Vector::const_iterator it = completed_tasks_.begin();
+ it != completed_tasks_.end(); ++it) {
+ TileTask* task = static_cast<TileTask*>(it->get());
+
+ task->WillComplete();
+ task->CompleteOnOriginThread(raster_buffer_provider_.get());
+ task->DidComplete();
+ }
+ completed_tasks_.clear();
+}
+
+void TileTaskManagerImpl::Shutdown() {
+ TRACE_EVENT0("cc", "TileTaskManagerImpl::Shutdown");
+
+ // Cancel non-scheduled tasks and wait for running tasks to finish.
+ TaskGraph empty;
+ task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
+ task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
+
+ raster_buffer_provider_->Shutdown();
+}
+
+RasterBufferProvider* TileTaskManagerImpl::GetRasterBufferProvider() const {
+ return raster_buffer_provider_.get();
+}
+
+} // namespace cc
diff --git a/cc/tiles/tile_task_manager.h b/cc/tiles/tile_task_manager.h
new file mode 100644
index 0000000..e670b41
--- /dev/null
+++ b/cc/tiles/tile_task_manager.h
@@ -0,0 +1,72 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_TILES_TILE_TASK_MANAGER_H_
+#define CC_TILES_TILE_TASK_MANAGER_H_
+
+#include <stddef.h>
+
+#include "cc/raster/raster_buffer_provider.h"
+#include "cc/raster/task_graph_runner.h"
+#include "cc/raster/tile_task.h"
+
+namespace cc {
+// This interface provides the wrapper over TaskGraphRunner for scheduling and
+// collecting tasks. The client can call CheckForCompletedTasks() at any time to
+// process all completed tasks at the moment that have finished running or
+// cancelled.
+class CC_EXPORT TileTaskManager {
+ public:
+ TileTaskManager();
+ virtual ~TileTaskManager();
+
+ // Schedule running of tile tasks in |graph| and all dependencies.
+ // Previously scheduled tasks that are not in |graph| will be canceled unless
+ // already running. Once scheduled, reply callbacks are guaranteed to run for
+ // all tasks even if they later get canceled by another call to
+ // ScheduleTasks().
+ virtual void ScheduleTasks(TaskGraph* graph) = 0;
+
+ // Check for completed tasks and dispatch reply callbacks.
+ virtual void CheckForCompletedTasks() = 0;
+
+ // Shutdown after canceling all previously scheduled tasks. Reply callbacks
+ // are still guaranteed to run when CheckForCompletedTasks() is called.
+ virtual void Shutdown() = 0;
+
+ // Get RasterBufferProvider.
+ virtual RasterBufferProvider* GetRasterBufferProvider() const = 0;
+};
+
+class CC_EXPORT TileTaskManagerImpl : public TileTaskManager {
+ public:
+ ~TileTaskManagerImpl() override;
+
+ static std::unique_ptr<TileTaskManagerImpl> Create(
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider,
+ TaskGraphRunner* task_graph_runner);
+
+ // Overridden from TileTaskManager:
+ void ScheduleTasks(TaskGraph* graph) override;
+ void CheckForCompletedTasks() override;
+ void Shutdown() override;
+ RasterBufferProvider* GetRasterBufferProvider() const override;
+
+ protected:
+ TileTaskManagerImpl(
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider,
+ TaskGraphRunner* task_graph_runner);
+
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
+ TaskGraphRunner* task_graph_runner_;
+ const NamespaceToken namespace_token_;
+ Task::Vector completed_tasks_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(TileTaskManagerImpl);
+};
+
+} // namespace cc
+
+#endif // CC_TILES_TILE_TASK_MANAGER_H_
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 8583ec4..27d28a3 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -63,13 +63,13 @@
#include "cc/quads/shared_quad_state.h"
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/texture_draw_quad.h"
-#include "cc/raster/bitmap_tile_task_worker_pool.h"
+#include "cc/raster/bitmap_raster_buffer_provider.h"
+#include "cc/raster/gpu_raster_buffer_provider.h"
#include "cc/raster/gpu_rasterizer.h"
-#include "cc/raster/gpu_tile_task_worker_pool.h"
-#include "cc/raster/one_copy_tile_task_worker_pool.h"
+#include "cc/raster/one_copy_raster_buffer_provider.h"
+#include "cc/raster/raster_buffer_provider.h"
#include "cc/raster/synchronous_task_graph_runner.h"
-#include "cc/raster/tile_task_worker_pool.h"
-#include "cc/raster/zero_copy_tile_task_worker_pool.h"
+#include "cc/raster/zero_copy_raster_buffer_provider.h"
#include "cc/resources/memory_history.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/ui_resource_bitmap.h"
@@ -79,6 +79,7 @@
#include "cc/tiles/picture_layer_tiling.h"
#include "cc/tiles/raster_tile_priority_queue.h"
#include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/tile_task_manager.h"
#include "cc/trees/damage_tracker.h"
#include "cc/trees/draw_property_utils.h"
#include "cc/trees/latency_info_swap_promise_monitor.h"
@@ -2134,7 +2135,9 @@
}
void LayerTreeHostImpl::CreateTileManagerResources() {
- CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_);
+ std::unique_ptr<RasterBufferProvider> raster_buffer_provider;
+ CreateResourceAndRasterBufferProvider(&raster_buffer_provider,
+ &resource_pool_);
if (use_gpu_rasterization_) {
image_decode_controller_ = base::WrapUnique(new GpuImageDecodeController(
@@ -2146,24 +2149,6 @@
settings_.renderer_settings.preferred_tile_format));
}
- // TODO(vmpstr): Initialize tile task limit at ctor time.
- tile_manager_->SetResources(
- resource_pool_.get(), tile_task_worker_pool_.get(),
- image_decode_controller_.get(),
- is_synchronous_single_threaded_ ? std::numeric_limits<size_t>::max()
- : settings_.scheduled_raster_task_limit,
- use_gpu_rasterization_);
- UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
-}
-
-void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
- std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
- std::unique_ptr<ResourcePool>* resource_pool) {
- DCHECK(GetTaskRunner());
- // TODO(vmpstr): Make this a DCHECK (or remove) when crbug.com/419086 is
- // resolved.
- CHECK(resource_provider_);
-
// Pass the single-threaded synchronous task graph runner to the worker pool
// if we're in synchronous single-threaded mode.
TaskGraphRunner* task_graph_runner = task_graph_runner_;
@@ -2174,13 +2159,34 @@
task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
}
+ tile_task_manager_ = TileTaskManagerImpl::Create(
+ std::move(raster_buffer_provider), task_graph_runner);
+
+ // TODO(vmpstr): Initialize tile task limit at ctor time.
+ tile_manager_->SetResources(
+ resource_pool_.get(), image_decode_controller_.get(),
+ tile_task_manager_.get(),
+ is_synchronous_single_threaded_ ? std::numeric_limits<size_t>::max()
+ : settings_.scheduled_raster_task_limit,
+ use_gpu_rasterization_);
+ UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
+}
+
+void LayerTreeHostImpl::CreateResourceAndRasterBufferProvider(
+ std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
+ std::unique_ptr<ResourcePool>* resource_pool) {
+ DCHECK(GetTaskRunner());
+ // TODO(vmpstr): Make this a DCHECK (or remove) when crbug.com/419086 is
+ // resolved.
+ CHECK(resource_provider_);
+
ContextProvider* context_provider = output_surface_->context_provider();
if (!context_provider) {
*resource_pool =
ResourcePool::Create(resource_provider_.get(), GetTaskRunner());
- *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
- GetTaskRunner(), task_graph_runner, resource_provider_.get());
+ *raster_buffer_provider =
+ BitmapRasterBufferProvider::Create(resource_provider_.get());
return;
}
@@ -2192,10 +2198,9 @@
int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
- *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
- GetTaskRunner(), task_graph_runner, context_provider,
- resource_provider_.get(), settings_.use_distance_field_text,
- msaa_sample_count);
+ *raster_buffer_provider = GpuRasterBufferProvider::Create(
+ context_provider, resource_provider_.get(),
+ settings_.use_distance_field_text, msaa_sample_count);
return;
}
@@ -2214,8 +2219,8 @@
*resource_pool = ResourcePool::CreateForGpuMemoryBufferResources(
resource_provider_.get(), GetTaskRunner());
- *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
- GetTaskRunner(), task_graph_runner, resource_provider_.get(),
+ *raster_buffer_provider = ZeroCopyRasterBufferProvider::Create(
+ resource_provider_.get(),
settings_.renderer_settings.preferred_tile_format);
return;
}
@@ -2226,10 +2231,10 @@
const int max_copy_texture_chromium_size =
context_provider->ContextCapabilities().max_copy_texture_chromium_size;
- *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
- GetTaskRunner(), task_graph_runner, context_provider,
- resource_provider_.get(), max_copy_texture_chromium_size,
- settings_.use_partial_raster, settings_.max_staging_buffer_usage_in_bytes,
+ *raster_buffer_provider = OneCopyRasterBufferProvider::Create(
+ GetTaskRunner(), context_provider, resource_provider_.get(),
+ max_copy_texture_chromium_size, settings_.use_partial_raster,
+ settings_.max_staging_buffer_usage_in_bytes,
settings_.renderer_settings.preferred_tile_format);
}
@@ -2243,7 +2248,7 @@
ClearUIResources();
tile_manager_->FinishTasksAndCleanUp();
resource_pool_ = nullptr;
- tile_task_worker_pool_ = nullptr;
+ tile_task_manager_ = nullptr;
single_thread_synchronous_task_graph_runner_ = nullptr;
image_decode_controller_ = nullptr;
}
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index ae4f257..935f4f0 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -64,7 +64,8 @@
class PageScaleAnimation;
class PictureLayerImpl;
class RasterTilePriorityQueue;
-class TileTaskWorkerPool;
+class TileTaskManager;
+class RasterBufferProvider;
class RenderPassDrawQuad;
class RenderingStatsInstrumentation;
class ResourcePool;
@@ -575,8 +576,8 @@
bool SupportsImplScrolling() const;
bool CommitToActiveTree() const;
- virtual void CreateResourceAndTileTaskWorkerPool(
- std::unique_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+ virtual void CreateResourceAndRasterBufferProvider(
+ std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
std::unique_ptr<ResourcePool>* resource_pool);
bool prepare_tiles_needed() const { return tile_priorities_dirty_; }
@@ -731,7 +732,7 @@
bool use_msaa_;
GpuRasterizationStatus gpu_rasterization_status_;
bool tree_resources_for_gpu_rasterization_dirty_;
- std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
+ std::unique_ptr<TileTaskManager> tile_task_manager_;
std::unique_ptr<ResourcePool> resource_pool_;
std::unique_ptr<Renderer> renderer_;
std::unique_ptr<ImageDecodeController> image_decode_controller_;