Update from https://crrev.com/308996

cc/trees/occlusion_tracker_unittest.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/occlusion_tracker.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 499 matching lines @@
   RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName)                                \
       RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)
 
 template <class Types>
 class OcclusionTrackerTestIdentityTransforms
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestIdentityTransforms(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
 
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
     typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
     typename Types::ContentLayerType* layer =
         this->CreateDrawingLayer(parent,
                                  this->identity_matrix,
                                  gfx::PointF(30.f, 30.f),
                                  gfx::Size(500, 500),
                                  true);
@@ skipping 13 matching lines @@
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestIdentityTransforms);
 
 template <class Types>
 class OcclusionTrackerTestRotatedChild : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestRotatedChild(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform layer_transform;
     layer_transform.Translate(250.0, 250.0);
     layer_transform.Rotate(90.0);
     layer_transform.Translate(-250.0, -250.0);
 
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::Point(0, 0), gfx::Size(200, 200));
     typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
     typename Types::ContentLayerType* layer =
@@ skipping 18 matching lines @@
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestRotatedChild);
 
 template <class Types>
 class OcclusionTrackerTestTranslatedChild : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestTranslatedChild(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform layer_transform;
     layer_transform.Translate(20.0, 20.0);
 
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
     typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
     typename Types::ContentLayerType* layer =
         this->CreateDrawingLayer(parent,
                                  layer_transform,
@@ skipping 17 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestTranslatedChild);
 
 template <class Types>
 class OcclusionTrackerTestChildInRotatedChild
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestChildInRotatedChild(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform child_transform;
     child_transform.Translate(250.0, 250.0);
     child_transform.Rotate(90.0);
     child_transform.Translate(-250.0, -250.0);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
     parent->SetMasksToBounds(true);
     typename Types::LayerType* child = this->CreateSurface(
         parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500));
@@ skipping 77 matching lines @@
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestChildInRotatedChild);
 
 template <class Types>
 class OcclusionTrackerTestScaledRenderSurface
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestScaledRenderSurface(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
 
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
 
     gfx::Transform layer1_matrix;
     layer1_matrix.Scale(2.0, 2.0);
     typename Types::ContentLayerType* layer1 = this->CreateDrawingLayer(
         parent, layer1_matrix, gfx::PointF(), gfx::Size(100, 100), true);
     layer1->SetForceRenderSurface(true);
 
     gfx::Transform layer2_matrix;
@@ skipping 22 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledRenderSurface);
 
 template <class Types>
 class OcclusionTrackerTestVisitTargetTwoTimes
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestVisitTargetTwoTimes(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
     typename Types::LayerType* surface = this->CreateSurface(
         root, this->identity_matrix, gfx::PointF(30.f, 30.f), gfx::Size());
     typename Types::ContentLayerType* surface_child =
         this->CreateDrawingLayer(surface,
                                  this->identity_matrix,
                                  gfx::PointF(10.f, 10.f),
                                  gfx::Size(50, 50),
                                  true);
@@ skipping 45 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestVisitTargetTwoTimes);
 
 template <class Types>
 class OcclusionTrackerTestSurfaceRotatedOffAxis
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestSurfaceRotatedOffAxis(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform child_transform;
     child_transform.Translate(250.0, 250.0);
     child_transform.Rotate(95.0);
     child_transform.Translate(-250.0, -250.0);
 
     gfx::Transform layer_transform;
     layer_transform.Translate(10.0, 10.0);
 
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(1000, 1000));
@@ skipping 31 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceRotatedOffAxis);
 
 template <class Types>
 class OcclusionTrackerTestSurfaceWithTwoOpaqueChildren
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestSurfaceWithTwoOpaqueChildren(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform child_transform;
     child_transform.Translate(250.0, 250.0);
     child_transform.Rotate(90.0);
     child_transform.Translate(-250.0, -250.0);
 
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(1000, 1000));
     typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
     parent->SetMasksToBounds(true);
