viz: Use Epsilon Value For Surface Aggregator Opaque Determination

Surface Aggregator uses render surface to apply opacity. This CL uses
an epsilon value to determine when opacity is close enough to 1.f to be
considered opaque.

R=enne

Bug: 831779
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel
Change-Id: Ic5f11429e4679c0990a9e441358701b8e3b5c7d2
Reviewed-on: https://chromium-review.googlesource.com/1008129Reviewed-by: enne <enne@chromium.org>
Commit-Queue: weiliangc <weiliangc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#551115}

components/viz/service/display/surface_aggregator.cc

@@ -13,6 +13,7 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/numerics/ranges.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ -34,6 +35,10 @@ namespace {
 // Maximum bucket size for the UMA stats.
 constexpr int kUmaStatMaxSurfaces = 30;
 
+// Used for determine when to treat opacity close to 1.f as opaque. The value is
+// chosen to be smaller than 1/255.
+constexpr float kOpacityEpsilon = 0.001f;
+
 const char kUmaValidSurface[] =
     "Compositing.SurfaceAggregator.SurfaceDrawQuad.ValidSurface";
 const char kUmaMissingSurface[] =
@@ -329,8 +334,9 @@ void SurfaceAggregator::EmitSurfaceContent(
                 : empty_map;
   gfx::Transform combined_transform = scaled_quad_to_target_transform;
   combined_transform.ConcatTransform(target_transform);
-  bool merge_pass = source_sqs->opacity == 1.f && copy_requests.empty() &&
-                    combined_transform.Preserves2dAxisAlignment();
+  bool merge_pass =
+      base::IsApproximatelyEqual(source_sqs->opacity, 1.f, kOpacityEpsilon) &&
+      copy_requests.empty() && combined_transform.Preserves2dAxisAlignment();
 
   const RenderPassList& referenced_passes = render_pass_list;
   // TODO(fsamuel): Move this to a separate helper function.

components/viz/service/display/surface_aggregator_unittest.cc

@@ -533,29 +533,44 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) {
   SubmitCompositorFrame(embedded_support.get(), embedded_passes,
                         arraysize(embedded_passes), embedded_local_surface_id,
                         device_scale_factor);
+  SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
+  {
+    Quad quads[] = {Quad::SurfaceQuad(embedded_surface_id, InvalidSurfaceId(),
+                                      SK_ColorWHITE, gfx::Rect(5, 5), .5f,
+                                      gfx::Transform(), false)};
+    Pass passes[] = {Pass(quads, arraysize(quads), SurfaceSize())};
 
-  Quad quads[] = {Quad::SurfaceQuad(embedded_surface_id, InvalidSurfaceId(),
-                                    SK_ColorWHITE, gfx::Rect(5, 5), .5f,
-                                    gfx::Transform(), false)};
-  Pass passes[] = {Pass(quads, arraysize(quads), SurfaceSize())};
+    SubmitCompositorFrame(support_.get(), passes, arraysize(passes),
+                          root_local_surface_id_, device_scale_factor);
 
-  SubmitCompositorFrame(support_.get(), passes, arraysize(passes),
-                        root_local_surface_id_, device_scale_factor);
+    CompositorFrame aggregated_frame = aggregator_.Aggregate(
+        root_surface_id, GetNextDisplayTimeAndIncrement());
 
-  SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
-  CompositorFrame aggregated_frame =
-      aggregator_.Aggregate(root_surface_id, GetNextDisplayTimeAndIncrement());
+    auto& render_pass_list = aggregated_frame.render_pass_list;
+    EXPECT_EQ(2u, render_pass_list.size());
 
-  auto& render_pass_list = aggregated_frame.render_pass_list;
-  ASSERT_EQ(2u, render_pass_list.size());
-  auto& shared_quad_state_list = render_pass_list[0]->shared_quad_state_list;
-  ASSERT_EQ(2u, shared_quad_state_list.size());
-  EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(0)->opacity);
-  EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(1)->opacity);
-
-  auto& shared_quad_state_list2 = render_pass_list[1]->shared_quad_state_list;
-  ASSERT_EQ(1u, shared_quad_state_list2.size());
-  EXPECT_EQ(.5f, shared_quad_state_list2.ElementAt(0)->opacity);
+    auto& shared_quad_state_list2 = render_pass_list[1]->shared_quad_state_list;
+    ASSERT_EQ(1u, shared_quad_state_list2.size());
+    EXPECT_EQ(.5f, shared_quad_state_list2.ElementAt(0)->opacity);
+  }
+
+  // For the case where opacity is close to 1.f, we treat it as opaque, and not
+  // use a render surface.
+  {
+    Quad quads[] = {Quad::SurfaceQuad(embedded_surface_id, InvalidSurfaceId(),
+                                      SK_ColorWHITE, gfx::Rect(5, 5), .9999f,
+                                      gfx::Transform(), false)};
+    Pass passes[] = {Pass(quads, arraysize(quads), SurfaceSize())};
+
+    SubmitCompositorFrame(support_.get(), passes, arraysize(passes),
+                          root_local_surface_id_, device_scale_factor);
+
+    CompositorFrame aggregated_frame = aggregator_.Aggregate(
+        root_surface_id, GetNextDisplayTimeAndIncrement());
+
+    auto& render_pass_list = aggregated_frame.render_pass_list;
+    EXPECT_EQ(1u, render_pass_list.size());
+  }
 }
 
 // Test that when surface is rotated and we need the render surface to apply the