Update from https://crrev.com/316786

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 83 matching lines @@
   gfx::Rect UnoccludedLayerContentRect(const LayerType* layer,
                                        const gfx::Rect& content_rect) const {
     DCHECK(layer->visible_content_rect().Contains(content_rect));
     return this->GetCurrentOcclusionForLayer(layer->draw_transform())
         .GetUnoccludedContentRect(content_rect);
   }
 
   gfx::Rect UnoccludedSurfaceContentRect(const LayerType* layer,
                                          const gfx::Rect& content_rect) const {
     typename LayerType::RenderSurfaceType* surface = layer->render_surface();
-    return this->UnoccludedContributingSurfaceContentRect(
-        content_rect, surface->draw_transform());
+    return this->GetCurrentOcclusionForContributingSurface(
+                     surface->draw_transform())
+        .GetUnoccludedContentRect(content_rect);
   }
 };
 
 struct OcclusionTrackerTestMainThreadTypes {
   typedef Layer LayerType;
   typedef FakeLayerTreeHost HostType;
   typedef RenderSurface RenderSurfaceType;
   typedef TestContentLayer ContentLayerType;
   typedef scoped_refptr<Layer> LayerPtrType;
   typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
@@ skipping 2548 matching lines @@
       ASSERT_LT(i, actual_occlusion.GetRegionComplexity());
       EXPECT_EQ(expected_occlusion.GetRect(i), actual_occlusion.GetRect(i));
     }
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(
     OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded);
 
 template <class Types>
+class OcclusionTrackerTestBlendModeDoesNotOcclude
+    : public OcclusionTrackerTest<Types> {
+ protected:
+  explicit OcclusionTrackerTestBlendModeDoesNotOcclude(bool opaque_layers)
+      : OcclusionTrackerTest<Types>(opaque_layers) {}
+  void RunMyTest() override {
+    typename Types::ContentLayerType* parent = this->CreateRoot(
+        this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
+    typename Types::LayerType* blend_mode_layer = this->CreateDrawingLayer(
+        parent, this->identity_matrix, gfx::PointF(0.f, 0.f),
+        gfx::Size(100, 100), true);
+    typename Types::LayerType* top_layer = this->CreateDrawingLayer(
+        parent, this->identity_matrix, gfx::PointF(10.f, 12.f),
+        gfx::Size(20, 22), true);
+
+    // Blend mode makes the layer own a surface.
+    Types::SetForceRenderSurface(blend_mode_layer, true);
+    blend_mode_layer->SetBlendMode(SkXfermode::kMultiply_Mode);
+
+    this->CalcDrawEtc(parent);
+
+    TestOcclusionTrackerWithClip<typename Types::LayerType> occlusion(
+        gfx::Rect(0, 0, 1000, 1000));
+
+    this->VisitLayer(top_layer, &occlusion);
+    // |top_layer| occludes.
+    EXPECT_EQ(gfx::Rect(10, 12, 20, 22).ToString(),
+              occlusion.occlusion_from_inside_target().ToString());
+    EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
+
+    this->VisitLayer(blend_mode_layer, &occlusion);
+    // |top_layer| occludes but not |blend_mode_layer|.
+    EXPECT_EQ(gfx::Rect(10, 12, 20, 22).ToString(),
+              occlusion.occlusion_from_outside_target().ToString());
+    EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
+
+    this->VisitContributingSurface(blend_mode_layer, &occlusion);
+    // |top_layer| occludes but not |blend_mode_layer|.
+    EXPECT_EQ(gfx::Rect(10, 12, 20, 22).ToString(),
+              occlusion.occlusion_from_inside_target().ToString());
+    EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
+  }
+};
+
+ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestBlendModeDoesNotOcclude);
+
+template <class Types>
 class OcclusionTrackerTestMinimumTrackingSize
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestMinimumTrackingSize(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
   void RunMyTest() override {
     gfx::Size tracking_size(100, 100);
     gfx::Size below_tracking_size(99, 99);
 
     typename Types::ContentLayerType* parent = this->CreateRoot(
@@ skipping 125 matching lines @@
                                                         this->identity_matrix,
                                                         gfx::Point(100, 0),
                                                         gfx::Size(200, 400));
     this->AddCopyRequest(copy);
     typename Types::LayerType* copy_child = this->CreateDrawingLayer(
         copy,
         this->identity_matrix,
         gfx::PointF(),
         gfx::Size(200, 400),
         true);
+    typename Types::LayerType* top_layer =
+        this->CreateDrawingLayer(root, this->identity_matrix,
+                                 gfx::PointF(50, 0), gfx::Size(50, 400), true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
+    this->VisitLayer(top_layer, &occlusion);
+    EXPECT_EQ(gfx::Rect().ToString(),
+              occlusion.occlusion_from_outside_target().ToString());
+    EXPECT_EQ(gfx::Rect(50, 0, 50, 400).ToString(),
+              occlusion.occlusion_from_inside_target().ToString());
+
     this->VisitLayer(copy_child, &occlusion);
+    // Layers outside the copy request do not occlude.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(200, 400).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // CopyRequests cause the layer to own a surface.
     this->VisitContributingSurface(copy, &occlusion);
 
     // The occlusion from the copy should be kept.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
-    EXPECT_EQ(gfx::Rect(100, 0, 200, 400).ToString(),
+    EXPECT_EQ(gfx::Rect(50, 0, 250, 400).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestCopyRequestDoesOcclude)
 
 template <class Types>
 class OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude
     : public OcclusionTrackerTest<Types> {
  protected:
@@ skipping 468 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc