The Tor Browser: gfx/skia/trunk/include/core/SkRRect.h@129ffea94266 (annotated)

gfx/skia/trunk/include/core/SkRRect.h@129ffea94266 (annotated)

gfx/skia/trunk/include/core/SkRRect.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkRRect_DEFINED
 #define SkRRect_DEFINED
 #include "SkRect.h"
 #include "SkPoint.h"
 class SkPath;
 class SkMatrix;
 // Path forward:
 //   core work
 //      add validate method (all radii positive, all radii sums < rect size, etc.)
 //      add contains(SkRect&)  - for clip stack
 //      add contains(SkRRect&) - for clip stack
 //      add heart rect computation (max rect inside RR)
 //      add 9patch rect computation
 //      add growToInclude(SkPath&)
 //   analysis
 //      use growToInclude to fit skp round rects & generate stats (RRs vs. real paths)
 //      check on # of rectorus's the RRs could handle
 //   rendering work
 //      update SkPath.addRRect() to only use quads
 //      add GM and bench
 //   further out
 //      detect and triangulate RRectorii rather than falling back to SW in Ganesh
 //
 /** \class SkRRect
     The SkRRect class represents a rounded rect with a potentially different
     radii for each corner. It does not have a constructor so must be
     initialized with one of the initialization functions (e.g., setEmpty,
     setRectRadii, etc.)
     This class is intended to roughly match CSS' border-*-*-radius capabilities.
     This means:
         If either of a corner's radii are 0 the corner will be square.
         Negative radii are not allowed (they are clamped to zero).
         If the corner curves overlap they will be proportionally reduced to fit.
 */
 class SK_API SkRRect {
 public:
     /**
      * Enum to capture the various possible subtypes of RR. Accessed
      * by type(). The subtypes become progressively less restrictive.
      */
     enum Type {
         // !< Internal indicator that the sub type must be computed.
         kUnknown_Type = -1,
         // !< The RR is empty
         kEmpty_Type,
         //!< The RR is actually a (non-empty) rect (i.e., at least one radius
         //!< at each corner is zero)
         kRect_Type,
         //!< The RR is actually a (non-empty) oval (i.e., all x radii are equal
         //!< and >= width/2 and all the y radii are equal and >= height/2
         kOval_Type,
         //!< The RR is non-empty and all the x radii are equal & all y radii
         //!< are equal but it is not an oval (i.e., there are lines between
         //!< the curves) nor a rect (i.e., both radii are non-zero)
         kSimple_Type,
         //!< A fully general (non-empty) RR. Some of the x and/or y radii are
         //!< different from the others and there must be one corner where
         //!< both radii are non-zero.
         kComplex_Type,
     };
     /**
      * Returns the RR's sub type.
      */
     Type getType() const {
         SkDEBUGCODE(this->validate();)
         if (kUnknown_Type == fType) {
             this->computeType();
         }
         SkASSERT(kUnknown_Type != fType);
         return fType;
     }
     Type type() const { return this->getType(); }
     inline bool isEmpty() const { return kEmpty_Type == this->getType(); }
     inline bool isRect() const { return kRect_Type == this->getType(); }
     inline bool isOval() const { return kOval_Type == this->getType(); }
     inline bool isSimple() const { return kSimple_Type == this->getType(); }
     inline bool isSimpleCircular() const {
         return this->isSimple() && fRadii[0].fX == fRadii[0].fY;
     }
     inline bool isComplex() const { return kComplex_Type == this->getType(); }
     bool allCornersCircular() const;
     /**
      * Are both x-radii the same on the two left corners, and similar for the top, right, and
      * bottom. When this is the case the four ellipse centers form a rectangle.
      */
     bool isNinePatch() const {
         return fRadii[kUpperLeft_Corner].fX == fRadii[kLowerLeft_Corner].fX &&
                fRadii[kUpperRight_Corner].fX == fRadii[kLowerRight_Corner].fX &&
                fRadii[kUpperLeft_Corner].fY == fRadii[kUpperRight_Corner].fY &&
                fRadii[kLowerLeft_Corner].fY == fRadii[kLowerRight_Corner].fY;
     }
     SkScalar width() const { return fRect.width(); }
     SkScalar height() const { return fRect.height(); }
     /**
      * Set this RR to the empty rectangle (0,0,0,0) with 0 x & y radii.
      */
     void setEmpty() {
         fRect.setEmpty();
         memset(fRadii, 0, sizeof(fRadii));
         fType = kEmpty_Type;
         SkDEBUGCODE(this->validate();)
     }
     /**
      * Set this RR to match the supplied rect. All radii will be 0.
      */
     void setRect(const SkRect& rect) {
         if (rect.isEmpty()) {
             this->setEmpty();
             return;
         }
         fRect = rect;
         memset(fRadii, 0, sizeof(fRadii));
         fType = kRect_Type;
         SkDEBUGCODE(this->validate();)
     }
     /**
      * Set this RR to match the supplied oval. All x radii will equal half the
      * width and all y radii will equal half the height.
      */
     void setOval(const SkRect& oval) {
         if (oval.isEmpty()) {
             this->setEmpty();
             return;
         }
         SkScalar xRad = SkScalarHalf(oval.width());
         SkScalar yRad = SkScalarHalf(oval.height());
         fRect = oval;
         for (int i = 0; i < 4; ++i) {
             fRadii[i].set(xRad, yRad);
         }
         fType = kOval_Type;
         SkDEBUGCODE(this->validate();)
     }
     /**
      * Initialize the RR with the same radii for all four corners.
      */
     void setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad);
     /**
      * Initialize the RR with potentially different radii for all four corners.
      */
     void setRectRadii(const SkRect& rect, const SkVector radii[4]);
     // The radii are stored in UL, UR, LR, LL order.
     enum Corner {
         kUpperLeft_Corner,
         kUpperRight_Corner,
         kLowerRight_Corner,
         kLowerLeft_Corner
     };
     const SkRect& rect() const { return fRect; }
     const SkVector& radii(Corner corner) const { return fRadii[corner]; }
     const SkRect& getBounds() const { return fRect; }
     /**
      *  When a rrect is simple, all of its radii are equal. This returns one
      *  of those radii. This call requires the rrect to be non-complex.
      */
     const SkVector& getSimpleRadii() const {
         SkASSERT(!this->isComplex());
         return fRadii[0];
     }
     friend bool operator==(const SkRRect& a, const SkRRect& b) {
         return a.fRect == b.fRect &&
                SkScalarsEqual(a.fRadii[0].asScalars(),
                               b.fRadii[0].asScalars(), 8);
     }
     friend bool operator!=(const SkRRect& a, const SkRRect& b) {
         return a.fRect != b.fRect ||
                !SkScalarsEqual(a.fRadii[0].asScalars(),
                                b.fRadii[0].asScalars(), 8);
     }
     /**
      *  Call inset on the bounds, and adjust the radii to reflect what happens
      *  in stroking: If the corner is sharp (no curvature), leave it alone,
      *  otherwise we grow/shrink the radii by the amount of the inset. If a
      *  given radius becomes negative, it is pinned to 0.
      *
      *  It is valid for dst == this.
      */
     void inset(SkScalar dx, SkScalar dy, SkRRect* dst) const;
     void inset(SkScalar dx, SkScalar dy) {
         this->inset(dx, dy, this);
     }
     /**
      *  Call outset on the bounds, and adjust the radii to reflect what happens
      *  in stroking: If the corner is sharp (no curvature), leave it alone,
      *  otherwise we grow/shrink the radii by the amount of the inset. If a
      *  given radius becomes negative, it is pinned to 0.
      *
      *  It is valid for dst == this.
      */
     void outset(SkScalar dx, SkScalar dy, SkRRect* dst) const {
         this->inset(-dx, -dy, dst);
     }
     void outset(SkScalar dx, SkScalar dy) {
         this->inset(-dx, -dy, this);
     }
     /**
      * Translate the rrect by (dx, dy).
      */
     void offset(SkScalar dx, SkScalar dy) {
         fRect.offset(dx, dy);
     }
     /**
      *  Returns true if 'rect' is wholy inside the RR, and both
      *  are not empty.
      */
     bool contains(const SkRect& rect) const;
     SkDEBUGCODE(void validate() const;)
     enum {
         kSizeInMemory = 12 * sizeof(SkScalar)
     };
     /**
      *  Write the rrect into the specified buffer. This is guaranteed to always
      *  write kSizeInMemory bytes, and that value is guaranteed to always be
      *  a multiple of 4. Return kSizeInMemory.
      */
     size_t writeToMemory(void* buffer) const;
     /**
      * Reads the rrect from the specified buffer
      *
      * If the specified buffer is large enough, this will read kSizeInMemory bytes,
      * and that value is guaranteed to always be a multiple of 4.
      *
      * @param buffer Memory to read from
      * @param length Amount of memory available in the buffer
      * @return number of bytes read (must be a multiple of 4) or
      *         0 if there was not enough memory available
      */
     size_t readFromMemory(const void* buffer, size_t length);
     /**
      *  Transform by the specified matrix, and put the result in dst.
      *
      *  @param matrix SkMatrix specifying the transform. Must only contain
      *      scale and/or translate, or this call will fail.
      *  @param dst SkRRect to store the result. It is an error to use this,
      *      which would make this function no longer const.
      *  @return true on success, false on failure. If false, dst is unmodified.
      */
     bool transform(const SkMatrix& matrix, SkRRect* dst) const;
 private:
     SkRect fRect;
     // Radii order is UL, UR, LR, LL. Use Corner enum to index into fRadii[]
     SkVector fRadii[4];
     mutable Type fType;
     // TODO: add padding so we can use memcpy for flattening and not copy
     // uninitialized data
     void computeType() const;
     bool checkCornerContainment(SkScalar x, SkScalar y) const;
     // to access fRadii directly
     friend class SkPath;
 };
 #endif

The Tor Browser / annotate

gfx/skia/trunk/include/core/SkRRect.h@129ffea94266 (annotated)

gfx/skia/trunk/include/core/SkRRect.h