cc: Put context-loss tests in layer_tree_host_unittest_context.cc

cc/layer_tree_host_unittest_scroll.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/layer_tree_host.h"
 
 #include "cc/content_layer.h"
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_impl.h"
@@ skipping 219 matching lines @@
 
  private:
   gfx::Vector2dF scroll_amount_;
 };
 
 TEST_F(LayerTreeHostScrollTestFractionalScroll, runMultiThread)
 {
     runTest(true);
 }
 
+template<int kDeviceScaleFactorTimesTen, bool kScrollChildLayer>
 class LayerTreeHostScrollTestCaseWithChild :
     public LayerTreeHostScrollTest,
     public WebKit::WebLayerScrollClient {
  public:
-  LayerTreeHostScrollTestCaseWithChild(
-      float device_scale_factor, bool scroll_child_layer)
-      : device_scale_factor_(device_scale_factor),
-        scroll_child_layer_(scroll_child_layer),
-        initial_offset_(10, 20),
+  LayerTreeHostScrollTestCaseWithChild()
+      : initial_offset_(10, 20),
         javascript_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {
   }
 
   virtual void setupTree() OVERRIDE {
-    m_layerTreeHost->setDeviceScaleFactor(device_scale_factor_);
+    m_layerTreeHost->setDeviceScaleFactor(kDeviceScaleFactorTimesTen / 10.f);
 
     scoped_refptr<Layer> root_layer = Layer::create();
     root_layer->setBounds(gfx::Size(10, 10));
 
     root_scroll_layer_ = ContentLayer::create(&fake_content_layer_client_);
     root_scroll_layer_->setBounds(gfx::Size(110, 110));
 
     root_scroll_layer_->setPosition(gfx::Point(0, 0));
     root_scroll_layer_->setAnchorPoint(gfx::PointF());
 
@@ skipping 10 matching lines @@
     // like device pixels, and device scale factor is 2, then they will
     // be considered at 2.5, 2.5 in logical pixels, and will miss this layer.
     child_layer_->setPosition(gfx::Point(5, 5));
     child_layer_->setAnchorPoint(gfx::PointF());
 
     child_layer_->setIsDrawable(true);
     child_layer_->setScrollable(true);
     child_layer_->setMaxScrollOffset(gfx::Vector2d(100, 100));
     root_scroll_layer_->addChild(child_layer_);
 
-    if (scroll_child_layer_) {
+    if (kScrollChildLayer) {
       expected_scroll_layer_ = child_layer_;
       expected_no_scroll_layer_ = root_scroll_layer_;
     } else {
       expected_scroll_layer_ = root_scroll_layer_;
       expected_no_scroll_layer_ = child_layer_;
     }
 
     expected_scroll_layer_->setScrollOffset(initial_offset_);
 
     m_layerTreeHost->setRootLayer(root_layer);
@@ skipping 41 matching lines @@
     }
   }
 
   virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root_impl = impl->rootLayer();
     LayerImpl* root_scroll_layer_impl = root_impl->children()[0];
     LayerImpl* child_layer_impl = root_scroll_layer_impl->children()[0];
 
     LayerImpl* expected_scroll_layer_impl = NULL;
     LayerImpl* expected_no_scroll_layer_impl = NULL;
-    if (scroll_child_layer_) {
+    if (kScrollChildLayer) {
       expected_scroll_layer_impl = child_layer_impl;
       expected_no_scroll_layer_impl = root_scroll_layer_impl;
     } else {
       expected_scroll_layer_impl = root_scroll_layer_impl;
       expected_no_scroll_layer_impl = child_layer_impl;
     }
 
     EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->scrollDelta());
     EXPECT_VECTOR_EQ(
         gfx::Vector2d(),
         expected_no_scroll_layer_impl->scrollDelta());
 
     // Ensure device scale factor is affecting the layers.
     gfx::Size expected_content_bounds = gfx::ToCeiledSize(
-        gfx::ScaleSize(root_scroll_layer_impl->bounds(), device_scale_factor_));
+        gfx::ScaleSize(
+            root_scroll_layer_impl->bounds(),
+            kDeviceScaleFactorTimesTen / 10.f));
     EXPECT_SIZE_EQ(
         expected_content_bounds,
         root_scroll_layer_->contentBounds());
 
     expected_content_bounds = gfx::ToCeiledSize(
-        gfx::ScaleSize(child_layer_impl->bounds(), device_scale_factor_));
+        gfx::ScaleSize(
+            child_layer_impl->bounds(), kDeviceScaleFactorTimesTen / 10.f));
     EXPECT_SIZE_EQ(expected_content_bounds, child_layer_->contentBounds());
 
     switch (impl->activeTree()->source_frame_number()) {
       case 0: {
         // Gesture scroll on impl thread.
         InputHandlerClient::ScrollStatus status = impl->scrollBegin(
             gfx::ToCeiledPoint(
                 expected_scroll_layer_impl->position() +
                 gfx::Vector2dF(0.5f, 0.5f)),
             InputHandlerClient::Gesture);
@@ skipping 38 matching lines @@
         EXPECT_VECTOR_EQ(
             gfx::Vector2d(),
             expected_scroll_layer_impl->scrollDelta());
 
         endTest();
         break;
     }
   }
 
   virtual void afterTest() OVERRIDE {
-    if (scroll_child_layer_) {
+    if (kScrollChildLayer) {
       EXPECT_EQ(0, num_scrolls_);
       EXPECT_VECTOR_EQ(
           javascript_scroll_ + scroll_amount_,
           final_scroll_offset_);
     } else {
       EXPECT_EQ(2, num_scrolls_);
       EXPECT_VECTOR_EQ(gfx::Vector2d(), final_scroll_offset_);
     }
   }
 
  private:
-  float device_scale_factor_;
-  bool scroll_child_layer_;
   gfx::Vector2d initial_offset_;
   gfx::Vector2d javascript_scroll_;
   gfx::Vector2d scroll_amount_;
   int num_scrolls_;
   gfx::Vector2d final_scroll_offset_;
 
   FakeContentLayerClient fake_content_layer_client_;
 
   scoped_refptr<Layer> root_scroll_layer_;
   scoped_refptr<Layer> child_layer_;
   scoped_refptr<Layer> expected_scroll_layer_;
   scoped_refptr<Layer> expected_no_scroll_layer_;
 };
 
-MULTI_THREAD_TEST_P2(LayerTreeHostScrollTestCaseWithChild,
-                     DeviceScaleFactor1, 1.0f,
-                     ScrollChild, true)
-MULTI_THREAD_TEST_P2(LayerTreeHostScrollTestCaseWithChild,
-                     DeviceScaleFactor15, 1.5f,
-                     ScrollChild, true)
-MULTI_THREAD_TEST_P2(LayerTreeHostScrollTestCaseWithChild,
-                     DeviceScaleFactor2, 2.0f,
-                     ScrollChild, true)
-MULTI_THREAD_TEST_P2(LayerTreeHostScrollTestCaseWithChild,
-                     DeviceScaleFactor1, 1.0f,
-                     ScrollRootScrollLayer, false)
-MULTI_THREAD_TEST_P2(LayerTreeHostScrollTestCaseWithChild,
-                     DeviceScaleFactor15, 1.5f,
-                     ScrollRootScrollLayer, false)
-MULTI_THREAD_TEST_P2(LayerTreeHostScrollTestCaseWithChild,
-                     DeviceScaleFactor2, 2.0f,
-                     ScrollRootScrollLayer, false)
+class LayerTreeHostScrollTestScrollChild_DeviceScaleFactor1
+    : public LayerTreeHostScrollTestCaseWithChild<10, true> {};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostScrollTestScrollChild_DeviceScaleFactor1)

[jamesr, 2013/01/03 22:59:07]

this is 5 lines to set up and run a threaded test.  I think this would be a lot
clearer:

TEST_F(LayerTreeHostScrollTestScrollChild, DeviceScaleFactor1) {
  device_scale_ = 15;
  runTest(true);
}

and is 1 line shorter to boot.

+
+class LayerTreeHostScrollTestScrollChild_DeviceScaleFactor15
+    : public LayerTreeHostScrollTestCaseWithChild<15, true> {};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostScrollTestScrollChild_DeviceScaleFactor15)
+
+class LayerTreeHostScrollTestScrollChild_DeviceScaleFactor2
+    : public LayerTreeHostScrollTestCaseWithChild<20, true> {};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostScrollTestScrollChild_DeviceScaleFactor2)
+
+class LayerTreeHostScrollTestScrollRootScrollLayer_DeviceScaleFactor1
+    : public LayerTreeHostScrollTestCaseWithChild<10, true> {};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostScrollTestScrollRootScrollLayer_DeviceScaleFactor1)
+
+class LayerTreeHostScrollTestScrollRootScrollLayer_DeviceScaleFactor15
+    : public LayerTreeHostScrollTestCaseWithChild<15, true> {};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostScrollTestScrollRootScrollLayer_DeviceScaleFactor15)
+
+class LayerTreeHostScrollTestScrollRootScrollLayer_DeviceScaleFactor2
+    : public LayerTreeHostScrollTestCaseWithChild<20, true> {};
+
+MULTI_THREAD_TEST_F(
+    LayerTreeHostScrollTestScrollRootScrollLayer_DeviceScaleFactor2)
+
 
 }  // namespace
 }  // namespace cc