cc: Make damage on delegated frame damage the host layer.

cc/layer_tree_host_unittest_delegated.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/layer_tree_host.h"
 
+#include "cc/delegated_frame_data.h"
 #include "cc/delegated_renderer_layer.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "gpu/GLES2/gl2extchromium.h"
 
 namespace cc {
 namespace {
 
 // These tests deal with delegated renderer layers.
-class LayerTreeHostDelegatedTest : public ThreadedTest {};
+class LayerTreeHostDelegatedTest : public ThreadedTest {
+ protected:
+  class TestDelegatedRendererLayer : public DelegatedRendererLayer {
+   public:
+    static scoped_refptr<DelegatedRendererLayer> Create(
+        LayerTreeHostDelegatedTest* test) {
+      return new TestDelegatedRendererLayer(test);
+    }
 
-class LayerTreeHostDelegatedTestCreateChildId
+    virtual void update(ResourceUpdateQueue& queue,
+                        const OcclusionTracker* occlusion,
+                        RenderingStats* stats) OVERRIDE {
+      DelegatedRendererLayer::update(queue, occlusion, stats);
+      test_->UpdateDelegatedLayer(this);
+
+    }
+   protected:
+    TestDelegatedRendererLayer(LayerTreeHostDelegatedTest* test)

[piman, 2013/02/27 02:27:43]

nit: explicit

[danakj, 2013/02/27 20:05:02]

Done.

+        : DelegatedRendererLayer(),
+          test_(test) {}
+    virtual ~TestDelegatedRendererLayer() {}
+    LayerTreeHostDelegatedTest* test_;
+  };
+
+  // Called by each delegated renderer layer when update is called on it.
+  virtual void UpdateDelegatedLayer(TestDelegatedRendererLayer* layer) {}
+
+  scoped_ptr<DelegatedFrameData> CreateFrameData(gfx::Rect root_output_rect,
+                                                 gfx::Rect root_damage_rect) {
+    scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
+
+    scoped_ptr<RenderPass> root_pass(RenderPass::Create());
+    root_pass->SetNew(RenderPass::Id(1, 1),
+                      root_output_rect,
+                      root_damage_rect,
+                      gfx::Transform());
+    frame->render_pass_list.push_back(root_pass.Pass());
+    return frame.Pass();
+  }
+
+  scoped_ptr<DelegatedFrameData> CreateEmptyFrameData() {
+    scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
+    return frame.Pass();
+  }
+};
+
+class LayerTreeHostDelegatedTestCaseSingleDelegatedLayer
     : public LayerTreeHostDelegatedTest {
  public:
   virtual void setupTree() OVERRIDE {
     root_ = Layer::create();
+    root_->setAnchorPoint(gfx::PointF());
     root_->setBounds(gfx::Size(10, 10));
 
-    delegated_ = DelegatedRendererLayer::Create();
+    delegated_ = TestDelegatedRendererLayer::Create(this);
+    delegated_->setAnchorPoint(gfx::PointF());
     delegated_->setBounds(gfx::Size(10, 10));
     delegated_->setIsDrawable(true);
 
     root_->addChild(delegated_);
     m_layerTreeHost->setRootLayer(root_);
     LayerTreeHostDelegatedTest::setupTree();
   }
 
   virtual void beginTest() OVERRIDE {
-    num_activates_ = 0;
-    did_reset_child_id_ = false;
     postSetNeedsCommitToMainThread();
   }
 
+  virtual void afterTest() OVERRIDE {}
+
+ protected:
+  scoped_refptr<Layer> root_;
+  scoped_refptr<DelegatedRendererLayer> delegated_;
+};
+
+class LayerTreeHostDelegatedTestCreateChildId
+    : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
+ public:
+  LayerTreeHostDelegatedTestCreateChildId()
+      : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
+        num_activates_(0),
+        did_reset_child_id_(false) {}
+
+  virtual void UpdateDelegatedLayer(TestDelegatedRendererLayer* layer)
+      OVERRIDE {
+    if (testEnded())
+      return;
+    layer->SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1),
+                                        gfx::Rect(0, 0, 1, 1)));
+  }
+
   virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
     DelegatedRendererLayerImpl* delegated_impl =
         static_cast<DelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     ++num_activates_;
     switch(num_activates_) {
       case 1:
         EXPECT_TRUE(delegated_impl->child_id());
         EXPECT_FALSE(did_reset_child_id_);
@@ skipping 23 matching lines @@
     EXPECT_EQ(1, num_activates_);
     EXPECT_FALSE(delegated_impl->child_id());
     did_reset_child_id_ = true;
   }
 
   virtual void afterTest() OVERRIDE {}
 
  protected:
   int num_activates_;
   bool did_reset_child_id_;
