cc: Activate when going invisible.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 5005 matching lines @@
   int num_draws_;
   const gfx::Size bounds_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayerWithUpdateTracking> content_layer_;
   scoped_refptr<FakePictureLayer> picture_layer_;
   Layer* child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousPainting);
 
-class LayerTreeHostTestInvisibleDoesntActivate : public LayerTreeHostTest {
+class LayerTreeHostTestActivateOnInvisible : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestInvisibleDoesntActivate() : activation_count_(0) {}
+  LayerTreeHostTestActivateOnInvisible()
+      : activation_count_(0), visible_(true) {}
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->impl_side_painting = true;
   }
 
-  virtual void SetupTree() OVERRIDE {
-    scoped_refptr<Layer> root_layer = Layer::Create();
-    root_layer->SetBounds(gfx::Size(1000, 1000));
-
-    // Set up a non-solid layer with a bunch of tiles.
-    client_.set_fill_with_nonsolid_color(true);
-    picture_layer_ = FakePictureLayer::Create(&client_);
-    picture_layer_->SetBounds(gfx::Size(1000, 1000));
-    picture_layer_->SetIsDrawable(true);
-    picture_layer_->SetNeedsDisplayRect(gfx::Rect(1000, 1000));
-    root_layer->AddChild(picture_layer_.get());
-
-    layer_tree_host()->SetRootLayer(root_layer);
-    LayerTreeHostTest::SetupTree();
-  }
-
   virtual void BeginTest() OVERRIDE {
     // Kick off the test with a commit.
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    // Make sure we don't activate before going invisible.
+    // Make sure we don't activate using the notify signal from tile manager.
     host_impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   virtual void DidCommit() OVERRIDE { layer_tree_host()->SetVisible(false); }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
                                        bool visible) OVERRIDE {
+    visible_ = visible;
+
     // Once invisible, we can go visible again.
     if (!visible) {
-      // Allow activation from now on.
-      host_impl->BlockNotifyReadyToActivateForTesting(false);
       PostSetVisibleToMainThread(true);
+    } else {
+      EndTest();
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     ++activation_count_;

[danakj, 2014/09/25 18:38:32]

can you test that RequiresHighRes was true when we became visible? Also, is it
racey or can you guarantee we'll activate before visible happens and we
SetRequiresHighRes? Or test that resource tiles are used here not checkerboards?

There should be a scheduler unit test of some sort too.

[danakj, 2014/09/25 18:40:27]

Maybe the scheduler test could demonstrate that it's not racey and it'll always
do the activate before making things visible again?

[vmpstr, 2014/09/25 19:42:12]

The activation with this change happens as a part of becoming not visible, so
it's not racey. I will test for RequiresHighRes though.

(and I'll do a scheduler test)

-    std::vector<Tile*> tiles = host_impl->tile_manager()->AllTilesForTesting();
-    EXPECT_GT(tiles.size(), 0u);
-    // When activating, ensure that all tiles are ready to draw with a mode
-    // other than rasterize on demand.
-    int resource_tiles_count = 0;
-    for (std::vector<Tile*>::iterator it = tiles.begin(); it != tiles.end();
-         ++it) {
-      Tile* tile = *it;
-      const ManagedTileState::TileVersion& tile_version =
-          tile->GetTileVersionForDrawing();
-      EXPECT_TRUE(tile_version.IsReadyToDraw());
-      EXPECT_NE(ManagedTileState::TileVersion::PICTURE_PILE_MODE,
-                tile_version.mode());
-      resource_tiles_count +=
-          tile_version.mode() == ManagedTileState::TileVersion::RESOURCE_MODE;
-    }
-    EXPECT_GT(resource_tiles_count, 0);
-
-    EndTest();
+    EXPECT_FALSE(visible_);
   }
 
   virtual void AfterTest() OVERRIDE {
-    // Double check that we activated once.
+    // Ensure we activated even though the signal was blocked.
     EXPECT_EQ(1, activation_count_);
+    EXPECT_TRUE(visible_);
   }
 
  private:
   int activation_count_;
+  bool visible_;
 
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> picture_layer_;
 };
 
 // TODO(vmpstr): Enable with single thread impl-side painting.
-MULTI_THREAD_TEST_F(LayerTreeHostTestInvisibleDoesntActivate);
+MULTI_THREAD_TEST_F(LayerTreeHostTestActivateOnInvisible);
 
 }  // namespace cc