@@ skipping 67 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceWithTwoOpaqueChildren);
 
 template <class Types>
 class OcclusionTrackerTestOverlappingSurfaceSiblings
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestOverlappingSurfaceSiblings(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
     parent->SetMasksToBounds(true);
     typename Types::LayerType* child1 = this->CreateSurface(
         parent, this->identity_matrix, gfx::PointF(10.f, 0.f), gfx::Size());
     typename Types::LayerType* child2 = this->CreateSurface(
         parent, this->identity_matrix, gfx::PointF(30.f, 0.f), gfx::Size());
     typename Types::ContentLayerType* layer1 = this->CreateDrawingLayer(
         child1, this->identity_matrix, gfx::PointF(), gfx::Size(40, 50), true);
     typename Types::ContentLayerType* layer2 =
@@ skipping 39 matching lines @@
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestOverlappingSurfaceSiblings);
 
 template <class Types>
 class OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform child1_transform;
     child1_transform.Translate(250.0, 250.0);
     child1_transform.Rotate(-90.0);
     child1_transform.Translate(-250.0, -250.0);
 
     gfx::Transform child2_transform;
     child2_transform.Translate(250.0, 250.0);
     child2_transform.Rotate(90.0);
     child2_transform.Translate(-250.0, -250.0);
 
@@ skipping 85 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(
     OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms);
 
 template <class Types>
 class OcclusionTrackerTestFilters : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestFilters(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform layer_transform;
     layer_transform.Translate(250.0, 250.0);
     layer_transform.Rotate(90.0);
     layer_transform.Translate(-250.0, -250.0);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
     parent->SetMasksToBounds(true);
     typename Types::ContentLayerType* blur_layer =
         this->CreateDrawingLayer(parent,
@@ skipping 79 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestFilters);
 
 template <class Types>
 class OcclusionTrackerTestReplicaDoesOcclude
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestReplicaDoesOcclude(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
     typename Types::LayerType* surface = this->CreateDrawingSurface(
         parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), true);
     this->CreateReplicaLayer(
         surface, this->identity_matrix, gfx::PointF(0.f, 50.f), gfx::Size());
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
@@ skipping 13 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaDoesOcclude);
 
 template <class Types>
 class OcclusionTrackerTestReplicaWithClipping
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestReplicaWithClipping(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 170));
     parent->SetMasksToBounds(true);
     typename Types::LayerType* surface =
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(0.f, 100.f),
                                    gfx::Size(50, 50),
                                    true);
     this->CreateReplicaLayer(
@@ skipping 21 matching lines @@
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithClipping);
 
 template <class Types>
 class OcclusionTrackerTestReplicaWithMask : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestReplicaWithMask(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
     typename Types::LayerType* surface =
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(0.f, 100.f),
                                    gfx::Size(50, 50),
                                    true);
     typename Types::LayerType* replica = this->CreateReplicaLayer(
         surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size());
@@ skipping 19 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithMask);
 
 template <class Types>
 class OcclusionTrackerTestOpaqueContentsRegionEmpty
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestOpaqueContentsRegionEmpty(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
     typename Types::ContentLayerType* layer =
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(200, 200),
                                    false);
     this->CalcDrawEtc(parent);
 
