Update from https://crrev.com/320343

cc/trees/layer_tree_host_pixeltest_masks.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 "build/build_config.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_image_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/test/layer_tree_pixel_resource_test.h"
 #include "cc/test/pixel_comparator.h"
 
 #if !defined(OS_ANDROID)
 
+// TODO(enne): these time out on Windows.  http://crbug.com/435632
+#if !defined(OS_WIN)
+
 namespace cc {
 namespace {
 
 typedef ParameterizedPixelResourceTest LayerTreeHostMasksPixelTest;
 
 INSTANTIATE_PIXEL_RESOURCE_TEST_CASE_P(LayerTreeHostMasksPixelTest);
 
 class MaskContentLayerClient : public ContentLayerClient {
  public:
   explicit MaskContentLayerClient(const gfx::Size& bounds) : bounds_(bounds) {}
@@ skipping 25 matching lines @@
       const gfx::Rect& clip,
       PaintingControlSetting picture_control) override {
     NOTIMPLEMENTED();
     return DisplayItemList::Create();
   }
 
  private:
   gfx::Size bounds_;
 };
 
-// TODO(enne): these time out on Windows.  http://crbug.com/435632
-#if !defined(OS_WIN)
-
 TEST_P(LayerTreeHostMasksPixelTest, MaskOfLayer) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
       gfx::Rect(50, 50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
   background->AddChild(green);
 
   gfx::Size mask_bounds(100, 100);
   MaskContentLayerClient client(mask_bounds);
@@ skipping 200 matching lines @@
   replica->SetPosition(gfx::Point());
   replica->SetTransform(replica_transform);
   replica->SetMaskLayer(mask.get());
   green->SetReplicaLayer(replica.get());
 
   RunPixelResourceTest(background,
                        base::FilePath(FILE_PATH_LITERAL(
                            "mask_of_replica_of_clipped_layer.png")));
 }
 
-#endif  // !defined(OS_WIN)
-
 class CheckerContentLayerClient : public ContentLayerClient {
  public:
   CheckerContentLayerClient(const gfx::Size& bounds,
                            SkColor color,
                            bool vertical)
       : bounds_(bounds), color_(color), vertical_(vertical) {}
   ~CheckerContentLayerClient() override {}
   bool FillsBoundsCompletely() const override { return false; }
   void PaintContents(SkCanvas* canvas,
                      const gfx::Rect& rect,
@@ skipping 95 matching lines @@
   gfx::Size mask_bounds(256, 256);
   CircleContentLayerClient mask_client(mask_bounds);
   scoped_refptr<PictureLayer> mask = PictureLayer::Create(&mask_client);
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
   blur->SetMaskLayer(mask.get());
 
   float percentage_pixels_large_error = 2.5f;  // 2.5%, ~1600px / (256*256)
   float percentage_pixels_small_error = 0.0f;
-  float average_error_allowed_in_bad_pixels = 60.0f;
-  int large_error_allowed = 100;
+  float average_error_allowed_in_bad_pixels = 100.0f;
+  int large_error_allowed = 256;
   int small_error_allowed = 0;
   pixel_comparator_.reset(new FuzzyPixelComparator(
       true,  // discard_alpha
       percentage_pixels_large_error,
       percentage_pixels_small_error,
       average_error_allowed_in_bad_pixels,
       large_error_allowed,
       small_error_allowed));
 
   RunPixelResourceTest(background,
@@ skipping 48 matching lines @@
       small_error_allowed));
 
   RunPixelResourceTest(background,
                        base::FilePath(
                            FILE_PATH_LITERAL("mask_of_layer_with_blend.png")));
 }
 
 }  // namespace
 }  // namespace cc
 
-#endif  // OS_ANDROID
+#endif  // !defined(OS_WIN)
+#endif  // !defined(OS_ANDROID)