remove SkScalarCompare type and header

include/core/SkCanvas.h

 
 /*
  * Copyright 2006 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.
  */
 
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
 #include "SkTypes.h"
 #include "SkBitmap.h"
 #include "SkDeque.h"
 #include "SkClipStack.h"
 #include "SkPaint.h"
 #include "SkRefCnt.h"
 #include "SkPath.h"
 #include "SkRegion.h"
-#include "SkScalarCompare.h"
 #include "SkXfermode.h"
 
 class SkBounder;
 class SkBaseDevice;
 class SkDraw;
 class SkDrawFilter;
 class SkMetaData;
 class SkPicture;
 class SkRRect;
 class SkSurface_Base;
@@ skipping 416 matching lines @@
         completely clipped out. This is a conservative calculation, meaning
         that it is possible that if the method returns false, the band may still
         in fact be clipped out, but the converse is not true. If this method
         returns true, then the band is guaranteed to be clipped out.
         @param top  The top of the horizontal band to compare with the clip
         @param bottom The bottom of the horizontal and to compare with the clip
         @return true if the horizontal band is completely clipped out (i.e. does
                      not intersect the current clip)
     */
     bool quickRejectY(SkScalar top, SkScalar bottom) const {
-        SkASSERT(SkScalarToCompareType(top) <= SkScalarToCompareType(bottom));
-        const SkRectCompareType& clipR = this->getLocalClipBoundsCompareType();
+        SkASSERT(top <= bottom);
+        const SkRect& clipR = this->getLocalClipBoundsCompareType();
         // In the case where the clip is empty and we are provided with a
         // negative top and positive bottom parameter then this test will return
         // false even though it will be clipped. We have chosen to exclude that
         // check as it is rare and would result double the comparisons.
-        return SkScalarToCompareType(top) >= clipR.fBottom
-            || SkScalarToCompareType(bottom) <= clipR.fTop;
+        return top >= clipR.fBottom || bottom <= clipR.fTop;
     }
 
     /** Return the bounds of the current clip (in local coordinates) in the
         bounds parameter, and return true if it is non-empty. This can be useful
         in a way similar to quickReject, in that it tells you that drawing
         outside of these bounds will be clipped out.
     */
     bool getClipBounds(SkRect* bounds) const;
 
     /** Return the bounds of the current clip, in device coordinates; returns
@@ skipping 617 matching lines @@
     void internalRestore();
     static void DrawRect(const SkDraw& draw, const SkPaint& paint,
                          const SkRect& r, SkScalar textSize);
     static void DrawTextDecorations(const SkDraw& draw, const SkPaint& paint,
                                     const char text[], size_t byteLength,
                                     SkScalar x, SkScalar y);
 
     /*  These maintain a cache of the clip bounds in local coordinates,
         (converted to 2s-compliment if floats are slow).
      */
-    mutable SkRectCompareType fLocalBoundsCompareType;
-    mutable bool              fLocalBoundsCompareTypeDirty;
+    mutable SkRect fCachedLocalClipBounds;
+    mutable bool   fCachedLocalClipBoundsDirty;
     bool fAllowSoftClip;
     bool fAllowSimplifyClip;
 
-    const SkRectCompareType& getLocalClipBoundsCompareType() const {
-        if (fLocalBoundsCompareTypeDirty) {
-            this->computeLocalClipBoundsCompareType();
-            fLocalBoundsCompareTypeDirty = false;
+    const SkRect& getLocalClipBoundsCompareType() const {

[f(malita), 2013/12/11 22:30:54]

Maybe rename the method to avoid "compareType"?

[reed1, 2013/12/13 21:15:25]

Done.

+        if (fCachedLocalClipBoundsDirty) {
+            if (!this->getClipBounds(&fCachedLocalClipBounds)) {
+                fCachedLocalClipBounds.setEmpty();
+            }
+            fCachedLocalClipBoundsDirty = false;
         }
-        return fLocalBoundsCompareType;
+        return fCachedLocalClipBounds;
     }
-    void computeLocalClipBoundsCompareType() const;
-
 
     class AutoValidateClip : ::SkNoncopyable {
     public:
         explicit AutoValidateClip(SkCanvas* canvas) : fCanvas(canvas) {
             fCanvas->validateClip();
         }
         ~AutoValidateClip() { fCanvas->validateClip(); }
 
     private:
         const SkCanvas* fCanvas;
@@ skipping 61 matching lines @@
             fCanvas->endCommentGroup();
         }
     }
 
 private:
     SkCanvas* fCanvas;
 };
 #define SkAutoCommentBlock(...) SK_REQUIRE_LOCAL_VAR(SkAutoCommentBlock)
 
 #endif