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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/tiles/tile_manager_unittest.cc

Issue 1988053002: Revert of cc: Refactor layer/tile manager unittest to extract common code. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/tiles/tile_manager_perftest.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/tiles/tile_manager_unittest.cc
diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index fff4db7e5a075faf05925cdcbf9d0c1ccb65e65d..b40df6bf5b928918da4799c03a09a9a0b6ded899 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc
@@ -25,7 +25,6 @@
#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_layer_tree_host_base.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/test/test_task_graph_runner.h"
#include "cc/test/test_tile_priorities.h"
@@ -43,24 +42,148 @@
namespace cc {
namespace {
-class TileManagerTilePriorityQueueTest : public TestLayerTreeHostBase {
+class LowResTilingsSettings : public LayerTreeSettings {
public:
- LayerTreeSettings CreateSettings() override {
- LayerTreeSettings settings;
- settings.create_low_res_tiling = true;
- settings.verify_clip_tree_calculations = true;
- return settings;
- }
-
- TileManager* tile_manager() { return host_impl()->tile_manager(); }
+ LowResTilingsSettings() {
+ create_low_res_tiling = true;
+ verify_clip_tree_calculations = true;
+ }
+};
+
+class TileManagerTilePriorityQueueTest : public testing::Test {
+ public:
+ TileManagerTilePriorityQueueTest()
+ : memory_limit_policy_(ALLOW_ANYTHING),
+ max_tiles_(10000),
+ ready_to_activate_(false),
+ id_(7),
+ task_runner_provider_(base::ThreadTaskRunnerHandle::Get()),
+ output_surface_(FakeOutputSurface::Create3d()),
+ host_impl_(LowResTilingsSettings(),
+ &task_runner_provider_,
+ &shared_bitmap_manager_,
+ &task_graph_runner_,
+ &gpu_memory_buffer_manager_) {}
+
+ void SetTreePriority(TreePriority tree_priority) {
+ GlobalStateThatImpactsTilePriority state;
+ gfx::Size tile_size(256, 256);
+
+ state.soft_memory_limit_in_bytes = 100 * 1000 * 1000;
+ state.num_resources_limit = max_tiles_;
+ state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes * 2;
+ state.memory_limit_policy = memory_limit_policy_;
+ state.tree_priority = tree_priority;
+
+ global_state_ = state;
+ host_impl_.resource_pool()->SetResourceUsageLimits(
+ state.soft_memory_limit_in_bytes,
+ state.num_resources_limit);
+ host_impl_.tile_manager()->SetGlobalStateForTesting(state);
+ }
+
+ void SetUp() override {
+ InitializeRenderer();
+ SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
+ }
+
+ virtual void InitializeRenderer() {
+ host_impl_.SetVisible(true);
+ host_impl_.InitializeRenderer(output_surface_.get());
+ }
+
+ void SetupDefaultTrees(const gfx::Size& layer_bounds) {
+ scoped_refptr<FakeRasterSource> pending_raster_source =
+ FakeRasterSource::CreateFilled(layer_bounds);
+ scoped_refptr<FakeRasterSource> active_raster_source =
+ FakeRasterSource::CreateFilled(layer_bounds);
+
+ SetupTrees(pending_raster_source, active_raster_source);
+ }
+
+ // This matches picture_layer_impl_unittest's ActivateTree.
+ void ActivateTree() {
+ host_impl_.ActivateSyncTree();
+ CHECK(!host_impl_.pending_tree());
+ pending_layer_ = NULL;
+ active_layer_ = static_cast<FakePictureLayerImpl*>(
+ host_impl_.active_tree()->LayerById(id_));
+ bool update_lcd_text = false;
+ host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
+ }
+
+ void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
+ const gfx::Size& tile_size) {
+ SetupDefaultTrees(layer_bounds);
+ pending_layer_->set_fixed_tile_size(tile_size);
+ active_layer_->set_fixed_tile_size(tile_size);
+ }
+
+ void SetupTrees(scoped_refptr<RasterSource> pending_raster_source,
+ scoped_refptr<RasterSource> active_raster_source) {
+ SetupPendingTree(active_raster_source);
+ ActivateTree();
+ SetupPendingTree(pending_raster_source);
+ }
+
+ void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
+ host_impl_.CreatePendingTree();
+ LayerTreeImpl* pending_tree = host_impl_.pending_tree();
+
+ // Steal from the recycled tree.
+ LayerImpl* old_pending_root = pending_tree->root_layer();
+ DCHECK(!old_pending_root || old_pending_root->id() == id_);
+
+ FakePictureLayerImpl* pending_layer = nullptr;
+ if (old_pending_root) {
+ pending_layer = static_cast<FakePictureLayerImpl*>(old_pending_root);
+ pending_layer->SetRasterSourceOnPending(raster_source, Region());
+ } else {
+ std::unique_ptr<FakePictureLayerImpl> new_root =
+ FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
+ raster_source);
+ pending_layer = new_root.get();
+ pending_tree->SetRootLayer(std::move(new_root));
+ pending_layer->SetDrawsContent(true);
+ pending_layer->SetHasRenderSurface(true);
+ }
+ // The bounds() just mirror the raster source size.
+ pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
+
+ pending_layer_ = static_cast<FakePictureLayerImpl*>(
+ host_impl_.pending_tree()->LayerById(id_));
+
+ // Add tilings/tiles for the layer.
+ bool update_lcd_text = false;
+ host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+ host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
+ }
+
+ TileManager* tile_manager() { return host_impl_.tile_manager(); }
+
+ protected:
+ GlobalStateThatImpactsTilePriority global_state_;
+
+ TestSharedBitmapManager shared_bitmap_manager_;
+ TestTaskGraphRunner task_graph_runner_;
+ TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
+ TileMemoryLimitPolicy memory_limit_policy_;
+ int max_tiles_;
+ bool ready_to_activate_;
+ int id_;
+ FakeImplTaskRunnerProvider task_runner_provider_;
+ std::unique_ptr<OutputSurface> output_surface_;
+ FakeLayerTreeHostImpl host_impl_;
+ FakePictureLayerImpl* pending_layer_;
+ FakePictureLayerImpl* active_layer_;
};
TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueue) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
@@ -78,8 +201,8 @@
// Sanity check, all tiles should be visible.
std::set<Tile*> smoothness_tiles;
- queue = host_impl()->BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
bool had_low_res = false;
while (!queue->IsEmpty()) {
PrioritizedTile prioritized_tile = queue->Top();
@@ -95,7 +218,7 @@
EXPECT_TRUE(had_low_res);
// Check that everything is required for activation.
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
std::set<Tile*> required_for_activation_tiles;
@@ -108,7 +231,7 @@
EXPECT_EQ(all_tiles, required_for_activation_tiles);
// Check that everything is required for draw.
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
std::set<Tile*> required_for_draw_tiles;
@@ -123,35 +246,35 @@
Region invalidation(gfx::Rect(0, 0, 500, 500));
// Invalidate the pending tree.
- pending_layer()->set_invalidation(invalidation);
- pending_layer()->HighResTiling()->Invalidate(invalidation);
+ pending_layer_->set_invalidation(invalidation);
+ pending_layer_->HighResTiling()->Invalidate(invalidation);
// Renew all of the tile priorities.
gfx::Rect viewport(50, 50, 100, 100);
- pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+ pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
- active_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+ active_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
// Populate all tiles directly from the tilings.
all_tiles.clear();
std::set<Tile*> high_res_tiles;
std::vector<Tile*> pending_high_res_tiles =
- pending_layer()->HighResTiling()->AllTilesForTesting();
+ pending_layer_->HighResTiling()->AllTilesForTesting();
for (size_t i = 0; i < pending_high_res_tiles.size(); ++i) {
all_tiles.insert(pending_high_res_tiles[i]);
high_res_tiles.insert(pending_high_res_tiles[i]);
}
std::vector<Tile*> active_high_res_tiles =
- active_layer()->HighResTiling()->AllTilesForTesting();
+ active_layer_->HighResTiling()->AllTilesForTesting();
for (size_t i = 0; i < active_high_res_tiles.size(); ++i) {
all_tiles.insert(active_high_res_tiles[i]);
high_res_tiles.insert(active_high_res_tiles[i]);
}
std::vector<Tile*> active_low_res_tiles =
- active_layer()->LowResTiling()->AllTilesForTesting();
+ active_layer_->LowResTiling()->AllTilesForTesting();
for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
all_tiles.insert(active_low_res_tiles[i]);
@@ -160,8 +283,8 @@
tile_count = 0;
size_t correct_order_tiles = 0u;
// Here we expect to get increasing ACTIVE_TREE priority_bin.
- queue = host_impl()->BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(SMOOTHNESS_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
std::set<Tile*> expected_required_for_draw_tiles;
std::set<Tile*> expected_required_for_activation_tiles;
while (!queue->IsEmpty()) {
@@ -210,7 +333,7 @@
EXPECT_GT(correct_order_tiles, 3 * tile_count / 4);
// Check that we have consistent required_for_activation tiles.
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
required_for_activation_tiles.clear();
@@ -225,7 +348,7 @@
EXPECT_NE(all_tiles, required_for_activation_tiles);
// Check that we have consistent required_for_draw tiles.
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
SMOOTHNESS_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
required_for_draw_tiles.clear();
@@ -242,8 +365,8 @@
last_tile = PrioritizedTile();
size_t increasing_distance_tiles = 0u;
// Here we expect to get increasing PENDING_TREE priority_bin.
- queue = host_impl()->BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
- RasterTilePriorityQueue::Type::ALL);
+ queue = host_impl_.BuildRasterQueue(NEW_CONTENT_TAKES_PRIORITY,
+ RasterTilePriorityQueue::Type::ALL);
tile_count = 0;
while (!queue->IsEmpty()) {
PrioritizedTile prioritized_tile = queue->Top();
@@ -281,7 +404,7 @@
EXPECT_GE(increasing_distance_tiles, 3 * tile_count / 4);
// Check that we have consistent required_for_activation tiles.
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
NEW_CONTENT_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
required_for_activation_tiles.clear();
@@ -296,7 +419,7 @@
EXPECT_NE(new_content_tiles, required_for_activation_tiles);
// Check that we have consistent required_for_draw tiles.
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
NEW_CONTENT_TAKES_PRIORITY,
RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
required_for_draw_tiles.clear();
@@ -314,22 +437,22 @@
RasterTilePriorityQueueHighNonIdealTilings) {
const gfx::Size layer_bounds(1000, 1000);
const gfx::Size viewport(800, 800);
- host_impl()->SetViewportSize(viewport);
+ host_impl_.SetViewportSize(viewport);
SetupDefaultTrees(layer_bounds);
- pending_layer()->tilings()->AddTiling(1.5f, pending_layer()->raster_source());
- active_layer()->tilings()->AddTiling(1.5f, active_layer()->raster_source());
- pending_layer()->tilings()->AddTiling(1.7f, pending_layer()->raster_source());
- active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
-
- pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
- 5.0, Occlusion(), true);
- active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+ pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
+ active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
+ pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
+ active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
+
+ pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
Occlusion(), true);
+ active_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+ Occlusion(), true);
std::set<Tile*> all_expected_tiles;
- for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
- PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
+ for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+ PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
if (tiling->contents_scale() == 1.f) {
tiling->set_resolution(HIGH_RESOLUTION);
const auto& all_tiles = tiling->AllTilesForTesting();
@@ -339,8 +462,8 @@
}
}
- for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
- PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
+ for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+ PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
if (tiling->contents_scale() == 1.5f) {
tiling->set_resolution(HIGH_RESOLUTION);
const auto& all_tiles = tiling->AllTilesForTesting();
@@ -359,7 +482,7 @@
}
}
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
@@ -381,22 +504,22 @@
RasterTilePriorityQueueHighLowTilings) {
const gfx::Size layer_bounds(1000, 1000);
const gfx::Size viewport(800, 800);
- host_impl()->SetViewportSize(viewport);
+ host_impl_.SetViewportSize(viewport);
SetupDefaultTrees(layer_bounds);
- pending_layer()->tilings()->AddTiling(1.5f, pending_layer()->raster_source());
- active_layer()->tilings()->AddTiling(1.5f, active_layer()->raster_source());
- pending_layer()->tilings()->AddTiling(1.7f, pending_layer()->raster_source());
- active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
-
- pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
- 5.0, Occlusion(), true);
- active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+ pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
+ active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
+ pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
+ active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
+
+ pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
Occlusion(), true);
+ active_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+ Occlusion(), true);
std::set<Tile*> all_expected_tiles;
- for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
- PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
+ for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+ PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
if (tiling->contents_scale() == 1.f) {
tiling->set_resolution(HIGH_RESOLUTION);
const auto& all_tiles = tiling->AllTilesForTesting();
@@ -406,8 +529,8 @@
}
}
- for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
- PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
+ for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+ PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
if (tiling->contents_scale() == 1.5f) {
tiling->set_resolution(HIGH_RESOLUTION);
const auto& all_tiles = tiling->AllTilesForTesting();
@@ -426,7 +549,7 @@
}
}
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
@@ -446,27 +569,27 @@
TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueInvalidation) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(gfx::Size(500, 500));
+ host_impl_.SetViewportSize(gfx::Size(500, 500));
SetupDefaultTrees(layer_bounds);
// Use a tile's content rect as an invalidation. We should inset it a bit to
// ensure that border math doesn't invalidate neighbouring tiles.
gfx::Rect invalidation =
- active_layer()->HighResTiling()->TileAt(1, 0)->content_rect();
+ active_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
invalidation.Inset(2, 2);
- pending_layer()->set_invalidation(invalidation);
- pending_layer()->HighResTiling()->Invalidate(invalidation);
- pending_layer()->HighResTiling()->CreateMissingTilesInLiveTilesRect();
+ pending_layer_->set_invalidation(invalidation);
+ pending_layer_->HighResTiling()->Invalidate(invalidation);
+ pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
// Sanity checks: Tile at 0, 0 not exist on the pending tree (it's not
// invalidated). Tile 1, 0 should exist on both.
- EXPECT_FALSE(pending_layer()->HighResTiling()->TileAt(0, 0));
- EXPECT_TRUE(active_layer()->HighResTiling()->TileAt(0, 0));
- EXPECT_TRUE(pending_layer()->HighResTiling()->TileAt(1, 0));
- EXPECT_TRUE(active_layer()->HighResTiling()->TileAt(1, 0));
- EXPECT_NE(pending_layer()->HighResTiling()->TileAt(1, 0),
- active_layer()->HighResTiling()->TileAt(1, 0));
+ EXPECT_FALSE(pending_layer_->HighResTiling()->TileAt(0, 0));
+ EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(0, 0));
+ EXPECT_TRUE(pending_layer_->HighResTiling()->TileAt(1, 0));
+ EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(1, 0));
+ EXPECT_NE(pending_layer_->HighResTiling()->TileAt(1, 0),
+ active_layer_->HighResTiling()->TileAt(1, 0));
std::set<Tile*> expected_now_tiles;
std::set<Tile*> expected_required_for_draw_tiles;
@@ -474,14 +597,14 @@
for (int i = 0; i <= 1; ++i) {
for (int j = 0; j <= 1; ++j) {
bool have_pending_tile = false;
- if (pending_layer()->HighResTiling()->TileAt(i, j)) {
+ if (pending_layer_->HighResTiling()->TileAt(i, j)) {
expected_now_tiles.insert(
- pending_layer()->HighResTiling()->TileAt(i, j));
+ pending_layer_->HighResTiling()->TileAt(i, j));
expected_required_for_activation_tiles.insert(
- pending_layer()->HighResTiling()->TileAt(i, j));
+ pending_layer_->HighResTiling()->TileAt(i, j));
have_pending_tile = true;
}
- Tile* active_tile = active_layer()->HighResTiling()->TileAt(i, j);
+ Tile* active_tile = active_layer_->HighResTiling()->TileAt(i, j);
EXPECT_TRUE(active_tile);
expected_now_tiles.insert(active_tile);
expected_required_for_draw_tiles.insert(active_tile);
@@ -500,11 +623,11 @@
std::set<Tile*> expected_all_tiles;
for (int i = 0; i <= 3; ++i) {
for (int j = 0; j <= 3; ++j) {
- if (pending_layer()->HighResTiling()->TileAt(i, j))
+ if (pending_layer_->HighResTiling()->TileAt(i, j))
expected_all_tiles.insert(
- pending_layer()->HighResTiling()->TileAt(i, j));
- EXPECT_TRUE(active_layer()->HighResTiling()->TileAt(i, j));
- expected_all_tiles.insert(active_layer()->HighResTiling()->TileAt(i, j));
+ pending_layer_->HighResTiling()->TileAt(i, j));
+ EXPECT_TRUE(active_layer_->HighResTiling()->TileAt(i, j));
+ expected_all_tiles.insert(active_layer_->HighResTiling()->TileAt(i, j));
}
}
// Expect 15 shared tiles and 1 unshared tile.
@@ -512,7 +635,7 @@
// The actual test will now build different queues and verify that the queues
// return the same information as computed manually above.
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
std::set<Tile*> actual_now_tiles;
std::set<Tile*> actual_all_tiles;
@@ -526,7 +649,7 @@
EXPECT_EQ(expected_now_tiles, actual_now_tiles);
EXPECT_EQ(expected_all_tiles, actual_all_tiles);
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES,
RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
std::set<Tile*> actual_required_for_draw_tiles;
@@ -537,7 +660,7 @@
}
EXPECT_EQ(expected_required_for_draw_tiles, actual_required_for_draw_tiles);
- queue = host_impl()->BuildRasterQueue(
+ queue = host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES,
RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
std::set<Tile*> actual_required_for_activation_tiles;
@@ -551,7 +674,7 @@
}
TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
- host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+ host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
gfx::Size layer_bounds(1000, 1000);
SetupDefaultTrees(layer_bounds);
@@ -561,21 +684,21 @@
FakeRasterSource::CreateFilled(layer_bounds);
std::unique_ptr<FakePictureLayerImpl> pending_child =
FakePictureLayerImpl::CreateWithRasterSource(
- host_impl()->pending_tree(), layer_id() + 1, pending_raster_source);
+ host_impl_.pending_tree(), id_ + 1, pending_raster_source);
FakePictureLayerImpl* pending_child_raw = pending_child.get();
pending_child_raw->SetDrawsContent(true);
- pending_layer()->AddChild(std::move(pending_child));
+ pending_layer_->AddChild(std::move(pending_child));
// Set a small viewport, so we have soon and eventually tiles.
- host_impl()->SetViewportSize(gfx::Size(200, 200));
- host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+ host_impl_.SetViewportSize(gfx::Size(200, 200));
+ host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
bool update_lcd_text = false;
- host_impl()->pending_tree()->property_trees()->needs_rebuild = true;
- host_impl()->pending_tree()->BuildPropertyTreesForTesting();
- host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
-
- host_impl()->SetRequiresHighResToDraw();
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ host_impl_.pending_tree()->property_trees()->needs_rebuild = true;
+ host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+ host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
+
+ host_impl_.SetRequiresHighResToDraw();
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SMOOTHNESS_TAKES_PRIORITY, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
@@ -600,22 +723,22 @@
TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- ASSERT_TRUE(active_layer()->HighResTiling());
- ASSERT_TRUE(active_layer()->LowResTiling());
- ASSERT_TRUE(pending_layer()->HighResTiling());
- EXPECT_FALSE(pending_layer()->LowResTiling());
+ ASSERT_TRUE(active_layer_->HighResTiling());
+ ASSERT_TRUE(active_layer_->LowResTiling());
+ ASSERT_TRUE(pending_layer_->HighResTiling());
+ EXPECT_FALSE(pending_layer_->LowResTiling());
std::unique_ptr<EvictionTilePriorityQueue> empty_queue(
- host_impl()->BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+ host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
EXPECT_TRUE(empty_queue->IsEmpty());
std::set<Tile*> all_tiles;
size_t tile_count = 0;
std::unique_ptr<RasterTilePriorityQueue> raster_queue(
- host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL));
+ host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::ALL));
while (!raster_queue->IsEmpty()) {
++tile_count;
EXPECT_TRUE(raster_queue->Top().tile());
@@ -630,7 +753,7 @@
std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
std::unique_ptr<EvictionTilePriorityQueue> queue(
- host_impl()->BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
+ host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY));
EXPECT_FALSE(queue->IsEmpty());
// Sanity check, all tiles should be visible.
@@ -651,32 +774,32 @@
Region invalidation(gfx::Rect(0, 0, 500, 500));
// Invalidate the pending tree.
- pending_layer()->set_invalidation(invalidation);
- pending_layer()->HighResTiling()->Invalidate(invalidation);
- pending_layer()->HighResTiling()->CreateMissingTilesInLiveTilesRect();
- EXPECT_FALSE(pending_layer()->LowResTiling());
+ pending_layer_->set_invalidation(invalidation);
+ pending_layer_->HighResTiling()->Invalidate(invalidation);
+ pending_layer_->HighResTiling()->CreateMissingTilesInLiveTilesRect();
+ EXPECT_FALSE(pending_layer_->LowResTiling());
// Renew all of the tile priorities.
gfx::Rect viewport(50, 50, 100, 100);
- pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+ pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
- active_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+ active_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
// Populate all tiles directly from the tilings.
all_tiles.clear();
std::vector<Tile*> pending_high_res_tiles =
- pending_layer()->HighResTiling()->AllTilesForTesting();
+ pending_layer_->HighResTiling()->AllTilesForTesting();
for (size_t i = 0; i < pending_high_res_tiles.size(); ++i)
all_tiles.insert(pending_high_res_tiles[i]);
std::vector<Tile*> active_high_res_tiles =
- active_layer()->HighResTiling()->AllTilesForTesting();
+ active_layer_->HighResTiling()->AllTilesForTesting();
for (size_t i = 0; i < active_high_res_tiles.size(); ++i)
all_tiles.insert(active_high_res_tiles[i]);
std::vector<Tile*> active_low_res_tiles =
- active_layer()->LowResTiling()->AllTilesForTesting();
+ active_layer_->LowResTiling()->AllTilesForTesting();
for (size_t i = 0; i < active_low_res_tiles.size(); ++i)
all_tiles.insert(active_low_res_tiles[i]);
@@ -687,7 +810,7 @@
smoothness_tiles.clear();
tile_count = 0;
// Here we expect to get increasing combined priority_bin.
- queue = host_impl()->BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
+ queue = host_impl_.BuildEvictionQueue(SMOOTHNESS_TAKES_PRIORITY);
int distance_increasing = 0;
int distance_decreasing = 0;
while (!queue->IsEmpty()) {
@@ -730,7 +853,7 @@
std::set<Tile*> new_content_tiles;
last_tile = PrioritizedTile();
// Again, we expect to get increasing combined priority_bin.
- queue = host_impl()->BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
+ queue = host_impl_.BuildEvictionQueue(NEW_CONTENT_TAKES_PRIORITY);
distance_decreasing = 0;
distance_increasing = 0;
while (!queue->IsEmpty()) {
@@ -771,42 +894,42 @@
TEST_F(TileManagerTilePriorityQueueTest,
EvictionTilePriorityQueueWithOcclusion) {
- host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+ host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
scoped_refptr<FakeRasterSource> pending_raster_source =
FakeRasterSource::CreateFilled(layer_bounds);
SetupPendingTree(pending_raster_source);
std::unique_ptr<FakePictureLayerImpl> pending_child =
- FakePictureLayerImpl::CreateWithRasterSource(host_impl()->pending_tree(),
- 2, pending_raster_source);
- pending_layer()->AddChild(std::move(pending_child));
+ FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
+ pending_raster_source);
+ pending_layer_->AddChild(std::move(pending_child));
FakePictureLayerImpl* pending_child_layer =
- static_cast<FakePictureLayerImpl*>(pending_layer()->children()[0]);
+ static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
pending_child_layer->SetDrawsContent(true);
- host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+ host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
bool update_lcd_text = false;
- host_impl()->pending_tree()->property_trees()->needs_rebuild = true;
- host_impl()->pending_tree()->BuildPropertyTreesForTesting();
- host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+ host_impl_.pending_tree()->property_trees()->needs_rebuild = true;
+ host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+ host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
ActivateTree();
SetupPendingTree(pending_raster_source);
FakePictureLayerImpl* active_child_layer =
- static_cast<FakePictureLayerImpl*>(active_layer()->children()[0]);
+ static_cast<FakePictureLayerImpl*>(active_layer_->children()[0]);
std::set<Tile*> all_tiles;
size_t tile_count = 0;
std::unique_ptr<RasterTilePriorityQueue> raster_queue(
- host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL));
+ host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::ALL));
while (!raster_queue->IsEmpty()) {
++tile_count;
EXPECT_TRUE(raster_queue->Top().tile());
@@ -818,12 +941,12 @@
// Renew all of the tile priorities.
gfx::Rect viewport(layer_bounds);
- pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+ pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
pending_child_layer->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
- active_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+ active_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
active_child_layer->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
@@ -831,7 +954,7 @@
// Populate all tiles directly from the tilings.
all_tiles.clear();
std::vector<Tile*> pending_high_res_tiles =
- pending_layer()->HighResTiling()->AllTilesForTesting();
+ pending_layer_->HighResTiling()->AllTilesForTesting();
all_tiles.insert(pending_high_res_tiles.begin(),
pending_high_res_tiles.end());
@@ -850,7 +973,7 @@
size_t occluded_count = 0u;
PrioritizedTile last_tile;
std::unique_ptr<EvictionTilePriorityQueue> queue(
- host_impl()->BuildEvictionQueue(tree_priority));
+ host_impl_.BuildEvictionQueue(tree_priority));
while (!queue->IsEmpty()) {
PrioritizedTile prioritized_tile = queue->Top();
if (!last_tile.tile())
@@ -886,7 +1009,7 @@
TEST_F(TileManagerTilePriorityQueueTest,
EvictionTilePriorityQueueWithTransparentLayer) {
- host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+ host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
gfx::Size layer_bounds(1000, 1000);
@@ -895,30 +1018,30 @@
SetupPendingTree(pending_raster_source);
std::unique_ptr<FakePictureLayerImpl> pending_child =
- FakePictureLayerImpl::CreateWithRasterSource(host_impl()->pending_tree(),
- 2, pending_raster_source);
+ FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
+ pending_raster_source);
FakePictureLayerImpl* pending_child_layer = pending_child.get();
- pending_layer()->AddChild(std::move(pending_child));
+ pending_layer_->AddChild(std::move(pending_child));
// Create a fully transparent child layer so that its tile priorities are not
// considered to be valid.
pending_child_layer->SetDrawsContent(true);
pending_child_layer->test_properties()->force_render_surface = true;
- host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+ host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
bool update_lcd_text = false;
- host_impl()->pending_tree()->property_trees()->needs_rebuild = true;
- host_impl()->pending_tree()->BuildPropertyTreesForTesting();
- host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+ host_impl_.pending_tree()->property_trees()->needs_rebuild = true;
+ host_impl_.pending_tree()->BuildPropertyTreesForTesting();
+ host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
pending_child_layer->OnOpacityAnimated(0.0);
- host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
- host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
+ host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
+ host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
// Renew all of the tile priorities.
gfx::Rect viewport(layer_bounds);
- pending_layer()->picture_layer_tiling_set()->UpdateTilePriorities(
+ pending_layer_->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
pending_child_layer->picture_layer_tiling_set()->UpdateTilePriorities(
viewport, 1.0f, 1.0, Occlusion(), true);
@@ -926,7 +1049,7 @@
// Populate all tiles directly from the tilings.
std::set<Tile*> all_pending_tiles;
std::vector<Tile*> pending_high_res_tiles =
- pending_layer()->HighResTiling()->AllTilesForTesting();
+ pending_layer_->HighResTiling()->AllTilesForTesting();
all_pending_tiles.insert(pending_high_res_tiles.begin(),
pending_high_res_tiles.end());
EXPECT_EQ(16u, pending_high_res_tiles.size());
@@ -945,7 +1068,7 @@
tile_manager()->InitializeTilesWithResourcesForTesting(
std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
- EXPECT_TRUE(pending_layer()->HasValidTilePriorities());
+ EXPECT_TRUE(pending_layer_->HasValidTilePriorities());
EXPECT_FALSE(pending_child_layer->HasValidTilePriorities());
// Verify that eviction queue returns tiles also from layers without valid
@@ -955,7 +1078,7 @@
std::set<Tile*> new_content_tiles;
size_t tile_count = 0;
std::unique_ptr<EvictionTilePriorityQueue> queue(
- host_impl()->BuildEvictionQueue(tree_priority));
+ host_impl_.BuildEvictionQueue(tree_priority));
while (!queue->IsEmpty()) {
PrioritizedTile prioritized_tile = queue->Top();
Tile* tile = prioritized_tile.tile();
@@ -976,10 +1099,10 @@
TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
@@ -996,16 +1119,15 @@
EXPECT_EQ(16u, tile_count);
for (int i = 1; i < 10; ++i) {
- std::unique_ptr<FakePictureLayerImpl> pending_child_layer =
- FakePictureLayerImpl::Create(host_impl()->pending_tree(),
- layer_id() + i);
- pending_child_layer->SetDrawsContent(true);
- pending_child_layer->set_has_valid_tile_priorities(true);
- pending_layer()->AddChild(std::move(pending_child_layer));
- }
-
- queue = host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL);
+ std::unique_ptr<FakePictureLayerImpl> pending_layer =
+ FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
+ pending_layer->SetDrawsContent(true);
+ pending_layer->set_has_valid_tile_priorities(true);
+ pending_layer_->AddChild(std::move(pending_layer));
+ }
+
+ queue = host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::ALL);
EXPECT_FALSE(queue->IsEmpty());
tile_count = 0;
@@ -1022,12 +1144,12 @@
TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
std::unique_ptr<RasterTilePriorityQueue> raster_queue(
- host_impl()->BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
- RasterTilePriorityQueue::Type::ALL));
+ host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
+ RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(raster_queue->IsEmpty());
size_t tile_count = 0;
@@ -1042,19 +1164,18 @@
EXPECT_EQ(16u, tile_count);
std::vector<Tile*> tiles(all_tiles.begin(), all_tiles.end());
- host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
+ host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
for (int i = 1; i < 10; ++i) {
- std::unique_ptr<FakePictureLayerImpl> pending_child_layer =
- FakePictureLayerImpl::Create(host_impl()->pending_tree(),
- layer_id() + i);
- pending_child_layer->SetDrawsContent(true);
- pending_child_layer->set_has_valid_tile_priorities(true);
- pending_layer()->AddChild(std::move(pending_child_layer));
+ std::unique_ptr<FakePictureLayerImpl> pending_layer =
+ FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
+ pending_layer->SetDrawsContent(true);
+ pending_layer->set_has_valid_tile_priorities(true);
+ pending_layer_->AddChild(std::move(pending_layer));
}
std::unique_ptr<EvictionTilePriorityQueue> queue(
- host_impl()->BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
+ host_impl_.BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
EXPECT_FALSE(queue->IsEmpty());
tile_count = 0;
@@ -1260,87 +1381,87 @@
TEST_F(TileManagerTilePriorityQueueTest, SetIsLikelyToRequireADraw) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
// Verify that the queue has a required for draw tile at Top.
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
EXPECT_TRUE(queue->Top().tile()->required_for_draw());
- EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
- EXPECT_TRUE(host_impl()->is_likely_to_require_a_draw());
+ EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+ host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
+ EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
}
TEST_F(TileManagerTilePriorityQueueTest,
SetIsLikelyToRequireADrawOnZeroMemoryBudget) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
// Verify that the queue has a required for draw tile at Top.
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
EXPECT_TRUE(queue->Top().tile()->required_for_draw());
- ManagedMemoryPolicy policy = host_impl()->ActualManagedMemoryPolicy();
+ ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
policy.bytes_limit_when_visible = 0;
- host_impl()->SetMemoryPolicy(policy);
-
- EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
- EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
+ host_impl_.SetMemoryPolicy(policy);
+
+ EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+ host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
+ EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
}
TEST_F(TileManagerTilePriorityQueueTest,
SetIsLikelyToRequireADrawOnLimitedMemoryBudget) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
// Verify that the queue has a required for draw tile at Top.
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
EXPECT_TRUE(queue->Top().tile()->required_for_draw());
EXPECT_EQ(gfx::Size(256, 256), queue->Top().tile()->desired_texture_size());
- EXPECT_EQ(RGBA_8888, host_impl()->resource_provider()->best_texture_format());
-
- ManagedMemoryPolicy policy = host_impl()->ActualManagedMemoryPolicy();
+ EXPECT_EQ(RGBA_8888, host_impl_.resource_provider()->best_texture_format());
+
+ ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
policy.bytes_limit_when_visible = ResourceUtil::UncheckedSizeInBytes<size_t>(
gfx::Size(256, 256), RGBA_8888);
- host_impl()->SetMemoryPolicy(policy);
-
- EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
- EXPECT_TRUE(host_impl()->is_likely_to_require_a_draw());
-
- Resource* resource = host_impl()->resource_pool()->AcquireResource(
+ host_impl_.SetMemoryPolicy(policy);
+
+ EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+ host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
+ EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
+
+ Resource* resource = host_impl_.resource_pool()->AcquireResource(
gfx::Size(256, 256), RGBA_8888);
- host_impl()->tile_manager()->CheckIfMoreTilesNeedToBePreparedForTesting();
- EXPECT_FALSE(host_impl()->is_likely_to_require_a_draw());
-
- host_impl()->resource_pool()->ReleaseResource(resource, 0);
+ host_impl_.tile_manager()->CheckIfMoreTilesNeedToBePreparedForTesting();
+ EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+
+ host_impl_.resource_pool()->ReleaseResource(resource, 0);
}
TEST_F(TileManagerTilePriorityQueueTest, DefaultMemoryPolicy) {
const gfx::Size layer_bounds(1000, 1000);
- host_impl()->SetViewportSize(layer_bounds);
+ host_impl_.SetViewportSize(layer_bounds);
SetupDefaultTrees(layer_bounds);
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+ host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
// 64MB is the default mem limit.
EXPECT_EQ(67108864u,
- host_impl()->global_tile_state().hard_memory_limit_in_bytes);
+ host_impl_.global_tile_state().hard_memory_limit_in_bytes);
EXPECT_EQ(TileMemoryLimitPolicy::ALLOW_ANYTHING,
- host_impl()->global_tile_state().memory_limit_policy);
+ host_impl_.global_tile_state().memory_limit_policy);
EXPECT_EQ(ManagedMemoryPolicy::kDefaultNumResourcesLimit,
- host_impl()->global_tile_state().num_resources_limit);
+ host_impl_.global_tile_state().num_resources_limit);
}
TEST_F(TileManagerTilePriorityQueueTest, RasterQueueAllUsesCorrectTileBounds) {
@@ -1431,7 +1552,7 @@
tiling_client.SetTileSize(size);
std::unique_ptr<PictureLayerImpl> layer_impl =
- PictureLayerImpl::Create(host_impl()->active_tree(), 1, false);
+ PictureLayerImpl::Create(host_impl_.active_tree(), 1, false);
layer_impl->set_is_drawn_render_surface_layer_list_member(true);
PictureLayerTilingSet* tiling_set = layer_impl->picture_layer_tiling_set();
@@ -1444,7 +1565,7 @@
gfx::Rect(layer_bounds), // Soon rect.
gfx::Rect(layer_bounds)); // Eventually rect.
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+ host_impl_.tile_manager()->PrepareTiles(host_impl_.global_tile_state());
std::vector<Tile*> tiles = tiling->AllTilesForTesting();
for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
@@ -1461,47 +1582,113 @@
}
}
-class TileManagerTest : public TestLayerTreeHostBase {
+// TODO(vmpstr): Merge TileManagerTest and TileManagerTilePriorityQueueTest.
+class TileManagerTest : public testing::Test {
public:
+ void SetUp() override {
+ LayerTreeSettings settings;
+ settings.verify_clip_tree_calculations = true;
+
+ CustomizeSettings(&settings);
+ output_surface_ = GetOutputSurface();
+ task_graph_runner_ = GetTaskGraphRunner();
+ host_impl_.reset(new MockLayerTreeHostImpl(settings, &task_runner_provider_,
+ &shared_bitmap_manager_,
+ task_graph_runner_.get()));
+ host_impl_->SetVisible(true);
+ host_impl_->InitializeRenderer(output_surface_.get());
+ }
+
+ void SetupDefaultTrees(const gfx::Size& layer_bounds) {
+ scoped_refptr<FakeRasterSource> pending_raster_source =
+ FakeRasterSource::CreateFilled(layer_bounds);
+ scoped_refptr<FakeRasterSource> active_raster_source =
+ FakeRasterSource::CreateFilled(layer_bounds);
+
+ SetupTrees(pending_raster_source, active_raster_source);
+ }
+
+ // This matches picture_layer_impl_unittest's ActivateTree.
+ void ActivateTree() {
+ host_impl_->ActivateSyncTree();
+ CHECK(!host_impl_->pending_tree());
+ bool update_lcd_text = false;
+ host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+ }
+
+ void SetupTrees(scoped_refptr<RasterSource> pending_raster_source,
+ scoped_refptr<RasterSource> active_raster_source) {
+ SetupPendingTree(active_raster_source);
+ ActivateTree();
+ SetupPendingTree(pending_raster_source);
+ }
+
+ void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
+ host_impl_->CreatePendingTree();
+ LayerTreeImpl* pending_tree = host_impl_->pending_tree();
+
+ // Steal from the recycled tree.
+ LayerImpl* old_pending_root = pending_tree->root_layer();
+ FakePictureLayerImpl* pending_layer = nullptr;
+ if (old_pending_root) {
+ pending_layer = static_cast<FakePictureLayerImpl*>(old_pending_root);
+ pending_layer->SetRasterSourceOnPending(raster_source, Region());
+ } else {
+ int id = 7;
+ std::unique_ptr<FakePictureLayerImpl> new_root =
+ FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id,
+ raster_source);
+ pending_layer = new_root.get();
+ pending_layer->SetDrawsContent(true);
+ pending_layer->SetHasRenderSurface(true);
+ pending_tree->SetRootLayer(std::move(new_root));
+ }
+
+ // The bounds() just mirror the raster source size.
+ pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
+
+ // Add tilings/tiles for the layer.
+ bool update_lcd_text = false;
+ host_impl_->pending_tree()->BuildPropertyTreesForTesting();
+ host_impl_->pending_tree()->UpdateDrawProperties(update_lcd_text);
+ }
+
+ protected:
// MockLayerTreeHostImpl allows us to intercept tile manager callbacks.
class MockLayerTreeHostImpl : public FakeLayerTreeHostImpl {
public:
- MockLayerTreeHostImpl(
- const LayerTreeSettings& settings,
- TaskRunnerProvider* task_runner_provider,
- SharedBitmapManager* manager,
- TaskGraphRunner* task_graph_runner,
- gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager)
+ MockLayerTreeHostImpl(const LayerTreeSettings& settings,
+ TaskRunnerProvider* task_runner_provider,
+ SharedBitmapManager* manager,
+ TaskGraphRunner* task_graph_runner)
: FakeLayerTreeHostImpl(settings,
task_runner_provider,
manager,
- task_graph_runner,
- gpu_memory_buffer_manager) {}
+ task_graph_runner) {}
MOCK_METHOD0(NotifyAllTileTasksCompleted, void());
MOCK_METHOD0(NotifyReadyToDraw, void());
};
- std::unique_ptr<FakeLayerTreeHostImpl> CreateHostImpl(
- const LayerTreeSettings& settings,
- TaskRunnerProvider* task_runner_provider,
- SharedBitmapManager* shared_bitmap_manager,
- TaskGraphRunner* task_graph_runner,
- gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) override {
- return base::WrapUnique(new MockLayerTreeHostImpl(
- settings, task_runner_provider, shared_bitmap_manager,
- task_graph_runner, gpu_memory_buffer_manager));
+ // By default do no customization.
+ virtual void CustomizeSettings(LayerTreeSettings* settings) {}
+
+ // By default use TestTaskGraphRunner.
+ virtual std::unique_ptr<TaskGraphRunner> GetTaskGraphRunner() const {
+ return base::WrapUnique(new TestTaskGraphRunner());
}
// By default use SoftwareOutputSurface.
- std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+ virtual std::unique_ptr<OutputSurface> GetOutputSurface() const {
return FakeOutputSurface::CreateSoftware(
base::WrapUnique(new SoftwareOutputDevice));
}
- MockLayerTreeHostImpl& MockHostImpl() {
- return *static_cast<MockLayerTreeHostImpl*>(host_impl());
- }
+ TestSharedBitmapManager shared_bitmap_manager_;
+ std::unique_ptr<TaskGraphRunner> task_graph_runner_;
+ FakeImplTaskRunnerProvider task_runner_provider_;
+ std::unique_ptr<OutputSurface> output_surface_;
+ std::unique_ptr<MockLayerTreeHostImpl> host_impl_;
};
// Test to ensure that we call NotifyAllTileTasksCompleted when PrepareTiles is
@@ -1510,12 +1697,11 @@
// Check with no tile work enqueued.
{
base::RunLoop run_loop;
- EXPECT_FALSE(
- host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
- EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+ EXPECT_FALSE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
+ EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
.WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
- EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+ host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
+ EXPECT_TRUE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
run_loop.Run();
}
@@ -1523,13 +1709,12 @@
// callback.
{
base::RunLoop run_loop;
- EXPECT_FALSE(
- host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
- EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+ EXPECT_FALSE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
+ EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
.WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
- host_impl()->tile_manager()->SetMoreTilesNeedToBeRasterizedForTesting();
- EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+ host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
+ host_impl_->tile_manager()->SetMoreTilesNeedToBeRasterizedForTesting();
+ EXPECT_TRUE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
run_loop.Run();
}
}
@@ -1537,35 +1722,34 @@
TEST_F(TileManagerTest, ActivateAndDrawWhenOOM) {
SetupDefaultTrees(gfx::Size(1000, 1000));
- auto global_state = host_impl()->global_tile_state();
+ auto global_state = host_impl_->global_tile_state();
global_state.hard_memory_limit_in_bytes = 1u;
global_state.soft_memory_limit_in_bytes = 1u;
{
base::RunLoop run_loop;
- EXPECT_FALSE(
- host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
- EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+ EXPECT_FALSE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
+ EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
.WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
- host_impl()->tile_manager()->PrepareTiles(global_state);
- EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+ host_impl_->tile_manager()->PrepareTiles(global_state);
+ EXPECT_TRUE(host_impl_->tile_manager()->HasScheduledTileTasksForTesting());
run_loop.Run();
}
- EXPECT_TRUE(host_impl()->tile_manager()->IsReadyToDraw());
- EXPECT_TRUE(host_impl()->tile_manager()->IsReadyToActivate());
- EXPECT_TRUE(host_impl()->notify_tile_state_changed_called());
+ EXPECT_TRUE(host_impl_->tile_manager()->IsReadyToDraw());
+ EXPECT_TRUE(host_impl_->tile_manager()->IsReadyToActivate());
+ EXPECT_TRUE(host_impl_->notify_tile_state_changed_called());
// Next PrepareTiles should skip NotifyTileStateChanged since all tiles
// are marked oom already.
{
base::RunLoop run_loop;
- host_impl()->set_notify_tile_state_changed_called(false);
- EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+ host_impl_->set_notify_tile_state_changed_called(false);
+ EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
.WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
- host_impl()->tile_manager()->PrepareTiles(global_state);
+ host_impl_->tile_manager()->PrepareTiles(global_state);
run_loop.Run();
- EXPECT_FALSE(host_impl()->notify_tile_state_changed_called());
+ EXPECT_FALSE(host_impl_->notify_tile_state_changed_called());
}
}
@@ -1600,7 +1784,7 @@
tiling_client.SetTileSize(size);
std::unique_ptr<PictureLayerImpl> layer =
- PictureLayerImpl::Create(host_impl()->active_tree(), 1, false);
+ PictureLayerImpl::Create(host_impl_->active_tree(), 1, false);
PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
layer->set_is_drawn_render_surface_layer_list_member(true);
@@ -1615,14 +1799,14 @@
// SMOOTHNESS_TAKES_PRIORITY ensures that we will actually raster
// LOW_RESOLUTION tiles, otherwise they are skipped.
- host_impl()->SetTreePriority(SMOOTHNESS_TAKES_PRIORITY);
+ host_impl_->SetTreePriority(SMOOTHNESS_TAKES_PRIORITY);
// Call PrepareTiles and wait for it to complete.
- auto* tile_manager = host_impl()->tile_manager();
+ auto* tile_manager = host_impl_->tile_manager();
base::RunLoop run_loop;
- EXPECT_CALL(MockHostImpl(), NotifyAllTileTasksCompleted())
+ EXPECT_CALL(*host_impl_, NotifyAllTileTasksCompleted())
.WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
- tile_manager->PrepareTiles(host_impl()->global_tile_state());
+ tile_manager->PrepareTiles(host_impl_->global_tile_state());
run_loop.Run();
tile_manager->Flush();
@@ -1632,7 +1816,7 @@
EXPECT_TRUE(tile->draw_info().IsReadyToDraw());
ResourceProvider::ScopedReadLockSoftware lock(
- host_impl()->resource_provider(), tile->draw_info().resource_id());
+ host_impl_->resource_provider(), tile->draw_info().resource_id());
const SkBitmap* bitmap = lock.sk_bitmap();
for (int x = 0; x < size.width(); ++x) {
for (int y = 0; y < size.height(); ++y) {
@@ -1655,18 +1839,20 @@
class ActivationTasksDoNotBlockReadyToDrawTest : public TileManagerTest {
protected:
- std::unique_ptr<TaskGraphRunner> CreateTaskGraphRunner() override {
+ std::unique_ptr<TaskGraphRunner> GetTaskGraphRunner() const override {
return base::WrapUnique(new SynchronousTaskGraphRunner());
}
- std::unique_ptr<OutputSurface> CreateOutputSurface() override {
+ std::unique_ptr<OutputSurface> GetOutputSurface() const override {
return FakeOutputSurface::Create3d();
}
- LayerTreeSettings CreateSettings() override {
- LayerTreeSettings settings = TileManagerTest::CreateSettings();
- settings.gpu_rasterization_forced = true;
- return settings;
+ void CustomizeSettings(LayerTreeSettings* settings) override {
+ settings->gpu_rasterization_forced = true;
+ }
+
+ SynchronousTaskGraphRunner* GetSynchronousTaskGraphRunner() const {
+ return static_cast<SynchronousTaskGraphRunner*>(task_graph_runner_.get());
}
};
@@ -1674,7 +1860,7 @@
ActivationTasksDoNotBlockReadyToDraw) {
const gfx::Size layer_bounds(1000, 1000);
- EXPECT_TRUE(host_impl()->use_gpu_rasterization());
+ EXPECT_TRUE(host_impl_->use_gpu_rasterization());
// Active tree has no non-solid tiles, so it will generate no tile tasks.
std::unique_ptr<FakeRecordingSource> active_tree_recording_source =
@@ -1707,15 +1893,14 @@
pending_tree_recording_source.get(), false);
SetupTrees(pending_tree_raster_source, active_tree_raster_source);
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+ host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
// The first task to run should be ReadyToDraw (this should not be blocked by
// the tasks required for activation).
base::RunLoop run_loop;
- EXPECT_CALL(MockHostImpl(), NotifyReadyToDraw())
+ EXPECT_CALL(*host_impl_, NotifyReadyToDraw())
.WillOnce(testing::Invoke([&run_loop]() { run_loop.Quit(); }));
- static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())
- ->RunSingleTaskForTesting();
+ GetSynchronousTaskGraphRunner()->RunSingleTaskForTesting();
run_loop.Run();
}
@@ -1738,10 +1923,8 @@
class PartialRasterTileManagerTest : public TileManagerTest {
public:
- LayerTreeSettings CreateSettings() override {
- LayerTreeSettings settings = TileManagerTest::CreateSettings();
- settings.use_partial_raster = true;
- return settings;
+ void CustomizeSettings(LayerTreeSettings* settings) override {
+ settings->use_partial_raster = true;
}
};
@@ -1751,7 +1934,7 @@
// Create a CancellingTaskRunner and set it on the tile manager so that all
// scheduled work is immediately cancelled.
CancellingTileTaskManager cancelling_task_manager;
- host_impl()->tile_manager()->SetTileTaskManagerForTesting(
+ host_impl_->tile_manager()->SetTileTaskManagerForTesting(
&cancelling_task_manager);
// Pick arbitrary IDs - they don't really matter as long as they're constant.
@@ -1761,8 +1944,8 @@
scoped_refptr<FakeRasterSource> pending_raster_source =
FakeRasterSource::CreateFilled(kTileSize);
- host_impl()->CreatePendingTree();
- LayerTreeImpl* pending_tree = host_impl()->pending_tree();
+ host_impl_->CreatePendingTree();
+ LayerTreeImpl* pending_tree = host_impl_->pending_tree();
// Steal from the recycled tree.
std::unique_ptr<FakePictureLayerImpl> pending_layer =
@@ -1776,29 +1959,28 @@
pending_tree->SetRootLayer(std::move(pending_layer));
// Add tilings/tiles for the layer.
- host_impl()->pending_tree()->BuildPropertyTreesForTesting();
- host_impl()->pending_tree()->UpdateDrawProperties(
- false /* update_lcd_text */);
+ host_impl_->pending_tree()->BuildPropertyTreesForTesting();
+ host_impl_->pending_tree()->UpdateDrawProperties(false /* update_lcd_text */);
// Build the raster queue and invalidate the top tile.
- std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
+ std::unique_ptr<RasterTilePriorityQueue> queue(host_impl_->BuildRasterQueue(
SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
EXPECT_FALSE(queue->IsEmpty());
queue->Top().tile()->SetInvalidated(gfx::Rect(), kInvalidatedId);
// PrepareTiles to schedule tasks. Due to the CancellingTileTaskManager,
// these tasks will immediately be canceled.
- host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+ host_impl_->tile_manager()->PrepareTiles(host_impl_->global_tile_state());
// Make sure that the tile we invalidated above was not returned to the pool
// with its invalidated resource ID.
- host_impl()->resource_pool()->CheckBusyResources();
- EXPECT_FALSE(host_impl()->resource_pool()->TryAcquireResourceWithContentId(
+ host_impl_->resource_pool()->CheckBusyResources();
+ EXPECT_FALSE(host_impl_->resource_pool()->TryAcquireResourceWithContentId(
kInvalidatedId));
// Free our host_impl_ before the cancelling_task_manager we passed it, as it
// will use that class in clean up.
- TakeHostImpl();
+ host_impl_ = nullptr;
}
// FakeRasterBufferProviderImpl that verifies the resource content ID of raster
@@ -1906,13 +2088,15 @@
// Ensures that the tile manager successfully reuses tiles when partial
// raster is enabled.
TEST_F(PartialRasterTileManagerTest, PartialRasterSuccessfullyEnabled) {
- RunPartialRasterCheck(TakeHostImpl(), true /* partial_raster_enabled */);
+ RunPartialRasterCheck(std::move(host_impl_),
+ true /* partial_raster_enabled */);
}
// Ensures that the tile manager does not attempt to reuse tiles when partial
// raster is disabled.
TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
- RunPartialRasterCheck(TakeHostImpl(), false /* partial_raster_enabled */);
+ RunPartialRasterCheck(std::move(host_impl_),
+ false /* partial_raster_enabled */);
}
} // namespace
« no previous file with comments | « cc/tiles/tile_manager_perftest.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698