@@ skipping 14 matching lines @@
 };
 
 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionEmpty);
 
 template <class Types>
 class OcclusionTrackerTestOpaqueContentsRegionNonEmpty
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestOpaqueContentsRegionNonEmpty(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
     typename Types::ContentLayerType* layer =
         this->CreateDrawingLayer(parent,
                                  this->identity_matrix,
                                  gfx::PointF(100.f, 100.f),
                                  gfx::Size(200, 200),
                                  false);
     this->CalcDrawEtc(parent);
     {
@@ skipping 36 matching lines @@
 };
 
 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionNonEmpty);
 
 template <class Types>
 class OcclusionTrackerTestUnsorted3dLayers
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestUnsorted3dLayers(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     // Currently, The main thread layer iterator does not iterate over 3d items
     // in sorted order, because layer sorting is not performed on the main
     // thread.  Because of this, the occlusion tracker cannot assume that a 3d
     // layer occludes other layers that have not yet been iterated over. For
     // now, the expected behavior is that a 3d layer simply does not add any
     // occlusion to the occlusion tracker.
 
     gfx::Transform translation_to_front;
     translation_to_front.Translate3d(0.0, 0.0, -10.0);
     gfx::Transform translation_to_back;
@@ skipping 32 matching lines @@
 // will only work on the main thread.
 MAIN_THREAD_TEST(OcclusionTrackerTestUnsorted3dLayers);
 
 template <class Types>
 class OcclusionTrackerTestLayerBehindCameraDoesNotOcclude
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestLayerBehindCameraDoesNotOcclude(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform transform;
     transform.Translate(50.0, 50.0);
     transform.ApplyPerspectiveDepth(100.0);
     transform.Translate3d(0.0, 0.0, 110.0);
     transform.Translate(-50.0, -50.0);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
     typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
         parent, transform, gfx::PointF(), gfx::Size(100, 100), true);
@@ skipping 19 matching lines @@
 // thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude);
 
 template <class Types>
 class OcclusionTrackerTestLargePixelsOccludeInsideClipRect
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestLargePixelsOccludeInsideClipRect(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform transform;
     transform.Translate(50.0, 50.0);
     transform.ApplyPerspectiveDepth(100.0);
     transform.Translate3d(0.0, 0.0, 99.0);
     transform.Translate(-50.0, -50.0);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
     parent->SetMasksToBounds(true);
     typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
@@ skipping 23 matching lines @@
 // the occlusion tracker on the main thread. So this test should run on the impl
 // thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestLargePixelsOccludeInsideClipRect);
 
 template <class Types>
 class OcclusionTrackerTestAnimationOpacity1OnMainThread
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestAnimationOpacity1OnMainThread(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     // parent
     // +--layer
     // +--surface
     // |  +--surface_child
     // |  +--surface_child2
     // +--parent2
     // +--topmost
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
@@ skipping 98 matching lines @@
 };
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity1OnMainThread);
 
 template <class Types>
 class OcclusionTrackerTestAnimationOpacity0OnMainThread
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestAnimationOpacity0OnMainThread(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
     typename Types::ContentLayerType* layer =
         this->CreateDrawingLayer(parent,
                                  this->identity_matrix,
                                  gfx::PointF(),
                                  gfx::Size(300, 300),
                                  true);
     typename Types::ContentLayerType* surface =
         this->CreateDrawingSurface(parent,
@@ skipping 90 matching lines @@
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity0OnMainThread);
 
 template <class Types>
 class OcclusionTrackerTestAnimationTranslateOnMainThread
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestAnimationTranslateOnMainThread(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
     typename Types::ContentLayerType* layer =
         this->CreateDrawingLayer(parent,
                                  this->identity_matrix,
                                  gfx::PointF(),
                                  gfx::Size(300, 300),
                                  true);
     typename Types::ContentLayerType* surface =
         this->CreateDrawingSurface(parent,
@@ skipping 109 matching lines @@
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationTranslateOnMainThread);
 
 template <class Types>
 class OcclusionTrackerTestSurfaceOcclusionTranslatesToParent
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestSurfaceOcclusionTranslatesToParent(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform surface_transform;
     surface_transform.Translate(300.0, 300.0);
     surface_transform.Scale(2.0, 2.0);
     surface_transform.Translate(-150.0, -150.0);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(500, 500));
     typename Types::ContentLayerType* surface = this->CreateDrawingSurface(
         parent, surface_transform, gfx::PointF(), gfx::Size(300, 300), false);
     typename Types::ContentLayerType* surface2 =
@@ skipping 34 matching lines @@
 MAIN_AND_IMPL_THREAD_TEST(
     OcclusionTrackerTestSurfaceOcclusionTranslatesToParent);
 
 template <class Types>
 class OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
     parent->SetMasksToBounds(true);
     typename Types::ContentLayerType* surface =
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(500, 300),
                                    false);
     surface->SetOpaqueContentsRect(gfx::Rect(0, 0, 400, 200));
@@ skipping 14 matching lines @@
 
 MAIN_AND_IMPL_THREAD_TEST(
     OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping);
 
 template <class Types>
 class OcclusionTrackerTestSurfaceWithReplicaUnoccluded
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestSurfaceWithReplicaUnoccluded(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
     typename Types::LayerType* surface =
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(100, 100),
                                    true);
     this->CreateReplicaLayer(surface,
                              this->identity_matrix,
@@ skipping 39 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceWithReplicaUnoccluded);
 
 template <class Types>
 class OcclusionTrackerTestSurfaceChildOfSurface
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestSurfaceChildOfSurface(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     // This test verifies that the surface cliprect does not end up empty and
     // clip away the entire unoccluded rect.
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
     typename Types::LayerType* surface =
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(100, 100),
@@ skipping 77 matching lines @@
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfSurface);
 
 template <class Types>
 class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform scale_by_half;
     scale_by_half.Scale(0.5, 0.5);
 
     FilterOperations filters;
     filters.Append(FilterOperation::CreateBlurFilter(10.f));
 
     // Save the distance of influence for the blur effect.
     int outset_top, outset_right, outset_bottom, outset_left;
     filters.GetOutsets(
         &outset_top, &outset_right, &outset_bottom, &outset_left);
@@ skipping 103 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(
     OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter);
 
 template <class Types>
 class OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform scale_by_half;
     scale_by_half.Scale(0.5, 0.5);
 
     // Makes two surfaces that completely cover |parent|. The occlusion both
     // above and below the filters will be reduced by each of them.
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(75, 75));
     typename Types::LayerType* parent = this->CreateSurface(
         root, scale_by_half, gfx::PointF(), gfx::Size(150, 150));
     parent->SetMasksToBounds(true);
@@ skipping 54 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(
     OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice);
 
 template <class Types>
 class OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform scale_by_half;
     scale_by_half.Scale(0.5, 0.5);
 
     // Make a surface and its replica, each 50x50, with a smaller 30x30 layer
     // centered below each.  The surface is scaled to test that the pixel moving
     // is done in the target space, where the background filter is applied, but
     // the surface appears at 50, 50 and the replica at 200, 50.
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 150));
     typename Types::LayerType* behind_surface_layer =
