remove SkScalarCompare type and header

src/core/SkCanvas.cpp

 
 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkCanvas.h"
 #include "SkBitmapDevice.h"
 #include "SkBounder.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDraw.h"
 #include "SkDrawFilter.h"
 #include "SkDrawLooper.h"
 #include "SkMetaData.h"
 #include "SkPathOps.h"
 #include "SkPicture.h"
 #include "SkRasterClip.h"
 #include "SkRRect.h"
-#include "SkScalarCompare.h"
 #include "SkSurface_Base.h"
 #include "SkTemplates.h"
 #include "SkTextFormatParams.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 
 #if SK_SUPPORT_GPU
 #include "GrRenderTarget.h"
 #endif
 
@@ skipping 445 matching lines @@
     while (looper.next(type)) {                                     \
         SkAutoBounderCommit ac(fBounder);                           \
         SkDrawIter          iter(this);
 
 #define LOOPER_END    }
 
 ////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkCanvas::init(SkBaseDevice* device) {
     fBounder = NULL;
-    fLocalBoundsCompareType.setEmpty();
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBounds.setEmpty();
+    fCachedLocalClipBoundsDirty = true;
     fAllowSoftClip = true;
     fAllowSimplifyClip = false;
     fDeviceCMDirty = false;
     fSaveLayerCount = 0;
     fMetaData = NULL;
 
     fMCRec = (MCRec*)fMCStack.push_back();
     new (fMCRec) MCRec(NULL, 0);
 
     fMCRec->fLayer = SkNEW_ARGS(DeviceCM, (NULL, 0, 0, NULL, NULL));
@@ skipping 390 matching lines @@
     // check for underflow
     if (fMCStack.count() > 1) {
         this->internalRestore();
     }
 }
 
 void SkCanvas::internalRestore() {
     SkASSERT(fMCStack.count() != 0);
 
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
 
     if (SkCanvas::kClip_SaveFlag & fMCRec->fFlags) {
         fClipStack.restore();
     }
 
     // reserve our layer (if any)
     DeviceCM* layer = fMCRec->fLayer;   // may be null
     // now detach it from fMCRec so we can pop(). Gets freed after its drawn
     fMCRec->fLayer = NULL;
 
@@ skipping 138 matching lines @@
             iter.fDevice->drawSprite(iter, bitmap, pos.x(), pos.y(), *paint);
         }
     }
     LOOPER_END
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 bool SkCanvas::translate(SkScalar dx, SkScalar dy) {
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     return fMCRec->fMatrix->preTranslate(dx, dy);
 }
 
 bool SkCanvas::scale(SkScalar sx, SkScalar sy) {
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     return fMCRec->fMatrix->preScale(sx, sy);
 }
 
 bool SkCanvas::rotate(SkScalar degrees) {
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     return fMCRec->fMatrix->preRotate(degrees);
 }
 
 bool SkCanvas::skew(SkScalar sx, SkScalar sy) {
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     return fMCRec->fMatrix->preSkew(sx, sy);
 }
 
 bool SkCanvas::concat(const SkMatrix& matrix) {
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     return fMCRec->fMatrix->preConcat(matrix);
 }
 
 void SkCanvas::setMatrix(const SkMatrix& matrix) {
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     *fMCRec->fMatrix = matrix;
 }
 
 // this is not virtual, so it must call a virtual method so that subclasses
 // will see its action
 void SkCanvas::resetMatrix() {
     SkMatrix matrix;
 
     matrix.reset();
     this->setMatrix(matrix);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 bool SkCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
 #ifdef SK_ENABLE_CLIP_QUICKREJECT
     if (SkRegion::kIntersect_Op == op) {
         if (fMCRec->fRasterClip->isEmpty()) {
             return false;
         }
 
         if (this->quickReject(rect)) {
             fDeviceCMDirty = true;
-            fLocalBoundsCompareTypeDirty = true;
+            fCachedLocalClipBoundsDirty = true;
 
             fClipStack.clipEmpty();
             return fMCRec->fRasterClip->setEmpty();
         }
     }
 #endif
 
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     doAA &= fAllowSoftClip;
 
     if (fMCRec->fMatrix->rectStaysRect()) {
         // for these simpler matrices, we can stay a rect even after applying
         // the matrix. This means we don't have to a) make a path, and b) tell
         // the region code to scan-convert the path, only to discover that it
         // is really just a rect.
         SkRect      r;
 
         fMCRec->fMatrix->mapRect(&r, rect);
@@ skipping 64 matching lines @@
 
 bool SkCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
 #ifdef SK_ENABLE_CLIP_QUICKREJECT
     if (SkRegion::kIntersect_Op == op && !path.isInverseFillType()) {
         if (fMCRec->fRasterClip->isEmpty()) {
             return false;
         }
 
         if (this->quickReject(path.getBounds())) {
             fDeviceCMDirty = true;
-            fLocalBoundsCompareTypeDirty = true;
+            fCachedLocalClipBoundsDirty = true;
 
             fClipStack.clipEmpty();
             return fMCRec->fRasterClip->setEmpty();
         }
     }
 #endif
 
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
     doAA &= fAllowSoftClip;
 
     SkPath devPath;
     path.transform(*fMCRec->fMatrix, &devPath);
 
     // Check if the transfomation, or the original path itself
     // made us empty. Note this can also happen if we contained NaN
     // values. computing the bounds detects this, and will set our
     // bounds to empty if that is the case. (see SkRect::set(pts, count))
     if (devPath.getBounds().isEmpty()) {
@@ skipping 112 matching lines @@
                 SkASSERT(0); // unhandled op?
         }
     }
     return true;
 }
 
 bool SkCanvas::clipRegion(const SkRegion& rgn, SkRegion::Op op) {
     AutoValidateClip avc(this);
 
     fDeviceCMDirty = true;
-    fLocalBoundsCompareTypeDirty = true;
+    fCachedLocalClipBoundsDirty = true;
 
     // todo: signal fClipStack that we have a region, and therefore (I guess)
     // we have to ignore it, and use the region directly?
     fClipStack.clipDevRect(rgn.getBounds(), op);
 
     return fMCRec->fRasterClip->op(rgn, op);
 }
 
 #ifdef SK_DEBUG
 void SkCanvas::validateClip() const {
@@ skipping 52 matching lines @@
                 break;
             case SkClipStack::Element::kEmpty_Type:
                 visitor->clipRect(kEmpty, SkRegion::kIntersect_Op, false);
                 break;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkCanvas::computeLocalClipBoundsCompareType() const {
-    SkRect r;
-
-    if (!this->getClipBounds(&r)) {
-        fLocalBoundsCompareType.setEmpty();
-    } else {
-        fLocalBoundsCompareType.set(SkScalarToCompareType(r.fLeft),
-                                    SkScalarToCompareType(r.fTop),
-                                    SkScalarToCompareType(r.fRight),
-                                    SkScalarToCompareType(r.fBottom));
-    }
-}
-
 bool SkCanvas::quickReject(const SkRect& rect) const {
 
     if (!rect.isFinite())
         return true;
 
     if (fMCRec->fRasterClip->isEmpty()) {
         return true;
     }
 
     if (fMCRec->fMatrix->hasPerspective()) {
         SkRect dst;
         fMCRec->fMatrix->mapRect(&dst, rect);
         SkIRect idst;
         dst.roundOut(&idst);
         return !SkIRect::Intersects(idst, fMCRec->fRasterClip->getBounds());
     } else {
-        const SkRectCompareType& clipR = this->getLocalClipBoundsCompareType();
+        const SkRect& clipR = this->getLocalClipBounds();
 
         // for speed, do the most likely reject compares first
-        SkScalarCompareType userT = SkScalarToCompareType(rect.fTop);
-        SkScalarCompareType userB = SkScalarToCompareType(rect.fBottom);
-        if (userT >= clipR.fBottom || userB <= clipR.fTop) {
+        // TODO: should we use | instead, or compare all 4 at once?
+        if (rect.fTop >= clipR.fBottom || rect.fBottom <= clipR.fTop) {
             return true;
         }
-        SkScalarCompareType userL = SkScalarToCompareType(rect.fLeft);
-        SkScalarCompareType userR = SkScalarToCompareType(rect.fRight);
-        if (userL >= clipR.fRight || userR <= clipR.fLeft) {
+        if (rect.fLeft >= clipR.fRight || rect.fRight <= clipR.fLeft) {
             return true;
         }
         return false;
     }
 }
 
 bool SkCanvas::quickReject(const SkPath& path) const {
     return path.isEmpty() || this->quickReject(path.getBounds());
 }
 
@@ skipping 744 matching lines @@
     return *paint;
 }
 
 const SkRegion& SkCanvas::LayerIter::clip() const { return fImpl->getClip(); }
 int SkCanvas::LayerIter::x() const { return fImpl->getX(); }
 int SkCanvas::LayerIter::y() const { return fImpl->getY(); }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkCanvas::ClipVisitor::~ClipVisitor() { }