-  scoped_refptr<Layer> root_;
-  scoped_refptr<DelegatedRendererLayer> delegated_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCreateChildId)
 
+class LayerTreeHostDelegatedTestLayerUsesFrameDamage
+    : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
+ public:
+  LayerTreeHostDelegatedTestLayerUsesFrameDamage()
+      : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
+        first_draw_for_source_frame_(true) {}
+
+  virtual void didCommit() OVERRIDE {
+    int next_source_frame_number = m_layerTreeHost->commitNumber();
+    switch (next_source_frame_number) {
+      case 1:
+        // Should create a total amount of gfx::Rect(2, 2, 10, 6) damage.
+        // The frame size is 20x20 while the layer is 10x10, so this should
+        // produce a gfx::Rect(1, 1, 5, 3) damage rect.
+        delegated_->SetFrameData(CreateFrameData(gfx::Rect(0, 0, 20, 20),
+                                                 gfx::Rect(2, 2, 5, 5)));
+        delegated_->SetFrameData(CreateFrameData(gfx::Rect(0, 0, 20, 20),
+                                                 gfx::Rect(7, 2, 5, 6)));
+        break;
+      case 2:
+        // Should create zero damage.
+        m_layerTreeHost->setNeedsCommit();
+        break;
+      case 3:
+        // Should damage the full viewport.
+        delegated_->setBounds(gfx::Size(2, 2));
+        break;
+      case 4:
+        // Should create zero damage.
+        m_layerTreeHost->setNeedsCommit();
+        break;
+      case 5:
+        // Should damage the full layer.
+        delegated_->setBounds(gfx::Size(6, 6));
+        delegated_->SetFrameData(CreateFrameData(gfx::Rect(0, 0, 5, 5),
+                                                 gfx::Rect(1, 1, 2, 2)));
+        break;
+      case 6:
+        // Should create zero damage.
+        m_layerTreeHost->setNeedsCommit();
+        break;
+      case 7:
+        // Should damage the full layer.
+        delegated_->SetDisplaySize(gfx::Size(10, 10));
+        break;
+      case 8:
+        // Should create zero damage.
+        m_layerTreeHost->setNeedsCommit();
+        break;
+      case 9:
+        // Setting an empty frame should damage the whole layer the
+        // first time.
+        delegated_->SetFrameData(CreateEmptyFrameData());
+        break;
+      case 10:
+        // Setting an empty frame shouldn't damage anything after the
+        // first time.
+        delegated_->SetFrameData(CreateEmptyFrameData());
+        break;
+      case 11:
+        // Should create gfx::Rect(1, 1, 2, 2) of damage. The frame size is
+        // 5x5 and the display size is now set to 10x10, so this should result
+        // in a gfx::Rect(2, 2, 4, 4) damage rect.
+        delegated_->SetFrameData(CreateFrameData(gfx::Rect(0, 0, 5, 5),
+                                                 gfx::Rect(1, 1, 2, 2)));
+        break;
+      case 12:
+        // Should create zero damage.
+        m_layerTreeHost->setNeedsCommit();
+        break;
+    }
+    first_draw_for_source_frame_ = true;
+  }
+
+  virtual bool prepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                     LayerTreeHostImpl::FrameData& frame,
+                                     bool result) {
+    EXPECT_TRUE(result);
+
+    if (!first_draw_for_source_frame_)
+      return result;
+
+    gfx::RectF damage_rect = frame.renderPasses.back()->damage_rect;
+
+    switch (host_impl->activeTree()->source_frame_number()) {
+      case 0:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 1:
+        EXPECT_EQ(gfx::RectF(1.f, 1.f, 5.f, 3.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 2:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 3:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 4:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 5:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 6.f, 6.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 6:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 7:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 6.f, 6.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 8:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 9:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 6.f, 6.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 10:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 11:
+        EXPECT_EQ(gfx::RectF(2.f, 2.f, 4.f, 4.f).ToString(),
+                  damage_rect.ToString());
+        break;
+      case 12:
+        EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
+                  damage_rect.ToString());
+        endTest();
+        break;
+    }
+
+    return result;
+  }
+
+ protected:
+  bool first_draw_for_source_frame_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestLayerUsesFrameDamage)
+
 }  // namespace
 }  // namespace cc