@@ skipping 63 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(
     OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter);
 
 template <class Types>
 class OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform scale_by_half;
     scale_by_half.Scale(0.5, 0.5);
 
     // Make a 50x50 filtered surface that is completely occluded by an opaque
     // layer which is above it in the z-order.  The surface is
     // scaled to test that the pixel moving is done in the target space, where
     // the background filter is applied, but the surface appears at 50, 50.
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(200, 150));
     typename Types::LayerType* filtered_surface =
@@ skipping 52 matching lines @@
     OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded);
 
 template <class Types>
 class OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit
   OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform scale_by_half;
     scale_by_half.Scale(0.5, 0.5);
 
     // Make a surface and its replica, each 50x50, that are partially occluded
     // by opaque layers which are above them in the z-order.  The surface is
     // scaled to test that the pixel moving is done in the target space, where
     // the background filter is applied, but the surface appears at 50, 50 and
     // the replica at 200, 50.
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 150));
@@ skipping 91 matching lines @@
 
 ALL_OCCLUSIONTRACKER_TEST(
     OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded);
 
 template <class Types>
 class OcclusionTrackerTestMinimumTrackingSize
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestMinimumTrackingSize(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Size tracking_size(100, 100);
     gfx::Size below_tracking_size(99, 99);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
     typename Types::LayerType* large = this->CreateDrawingLayer(
         parent, this->identity_matrix, gfx::PointF(), tracking_size, true);
     typename Types::LayerType* small =
         this->CreateDrawingLayer(parent,
                                  this->identity_matrix,
@@ skipping 25 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestMinimumTrackingSize);
 
 template <class Types>
 class OcclusionTrackerTestScaledLayerIsClipped
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestScaledLayerIsClipped(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform scale_transform;
     scale_transform.Scale(512.0, 512.0);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
     typename Types::LayerType* clip = this->CreateLayer(parent,
                                                         this->identity_matrix,
                                                         gfx::PointF(10.f, 10.f),
                                                         gfx::Size(50, 50));
     clip->SetMasksToBounds(true);
@@ skipping 16 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledLayerIsClipped)
 
 template <class Types>
 class OcclusionTrackerTestScaledLayerInSurfaceIsClipped
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestScaledLayerInSurfaceIsClipped(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform scale_transform;
     scale_transform.Scale(512.0, 512.0);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
     typename Types::LayerType* clip = this->CreateLayer(parent,
                                                         this->identity_matrix,
                                                         gfx::PointF(10.f, 10.f),
                                                         gfx::Size(50, 50));
     clip->SetMasksToBounds(true);
@@ skipping 20 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledLayerInSurfaceIsClipped)
 
 template <class Types>
 class OcclusionTrackerTestCopyRequestDoesOcclude
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestCopyRequestDoesOcclude(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::Point(), gfx::Size(400, 400));
     typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true);
     typename Types::LayerType* copy = this->CreateLayer(parent,
                                                         this->identity_matrix,
                                                         gfx::Point(100, 0),
                                                         gfx::Size(200, 400));
     this->AddCopyRequest(copy);
     typename Types::LayerType* copy_child = this->CreateDrawingLayer(
@@ skipping 26 matching lines @@
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestCopyRequestDoesOcclude)
 
 template <class Types>
 class OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude(
       bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::Point(), gfx::Size(400, 400));
     typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true);
     typename Types::LayerType* hide = this->CreateLayer(
         parent, this->identity_matrix, gfx::Point(), gfx::Size());
     typename Types::LayerType* copy = this->CreateLayer(
         hide, this->identity_matrix, gfx::Point(100, 0), gfx::Size(200, 400));
     this->AddCopyRequest(copy);
     typename Types::LayerType* copy_child = this->CreateDrawingLayer(
@@ skipping 25 matching lines @@
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude)
 
 template <class Types>
 class OcclusionTrackerTestOccludedLayer : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestOccludedLayer(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform translate;
     translate.Translate(10.0, 20.0);
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
     typename Types::LayerType* surface = this->CreateSurface(
         root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
     typename Types::LayerType* layer = this->CreateDrawingLayer(
         surface, translate, gfx::Point(), gfx::Size(200, 200), false);
     typename Types::ContentLayerType* outside_layer = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200), false);
@@ skipping 70 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestOccludedLayer)
 
 template <class Types>
 class OcclusionTrackerTestUnoccludedLayerQuery
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestUnoccludedLayerQuery(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform translate;
     translate.Translate(10.0, 20.0);
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
     typename Types::LayerType* surface = this->CreateSurface(
         root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
     typename Types::LayerType* layer = this->CreateDrawingLayer(
         surface, translate, gfx::Point(), gfx::Size(200, 200), false);
     typename Types::ContentLayerType* outside_layer = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200), false);
@@ skipping 145 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedLayerQuery)
 
 template <class Types>
 class OcclusionTrackerTestUnoccludedSurfaceQuery
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestUnoccludedSurfaceQuery(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() {
+  void RunMyTest() override {
     gfx::Transform translate;
     translate.Translate(10.0, 20.0);
     typename Types::ContentLayerType* root = this->CreateRoot(
         this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
     typename Types::LayerType* surface =
         this->CreateSurface(root, translate, gfx::Point(), gfx::Size(200, 200));
     typename Types::LayerType* layer =
         this->CreateDrawingLayer(surface,
                                  this->identity_matrix,
                                  gfx::Point(),
@@ skipping 151 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc