cc: Make sure to issue IsReadyToDraw when we're out of memory.

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 "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/playback/display_list_raster_source.h"
 #include "cc/playback/display_list_recording_source.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/resources/resource_pool.h"
@@ skipping 1430 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());
   }
 }
 
+// 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 {
     LayerTreeSettings settings;
     CustomizeSettings(&settings);
     host_impl_.reset(new MockLayerTreeHostImpl(settings, &task_runner_provider_,
                                                &shared_bitmap_manager_,
                                                &task_graph_runner_));
     host_impl_->SetVisible(true);
     host_impl_->InitializeRenderer(output_surface_.get());
   }
 
+  void SetupDefaultTrees(const gfx::Size& layer_bounds) {
+    scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
+        FakeDisplayListRasterSource::CreateFilled(layer_bounds);
+    scoped_refptr<FakeDisplayListRasterSource> active_raster_source =
+        FakeDisplayListRasterSource::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<DisplayListRasterSource> pending_raster_source,
+                  scoped_refptr<DisplayListRasterSource> active_raster_source) {
+    SetupPendingTree(active_raster_source);
+    ActivateTree();
+    SetupPendingTree(pending_raster_source);
+  }
+
+  void SetupPendingTree(scoped_refptr<DisplayListRasterSource> raster_source) {
+    host_impl_->CreatePendingTree();
+    LayerTreeImpl* pending_tree = host_impl_->pending_tree();
+
+    // Steal from the recycled tree.
+    scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
+    scoped_ptr<FakePictureLayerImpl> pending_layer;
+    if (old_pending_root) {
+      pending_layer.reset(
+          static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
+      pending_layer->SetRasterSourceOnPending(raster_source, Region());
+    } else {
+      int id = 7;
+      pending_layer = FakePictureLayerImpl::CreateWithRasterSource(
+          pending_tree, id, raster_source);
+      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_tree->SetRootLayer(pending_layer.Pass());
+
+    // 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)
         : FakeLayerTreeHostImpl(settings,
                                 task_runner_provider,
@@ skipping 34 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) {
+  SetupDefaultTrees(gfx::Size(1000, 1000));
+
+  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(*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();
+
+  EXPECT_TRUE(host_impl_->tile_manager()->IsReadyToDraw());
+  EXPECT_TRUE(host_impl_->tile_manager()->IsReadyToActivate());
+}
+
 TEST_F(TileManagerTest, LowResHasNoImage) {
   gfx::Size size(10, 12);
   TileResolution resolutions[] = {HIGH_RESOLUTION, LOW_RESOLUTION};
 
   for (size_t i = 0; i < arraysize(resolutions); ++i) {
     SCOPED_TRACE(resolutions[i]);
 
     // Make a DisplayListRasterSource that will draw a blue bitmap image.
     skia::RefPtr<SkSurface> surface = skia::AdoptRef(
         SkSurface::NewRasterN32Premul(size.width(), size.height()));
@@ skipping 272 matching lines @@
 }
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
   RunPartialRasterCheck(host_impl_.Pass(), false /* partial_raster_enabled */);
 }
 
 }  // namespace
 }  // namespace cc