cc: Do solid color analysis before scheduling tiles.

cc/tiles/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 <stddef.h>
 #include <stdint.h>
 
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/playback/display_list_raster_source.h"
@@ skipping 1434 matching lines @@
         non_intersecting_rect,  // Visible rect.
         non_intersecting_rect,  // Skewport rect.
         non_intersecting_rect,  // Soon rect.
         intersecting_rect);     // Eventually rect.
     scoped_ptr<TilingSetRasterQueueAll> queue(
         new TilingSetRasterQueueAll(tiling_set.get(), false));
     EXPECT_FALSE(queue->IsEmpty());
   }
 }
 
+TEST_F(TileManagerTilePriorityQueueTest, NoRasterTasksforSolidColorTiles) {
+  gfx::Size size(10, 10);
+  const gfx::Size layer_bounds(10, 10);
+
+  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(layer_bounds);
+
+  SkPaint solid_paint;
+  SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
+  solid_paint.setColor(solid_color);
+  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
+                                             solid_paint);
+  recording_source->Rerecord();
+
+  scoped_refptr<DisplayListRasterSource> raster_source =
+      DisplayListRasterSource::CreateFromDisplayListRecordingSource(
+          recording_source.get(), false);
+
+  FakePictureLayerTilingClient tiling_client;
+  tiling_client.SetTileSize(size);
+
+  scoped_ptr<PictureLayerImpl> layer_impl =
+      PictureLayerImpl::Create(host_impl_.active_tree(), 1, false, nullptr);
+  PictureLayerTilingSet* tiling_set = layer_impl->picture_layer_tiling_set();
+
+  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  tiling->set_resolution(HIGH_RESOLUTION);
+  tiling->CreateAllTilesForTesting();
+  tiling->SetTilePriorityRectsForTesting(gfx::Rect(size),   // Visible rect.
+                                         gfx::Rect(size),   // Skewport rect.
+                                         gfx::Rect(size),   // Soon rect.
+                                         gfx::Rect(size));  // Eventually rect.
+
+  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) {
+    Tile* tile = tiles[tile_idx];
+    EXPECT_FALSE(tile->HasRasterTask());
+    EXPECT_EQ(TileDrawInfo::SOLID_COLOR_MODE, tile->draw_info().mode());
+    EXPECT_EQ(solid_color, tile->draw_info().solid_color());
+  }
+}
+
 // TODO(vmpstr): Merge TileManagerTest and TileManagerTilePriorityQueueTest.
 class TileManagerTest : public testing::Test {
  public:
   TileManagerTest()
       : output_surface_(FakeOutputSurface::CreateSoftware(
             make_scoped_ptr(new SoftwareOutputDevice))) {}
 
   void SetUp() override {
     LayerTreeSettingsForTesting settings;
     CustomizeSettings(&settings);
@@ skipping 103 matching lines @@
     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());
     run_loop.Run();
   }
 }
 
 TEST_F(TileManagerTest, ActivateAndDrawWhenOOM) {

[vmpstr, 2016/01/07 22:36:02]

It's actually kind of nice that this fails now, since solid color tiles don't
cause OOM anymore (they don't require memory). Before, we would have to create
resources before even figuring out whether tiles were solid.

[sohanjg, 2016/01/08 11:47:56]

OK. i will remove these changes to draw a non-solid src. As we are now notifying
tile state changed while skipping solid color, this will not fail anymore. 

-  SetupDefaultTrees(gfx::Size(1000, 1000));
+  gfx::Size size(10, 10);
+  const gfx::Size layer_bounds(10, 10);
 
   auto global_state = host_impl_->global_tile_state();
   global_state.hard_memory_limit_in_bytes = 1u;
   global_state.soft_memory_limit_in_bytes = 1u;
 
+  scoped_ptr<FakeDisplayListRecordingSource> recording_source =
+      FakeDisplayListRecordingSource::CreateFilledRecordingSource(layer_bounds);
+
+  SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
+  SkPaint non_solid_paint;
+  non_solid_paint.setColor(non_solid_color);
+  recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds),
+                                             non_solid_paint);
+  recording_source->Rerecord();
+
+  scoped_refptr<DisplayListRasterSource> raster_source =
+      DisplayListRasterSource::CreateFromDisplayListRecordingSource(
+          recording_source.get(), false);
+
+  FakePictureLayerTilingClient tiling_client;
+  tiling_client.SetTileSize(size);
+
+  scoped_ptr<PictureLayerImpl> layer =
+      PictureLayerImpl::Create(host_impl_->active_tree(), 1, false, nullptr);
+  PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
+
+  auto* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  tiling->set_resolution(HIGH_RESOLUTION);
+  tiling->CreateAllTilesForTesting();
+  tiling->SetTilePriorityRectsForTesting(gfx::Rect(size),   // Visible rect.
+                                         gfx::Rect(size),   // Skewport rect.
+                                         gfx::Rect(size),   // Soon rect.
+                                         gfx::Rect(size));  // Eventually rect.
+
   {
     base::RunLoop run_loop;
     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());
     run_loop.Run();
   }
 
@@ skipping 301 matching lines @@
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
   RunPartialRasterCheck(std::move(host_impl_),
                         false /* partial_raster_enabled */);
 }
 
 }  // namespace
 }  // namespace cc