Prevent division by 0 in set_luminance shader function.

cc/trees/layer_tree_host_pixeltest_blending.cc

 // Copyright 2013 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/layers/image_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/test/layer_tree_pixel_test.h"
 #include "cc/test/pixel_comparator.h"
 
 #if !defined(OS_ANDROID)
@@ skipping 215 matching lines @@
     background->SetIsRootForIsolatedGroup(true);
     root->AddChild(background);
 
     CreateBlendingColorLayers(kRootSize, kRootSize, background.get(), flags);
 
     this->impl_side_painting_ = false;
     this->force_antialiasing_ = (flags & kUseAntialiasing);
 
     if ((flags & kUseAntialiasing) && (type == PIXEL_TEST_GL)) {
       // Anti aliasing causes differences up to 7 pixels at the edges.
-      int large_error_allowed = 7;
+      // Several pixels have 9 units difference on the alpha channel.
+      int large_error_allowed = (flags & kUseMasks) ? 7 : 9;
       // Blending results might differ with one pixel.
       int small_error_allowed = 1;
       // Most of the errors are one pixel errors.
-      float percentage_pixels_small_error = 12.5f;
+      float percentage_pixels_small_error = (flags & kUseMasks) ? 7.7f : 12.1f;
       // Because of anti-aliasing, around 3% of pixels (at the edges) have
       // bigger errors (from small_error_allowed + 1 to large_error_allowed).
-      float percentage_pixels_error = 15.0f;
+      float percentage_pixels_error = (flags & kUseMasks) ? 12.4f : 15.f;
       // The average error is still close to 1.
-      float average_error_allowed_in_bad_pixels = 1.3f;
+      float average_error_allowed_in_bad_pixels =
+          (flags & kUseMasks) ? 1.3f : 1.f;
 
       // The sepia filter generates more small errors, but the number of large
       // errors remains around 3%.
       if (flags & kUseColorMatrix) {
-        percentage_pixels_small_error = 26.f;
-        percentage_pixels_error = 29.f;
+        percentage_pixels_small_error = (flags & kUseMasks) ? 14.0f : 26.f;
+        percentage_pixels_error = (flags & kUseMasks) ? 18.5f : 29.f;
+        average_error_allowed_in_bad_pixels = (flags & kUseMasks) ? 0.9f : 0.7f;
       }
 
-      // Anti-aliased pixels in combination with non-separable blend modes and
-      // a white background produces several black pixels (6 for these tests).
-      // Having a mask will hide the black pixels.
-      // TODO(rosca): fix this issue for non-separable blend modes.
-      if (!(flags & kUseMasks))
-        large_error_allowed = 255;
-
       pixel_comparator_.reset(
           new FuzzyPixelComparator(false,  // discard_alpha
                                    percentage_pixels_error,
                                    percentage_pixels_small_error,
                                    average_error_allowed_in_bad_pixels,
                                    large_error_allowed,
                                    small_error_allowed));
     } else if ((flags & kUseColorMatrix) && (type == PIXEL_TEST_GL)) {
       float percentage_pixels_error = 100.f;
       float percentage_pixels_small_error = 0.f;
@@ skipping 163 matching lines @@
   RunBlendingWithRenderPass(
       PIXEL_TEST_SOFTWARE,
       FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID