Avoid using SkClipOp::kReplace_deprecated in software renderer

cc/output/software_renderer_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/output/software_renderer.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/software_output_device.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_resource_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/utils/SkNWayCanvas.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 namespace {
 
 class SoftwareRendererTest : public testing::Test {
  public:
   void InitializeRenderer(
       std::unique_ptr<SoftwareOutputDevice> software_output_device) {
     output_surface_ =
@@ skipping 331 matching lines @@
       output->getColor(smaller_rect.right() - 1, smaller_rect.bottom() - 1));
 
   EXPECT_EQ(
       SK_ColorMAGENTA,
       output->getColor(interior_visible_rect.x(), interior_visible_rect.y()));
   EXPECT_EQ(SK_ColorMAGENTA,
             output->getColor(interior_visible_rect.right() - 1,
                              interior_visible_rect.bottom() - 1));
 }
 
+class ClipTrackingCanvas : public SkNWayCanvas {
+ public:
+  ClipTrackingCanvas(int width, int height) : SkNWayCanvas(width, height) {}
+  void onClipRect(const SkRect& rect,
+                  SkClipOp op,
+                  ClipEdgeStyle style) override {
+    last_clip_rect_ = rect;
+    SkNWayCanvas::onClipRect(rect, op, style);
+  }
+
+  SkRect last_clip_rect() const { return last_clip_rect_; }
+
+ private:
+  SkRect last_clip_rect_;
+};
+
 class PartialSwapSoftwareOutputDevice : public SoftwareOutputDevice {
  public:
   // SoftwareOutputDevice overrides.
   SkCanvas* BeginPaint(const gfx::Rect& damage_rect) override {
     damage_rect_at_start_ = damage_rect;
-    canvas_ = SoftwareOutputDevice::BeginPaint(damage_rect);
-    return canvas_;
+    canvas_.reset(new ClipTrackingCanvas(viewport_pixel_size_.width(),
+                                         viewport_pixel_size_.height()));
+    canvas_->addCanvas(SoftwareOutputDevice::BeginPaint(damage_rect));
+    return canvas_.get();
   }
+
   void EndPaint() override {
-    clip_rect_at_end_ = gfx::SkIRectToRect(canvas_->getDeviceClipBounds());
+    clip_rect_at_end_ = gfx::SkRectToRectF(canvas_->last_clip_rect());
     SoftwareOutputDevice::EndPaint();
   }
 
   gfx::Rect damage_rect_at_start() const { return damage_rect_at_start_; }
-  gfx::Rect clip_rect_at_end() const { return clip_rect_at_end_; }
+  gfx::RectF clip_rect_at_end() const { return clip_rect_at_end_; }
 
  private:
-  SkCanvas* canvas_ = nullptr;
+  std::unique_ptr<ClipTrackingCanvas> canvas_;
   gfx::Rect damage_rect_at_start_;
-  gfx::Rect clip_rect_at_end_;
+  gfx::RectF clip_rect_at_end_;
 };
 
 TEST_F(SoftwareRendererTest, PartialSwap) {
   float device_scale_factor = 1.f;
   gfx::Size viewport_size(100, 100);
 
   settings_.partial_swap_enabled = true;
 
   auto device_owned = base::MakeUnique<PartialSwapSoftwareOutputDevice>();
   auto* device = device_owned.get();
@@ skipping 10 matching lines @@
   // Partial frame, we should pass this rect to the SoftwareOutputDevice.
   // partial swap is enabled.
   root_pass->damage_rect = gfx::Rect(2, 2, 3, 3);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
   renderer()->DrawFrame(&list, device_scale_factor, viewport_size);
 
   // The damage rect should be reported to the SoftwareOutputDevice.
   EXPECT_EQ(gfx::Rect(2, 2, 3, 3), device->damage_rect_at_start());
   // The SkCanvas should be clipped to the damage rect.
-  EXPECT_EQ(gfx::Rect(2, 2, 3, 3), device->clip_rect_at_end());
+  EXPECT_EQ(gfx::RectF(2, 2, 3, 3), device->clip_rect_at_end());
 }
 
 }  // namespace
 }  // namespace cc