Support rrect clips in analysis canvas

skia/ext/analysis_canvas.cc

 // Copyright (c) 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 "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkDraw.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRRect.h"
@@ skipping 392 matching lines @@
   INHERITED::onClipRect(rect, op, edge_style);
 }
 
 void AnalysisCanvas::onClipPath(const SkPath& path,
                                 SkRegion::Op op,
                                 ClipEdgeStyle edge_style) {
   OnComplexClip();
   INHERITED::onClipRect(path.getBounds(), op, edge_style);
 }
 
+SkRect toDeviceSpace(const SkVector& scale,

[f(malita), 2016/10/25 13:26:25]

SkMatrix::mapRectScaleTranslate()?

(see below)

+                     const SkVector& translate,
+                     const SkRect& src) {
+  SkRect result = SkRect::MakeLTRB(src.fLeft * scale.fX + translate.fX,
+                                   src.fTop * scale.fY + translate.fY,
+                                   src.fRight * scale.fX + translate.fX,
+                                   src.fBottom * scale.fY + translate.fY);
+
+  if (result.fLeft > result.fRight)
+    std::swap(result.fLeft, result.fRight);
+
+  if (result.fTop > result.fBottom)
+    std::swap(result.fTop, result.fBottom);
+
+  return result;
+}
+
+bool doesCoverCanvas(const SkRRect& rr,
+                     const SkMatrix& total_matrix,
+                     const SkIRect& clip_device_bounds) {
+  // We cannot handle non axis aligned rectangles at the moment.
+  if (!total_matrix.isScaleTranslate()) {
+    return false;
+  }
+
+  const SkRect& bounding_rect = rr.rect();
+
+  // We inline the implementation of mapping and scaling to device space for
+  // the fast path. We also inline here so that we can reuse intermediate
+  // results for scaling multiple rects.
+  float sx = total_matrix.getScaleX();
+  float sy = total_matrix.getScaleY();
+  float tx = total_matrix.getTranslateX();
+  float ty = total_matrix.getTranslateY();
+
+  SkVector scale =
+      SkVector::Make(total_matrix.getScaleX(), total_matrix.getScaleY());
+  SkVector translate = SkVector::Make(total_matrix.getTranslateX(),
+                                      total_matrix.getTranslateY());
+
+  const SkVector& ul_radii = rr.radii(SkRRect::kUpperLeft_Corner);
+  const SkVector& ur_radii = rr.radii(SkRRect::kUpperRight_Corner);
+  const SkVector& ll_radii = rr.radii(SkRRect::kLowerLeft_Corner);
+  const SkVector& lr_radii = rr.radii(SkRRect::kLowerRight_Corner);
+
+  SkRect ul_device_rect =
+      toDeviceSpace(scale, translate,

[f(malita), 2016/10/25 13:26:25]

total_matrix.mapRectScaleTranslate(&ul_device_rect, ...)?

+                    SkRect::MakeLTRB(bounding_rect.fLeft, bounding_rect.fTop,
+                                     bounding_rect.fLeft + ul_radii.fX,
+                                     bounding_rect.fTop + ul_radii.fY));
+
+  SkRect ur_device_rect =
+      toDeviceSpace(scale, translate,

[f(malita), 2016/10/25 13:26:25]

ditto

+                    SkRect::MakeLTRB(bounding_rect.fRight - ur_radii.fX,
+                                     bounding_rect.fTop, bounding_rect.fRight,
+                                     bounding_rect.fTop + ur_radii.fY));
+
+  SkRect ll_device_rect = toDeviceSpace(

[f(malita), 2016/10/25 13:26:25]

ditto

+      scale, translate,
+      SkRect::MakeLTRB(bounding_rect.fLeft, bounding_rect.fBottom - ll_radii.fY,
+                       bounding_rect.fLeft + ll_radii.fX,
+                       bounding_rect.fBottom));
+
+  SkRect lr_device_rect = toDeviceSpace(

[f(malita), 2016/10/25 13:26:25]

ditto

+      scale, translate,
+      SkRect::MakeLTRB(bounding_rect.fRight - lr_radii.fX,
+                       bounding_rect.fBottom - lr_radii.fY,
+                       bounding_rect.fRight, bounding_rect.fBottom));
+
+  SkRect bounding_device_rect = toDeviceSpace(scale, translate, bounding_rect);

[f(malita), 2016/10/25 13:26:25]

ditto

+
+  if (!bounding_device_rect.isFinite() || !ul_device_rect.isFinite() ||
+      !ur_device_rect.isFinite() || !ll_device_rect.isFinite() ||
+      !lr_device_rect.isFinite()) {
+    return false;
+  }
+
+  SkRect clip_device_rect = SkRect::MakeFromIRect(clip_device_bounds);
+
+  return bounding_device_rect.contains(clip_device_rect) &&
+         !SkRect::Intersects(ul_device_rect, clip_device_rect) &&
+         !SkRect::Intersects(ur_device_rect, clip_device_rect) &&
+         !SkRect::Intersects(ll_device_rect, clip_device_rect) &&
+         !SkRect::Intersects(lr_device_rect, clip_device_rect);

[f(malita), 2016/10/25 13:26:25]

Not quite the same thing, but wouldn't it be sufficient to check containment
against the inner rect (the equivalent of FloatRoundedRect::radiusCenterRect)?

Then we only have to map/check 1 rect instead of 5.

Or better yet, inverse-map clip_device_bounds and just use
SkRRect::contains(const SkRect&)?

+}
+
 void AnalysisCanvas::onClipRRect(const SkRRect& rrect,
                                  SkRegion::Op op,
                                  ClipEdgeStyle edge_style) {
+  SkIRect clip_device_bounds;
+  if (getClipDeviceBounds(&clip_device_bounds) &&
+      doesCoverCanvas(rrect, getTotalMatrix(), clip_device_bounds)) {
+    // If the canvas is fully contained within the clip, it is as if we weren't
+    // clipped at all, so bail early.
+    return;
+  }
+
   OnComplexClip();
   INHERITED::onClipRect(rrect.getBounds(), op, edge_style);
 }
 
 void AnalysisCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
   const ClipEdgeStyle edge_style = kHard_ClipEdgeStyle;
   if (deviceRgn.isRect()) {
     onClipRect(SkRect::MakeFromIRect(deviceRgn.getBounds()), op, edge_style);
     return;
   }
@@ skipping 60 matching lines @@
       force_not_transparent_stack_level_ = kNoLayer;
     }
   }
 
   INHERITED::willRestore();
 }
 
 }  // namespace skia