Run all LayerTreeHost tests with a delegating renderer.

cc/trees/layer_tree_host_unittest_damage.cc

 // Copyright 2012 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 "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/damage_tracker.h"
@@ skipping 13 matching lines @@
     did_swap_and_succeed_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_);
     root->SetBounds(gfx::Size(10, 10));
 
     // Most of the layer isn't visible.
     content_ = FakeContentLayer::Create(&client_);
-    content_->SetBounds(gfx::Size(100, 100));
+    content_->SetBounds(gfx::Size(2000, 100));
     root->AddChild(content_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostDamageTest::SetupTree();
   }
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                      LayerTreeHostImpl::FrameData* frame_data,
                                      bool result) OVERRIDE {
     EXPECT_TRUE(result);
@@ skipping 34 matching lines @@
       case 1:
         layer_tree_host()->SetNeedsCommit();
         break;
       case 2:
         // Cause visible damage.
         content_->SetNeedsDisplayRect(
             gfx::Rect(layer_tree_host()->device_viewport_size()));
         break;
       case 3:
         // Cause non-visible damage.
-        content_->SetNeedsDisplayRect(gfx::Rect(90, 90, 10, 10));
+        content_->SetNeedsDisplayRect(gfx::Rect(1990, 1990, 10, 10));
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(4, did_swaps_);
     EXPECT_EQ(2, expect_swap_and_succeed_);
     EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_);
   }
 
@@ skipping 122 matching lines @@
       case 2:
         // The whole frame should be damaged as requested.
         EXPECT_EQ(gfx::RectF(root_surface->content_rect()).ToString(),
                   root_damage.ToString());
         EXPECT_FALSE(frame_data->has_no_damage);
 
         // Just a part of the next frame should be damaged.
         child_damage_rect_ = gfx::RectF(10, 11, 12, 13);
         break;
       case 3:
-        // The update rect in the child should be damaged.
-        EXPECT_EQ(gfx::RectF(100+10, 100+11, 12, 13).ToString(),
-                  root_damage.ToString());
+        if (!delegating_renderer()) {
+          // The update rect in the child should be damaged.
+          EXPECT_EQ(gfx::RectF(100+10, 100+11, 12, 13).ToString(),
+                    root_damage.ToString());
+        } else {
+          // When using a delegating renderer, the entire child is considered
+          // damaged as we need to replace its resources with newly created
+          // ones.
+          EXPECT_EQ(gfx::RectF(child_->position(), child_->bounds()).ToString(),
+                    root_damage.ToString());
+        }
         EXPECT_FALSE(frame_data->has_no_damage);
 
         // If we damage part of the frame, but also damage the full
         // frame, then the whole frame should be damaged.
         child_damage_rect_ = gfx::RectF(10, 11, 12, 13);
         host_impl->SetFullRootLayerDamage();
         break;
       case 4:
         // The whole frame is damaged.
         EXPECT_EQ(gfx::RectF(root_surface->content_rect()).ToString(),
@@ skipping 21 matching lines @@
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
   scoped_refptr<FakeContentLayer> child_;
   gfx::RectF child_damage_rect_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestForcedFullDamage);
 
 }  // namespace
 }  // namespace cc