cc: Fix memory limit edge cases for SetIsLikelyToRequireADraw.

cc/resources/tile_manager_unittest.cc

 // 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/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/raster_tile_priority_queue.h"
+#include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/resources/tiling_set_raster_queue_all.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
@@ skipping 1275 matching lines @@
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top()->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());
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
-       NoSetIsLikelyToRequireADrawOnZeroMemoryBudget) {
+       SetIsLikelyToRequireADrawOnZeroMemoryBudget) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(layer_bounds);
   SetupDefaultTrees(layer_bounds);
 
   // Verify that the queue has a required for draw tile at Top.
   scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
       SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
   EXPECT_FALSE(queue->IsEmpty());
   EXPECT_TRUE(queue->Top()->required_for_draw());
 
   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());
 }
 
+TEST_F(TileManagerTilePriorityQueueTest,
+       SetIsLikelyToRequireADrawOnLimitedMemoryBudget) {
+  const gfx::Size layer_bounds(1000, 1000);
+  host_impl_.SetViewportSize(layer_bounds);
+  SetupDefaultTrees(layer_bounds);
+
+  // Verify that the queue has a required for draw tile at Top.
+  scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+      SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+  EXPECT_FALSE(queue->IsEmpty());
+  EXPECT_TRUE(queue->Top()->required_for_draw());
+  EXPECT_EQ(queue->Top()->desired_texture_size(), gfx::Size(256, 256));
+  EXPECT_EQ(host_impl_.tile_manager()
+                ->TileTaskRunnerForTesting()

[vmpstr, 2015/03/27 17:23:28]

This is kind of an overkill to get the tile task runner from tile manager just
to check the resource format... Is there another way to get this or is this the
best place?

[sunnyps, 2015/03/27 18:38:04]

Done. Using ResourceProvider::best_texture_format for this. The intent here is
to communicate what the numbers mean if the test ever breaks.

+                ->GetResourceFormat(),
+            RGBA_8888);
+
+  ManagedMemoryPolicy policy = host_impl_.ActualManagedMemoryPolicy();
+  policy.bytes_limit_when_visible = 256 * 256 * 4;
+  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());
+
+  scoped_ptr<ScopedResource> 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.Pass());
+}
+
+TEST_F(TileManagerTilePriorityQueueTest,
+       SetIsLikelyToRequireADrawOnSynchronousRaster) {
+  const gfx::Size layer_bounds(1000, 1000);
+  host_impl_.SetViewportSize(layer_bounds);
+  host_impl_.SetUseGpuRasterization(true);
+  EXPECT_EQ(host_impl_.rasterizer()->GetPrepareTilesMode(),
+            PrepareTilesMode::PREPARE_NONE);
+  SetupDefaultTrees(layer_bounds);
+
+  // Verify that the queue has a required for draw tile at Top.
+  scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+      SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+  EXPECT_FALSE(queue->IsEmpty());
+  EXPECT_TRUE(queue->Top()->required_for_draw());
+
+  host_impl_.SetIsLikelyToRequireADraw(true);
+
+  EXPECT_TRUE(host_impl_.is_likely_to_require_a_draw());
+  host_impl_.tile_manager()->UpdateVisibleTiles(host_impl_.global_tile_state());
+  EXPECT_FALSE(host_impl_.is_likely_to_require_a_draw());
+}
+
 }  // namespace
 }  // namespace cc