cc: Some tests for LayerTreeHost SetVisible, SetNeedsRedraw and SetViewportSize

These tests describe what happens when the SetVisible,
SetNeedsRedraw, and SetViewportSize methods on LayerTreeHost
are used by the embedder.

R=enne, jbauman
BUG=

Review URL: https://chromiumcodereview.appspot.com/23514022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@221053 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 229 insertions, 5 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index 17a0c1c..16d4770 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -288,13 +288,13 @@ void DelegatedRendererLayerImpl::AppendQuads(
   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
 
-  // If the index of the EenderPassId is 0, then it is a RenderPass generated
-  // for a layer in this compositor, not the delegated renderer. Then we want to
-  // merge our root RenderPass with the target RenderPass. Otherwise, it is some
-  // RenderPass which we added from the delegated renderer.
+  // If the index of the RenderPassId is 0, then it is a RenderPass generated
+  // for a layer in this compositor, not the delegating renderer. Then we want
+  // to merge our root RenderPass with the target RenderPass. Otherwise, it is
+  // some RenderPass which we added from the delegating renderer.
   bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
   if (should_merge_root_render_pass_with_target) {
-    // Verify that the RenderPass we are appending to is created our
+    // Verify that the RenderPass we are appending to is created by our
     // render_target.
     DCHECK(target_render_pass_id.layer_id == render_target()->id());
 
diff --git a/cc/trees/layer_tree_host_unittest_damage.cc b/cc/trees/layer_tree_host_unittest_damage.cc
index e53dc2e..9c61b11 100644
--- a/cc/trees/layer_tree_host_unittest_damage.cc
+++ b/cc/trees/layer_tree_host_unittest_damage.cc
@@ -4,6 +4,11 @@
 
 #include "cc/trees/layer_tree_host.h"
 
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/time/time.h"
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_painted_scrollbar_layer.h"
@@ -17,6 +22,225 @@ namespace {
 // These tests deal with damage tracking.
 class LayerTreeHostDamageTest : public LayerTreeTest {};
 
+// Changing visibility alone does not cause drawing.
+class LayerTreeHostDamageTestSetVisibleDoesNotDraw
+    : public LayerTreeHostDamageTest {
+  virtual void BeginTest() OVERRIDE {
+    step_ = 0;
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void SetupTree() OVERRIDE {
+    // Viewport is 10x10.
+    scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
+    root->SetBounds(gfx::Size(10, 10));
+
+    layer_tree_host()->SetRootLayer(root);
+    LayerTreeHostDamageTest::SetupTree();
+  }
+
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* impl,
+                                     LayerTreeHostImpl::FrameData* frame_data,
+                                     bool result) OVERRIDE {
+    EXPECT_TRUE(result);
+
+    RenderSurfaceImpl* root_surface =
+        impl->active_tree()->root_layer()->render_surface();
+    gfx::RectF root_damage =
+        root_surface->damage_tracker()->current_damage_rect();
+
+    switch (step_) {
+      case 0:
+        // The first frame has full damage.
+        EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+
+        // No evictions when we become not-visible.
+        impl->SetMemoryPolicy(ManagedMemoryPolicy(
+            1000 * 1000 * 1000,
+            ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
+            1000 * 1000 * 1000,
+            ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
+            ManagedMemoryPolicy::kDefaultNumResourcesLimit));
+
+        PostSetVisibleToMainThread(false);
+        break;
+      case 1:
+        // The compositor has been set not-visible.
+        EXPECT_FALSE(impl->visible());
+        // This frame not visible, so not drawn.
+        NOTREACHED();
+        break;
+      case 2:
+        // The compositor has been set visible again.
+        EXPECT_TRUE(impl->visible());
+        // But it still does not draw.
+        NOTREACHED();
+        break;
+      case 3:
+        // Finally we force a draw, but it will have no damage.
+        EXPECT_EQ(gfx::RectF().ToString(), root_damage.ToString());
+        EndTest();
+        break;
+      case 4:
+        NOTREACHED();
+    }
+    return result;
+  }
+
+  virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* impl,
+                                       bool visible) OVERRIDE {
+    if (!visible) {
+      EXPECT_EQ(0, step_);
+      PostSetVisibleToMainThread(true);
+    } else {
+      EXPECT_EQ(1, step_);
+
+      base::MessageLoopProxy::current()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&LayerTreeHostDamageTestSetVisibleDoesNotDraw::Redraw,
+                     base::Unretained(this),
+                     impl),
+          base::TimeDelta::FromMilliseconds(10));
+    }
+    ++step_;
+  }
+
+  void Redraw(LayerTreeHostImpl* impl) {
+    EXPECT_EQ(2, step_);
+    impl->SetNeedsRedraw();
+    ++step_;
+  }
+
+  virtual void AfterTest() OVERRIDE {}
+
+  int step_;
+  FakeContentLayerClient client_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetVisibleDoesNotDraw);
+
+// LayerTreeHost::SetNeedsRedraw should damage the whole viewport.
+class LayerTreeHostDamageTestSetNeedsRedraw
+    : public LayerTreeHostDamageTest {
+  virtual void SetupTree() OVERRIDE {
+    // Viewport is 10x10.
+    scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
+    root->SetBounds(gfx::Size(10, 10));
+
+    layer_tree_host()->SetRootLayer(root);
+    LayerTreeHostDamageTest::SetupTree();
+  }
+
+  virtual void BeginTest() OVERRIDE {
+    draw_count_ = 0;
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
+    switch (layer_tree_host()->source_frame_number()) {
+      case 1:
+        layer_tree_host()->SetNeedsRedraw();
+        break;
+    }
+  }
+
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* impl,
+                                     LayerTreeHostImpl::FrameData* frame_data,
+                                     bool result) OVERRIDE {
+    EXPECT_TRUE(result);
+
+    RenderSurfaceImpl* root_surface =
+        impl->active_tree()->root_layer()->render_surface();
+    gfx::RectF root_damage =
+        root_surface->damage_tracker()->current_damage_rect();
+
+    switch (draw_count_) {
+      case 0:
+        // The first frame has full damage.
+        EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        break;
+      case 1:
+        // The second frame has full damage.
+        EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        EndTest();
+        break;
+      case 2:
+        NOTREACHED();
+    }
+
+    ++draw_count_;
+    return result;
+  }
+
+  virtual void AfterTest() OVERRIDE {}
+
+  int draw_count_;
+  FakeContentLayerClient client_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetNeedsRedraw);
+
+// LayerTreeHost::SetViewportSize should damage the whole viewport.
+class LayerTreeHostDamageTestSetViewportSize
+    : public LayerTreeHostDamageTest {
+  virtual void SetupTree() OVERRIDE {
+    // Viewport is 10x10.
+    scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
+    root->SetBounds(gfx::Size(10, 10));
+
+    layer_tree_host()->SetRootLayer(root);
+    LayerTreeHostDamageTest::SetupTree();
+  }
+
+  virtual void BeginTest() OVERRIDE {
+    draw_count_ = 0;
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
+    switch (layer_tree_host()->source_frame_number()) {
+      case 1:
+        layer_tree_host()->SetViewportSize(gfx::Size(15, 15));
+        break;
+    }
+  }
+
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* impl,
+                                     LayerTreeHostImpl::FrameData* frame_data,
+                                     bool result) OVERRIDE {
+    EXPECT_TRUE(result);
+
+    RenderSurfaceImpl* root_surface =
+        impl->active_tree()->root_layer()->render_surface();
+    gfx::RectF root_damage =
+        root_surface->damage_tracker()->current_damage_rect();
+
+    switch (draw_count_) {
+      case 0:
+        // The first frame has full damage.
+        EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        break;
+      case 1:
+        // The second frame has full damage.
+        EXPECT_EQ(gfx::RectF(15.f, 15.f).ToString(), root_damage.ToString());
+        EndTest();
+        break;
+      case 2:
+        NOTREACHED();
+    }
+
+    ++draw_count_;
+    return result;
+  }
+
+  virtual void AfterTest() OVERRIDE {}
+
+  int draw_count_;
+  FakeContentLayerClient client_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetViewportSize);
+
 class LayerTreeHostDamageTestNoDamageDoesNotSwap
     : public LayerTreeHostDamageTest {
   virtual void BeginTest() OVERRIDE {