Update from https://crrev.com/308331

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/picture_image_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)
 
 namespace cc {
 namespace {
 
 SkXfermode::Mode const kBlendModes[] = {
@@ skipping 114 matching lines @@
     SkBitmap backing_store;
     backing_store.allocN32Pixels(width, height);
     SkCanvas canvas(backing_store);
     canvas.clear(SK_ColorTRANSPARENT);
     for (int i = 0; i < kCSSTestColorsCount; ++i) {
       SkPaint paint;
       paint.setColor(kCSSTestColors[i]);
       canvas.drawRect(
           SkRect::MakeXYWH(0, i * kLaneHeight, kLaneWidth, kLaneHeight), paint);
     }
-    scoped_refptr<ImageLayer> layer = ImageLayer::Create();
+    scoped_refptr<PictureImageLayer> layer = PictureImageLayer::Create();
     layer->SetIsDrawable(true);
     layer->SetBounds(gfx::Size(width, height));
     layer->SetBitmap(backing_store);
     return layer;
   }
 
   void SetupMaskLayer(scoped_refptr<Layer> layer) {
     const int kMaskOffset = 2;
     gfx::Size bounds = layer->bounds();
-    scoped_refptr<ImageLayer> mask = ImageLayer::Create();
+    scoped_refptr<PictureImageLayer> mask = PictureImageLayer::Create();
     mask->SetIsDrawable(true);
     mask->SetIsMask(true);
     mask->SetBounds(bounds);
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(bounds.width(), bounds.height());
     SkCanvas canvas(bitmap);
     SkPaint paint;
     paint.setColor(SK_ColorWHITE);
     canvas.clear(SK_ColorTRANSPARENT);
@@ skipping 69 matching lines @@
     scoped_refptr<SolidColorLayer> root =
         CreateSolidColorLayer(gfx::Rect(kRootSize, kRootSize), SK_ColorWHITE);
     scoped_refptr<Layer> background =
         CreateColorfulBackdropLayer(kRootSize, kRootSize);
 
     background->SetIsRootForIsolatedGroup(true);
     root->AddChild(background);
 
     CreateBlendingColorLayers(kLaneWidth, kLaneHeight, background.get(), flags);
 
-    this->impl_side_painting_ = false;
     this->force_antialiasing_ = (flags & kUseAntialiasing);
     this->force_blending_with_shaders_ = (flags & kForceShaders);
 
     if ((flags & kUseAntialiasing) && (test_type_ == PIXEL_TEST_GL)) {
       // Anti aliasing causes differences up to 8 pixels at the edges.
       int large_error_allowed = 8;
       // 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 = 13.1f;
@@ skipping 179 matching lines @@
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMask_GL) {
   RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
+       BlendingWithRenderPassShadersWithMask_GL_TextureRect) {
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
+                            FILE_PATH_LITERAL("blending_render_pass_mask.png"),
+                            kUseMasks | kForceShaders);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskAA_GL) {
   RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
+       BlendingWithRenderPassShadersWithMaskAA_GL_TextureRect) {
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
+                            FILE_PATH_LITERAL("blending_render_pass_mask.png"),
+                            kUseMasks | kUseAntialiasing | kForceShaders);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrix_GL) {
   RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrixAA_GL) {
   RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrix_GL) {
   RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
+       BlendingWithRenderPassShadersWithMaskColorMatrix_GL_TextureRect) {
+  RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW,
+                            FILE_PATH_LITERAL("blending_render_pass_mask.png"),
+                            kUseMasks | kUseColorMatrix | kForceShaders);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrixAA_GL) {
   RunBlendingWithRenderPass(
       GL_ASYNC_UPLOAD_2D_DRAW,
       FILE_PATH_LITERAL("blending_render_pass_mask.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID