The Tor Browser: gfx/skia/trunk/src/core/SkLineClipper.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/core/SkLineClipper.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/core/SkLineClipper.cpp

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 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkLineClipper.h"
 template <typename T> T pin_unsorted(T value, T limit0, T limit1) {
     if (limit1 < limit0) {
         SkTSwap(limit0, limit1);
     }
     // now the limits are sorted
     SkASSERT(limit0 <= limit1);
     if (value < limit0) {
         value = limit0;
     } else if (value > limit1) {
         value = limit1;
     }
     return value;
 }
 // return X coordinate of intersection with horizontal line at Y
 static SkScalar sect_with_horizontal(const SkPoint src[2], SkScalar Y) {
     SkScalar dy = src[1].fY - src[0].fY;
     if (SkScalarNearlyZero(dy)) {
         return SkScalarAve(src[0].fX, src[1].fX);
     } else {
         // need the extra precision so we don't compute a value that exceeds
         // our original limits
         double X0 = src[0].fX;
         double Y0 = src[0].fY;
         double X1 = src[1].fX;
         double Y1 = src[1].fY;
         double result = X0 + ((double)Y - Y0) * (X1 - X0) / (Y1 - Y0);
         // The computed X value might still exceed [X0..X1] due to quantum flux
         // when the doubles were added and subtracted, so we have to pin the
         // answer :(
         return (float)pin_unsorted(result, X0, X1);
     }
 }
 // return Y coordinate of intersection with vertical line at X
 static SkScalar sect_with_vertical(const SkPoint src[2], SkScalar X) {
     SkScalar dx = src[1].fX - src[0].fX;
     if (SkScalarNearlyZero(dx)) {
         return SkScalarAve(src[0].fY, src[1].fY);
     } else {
         // need the extra precision so we don't compute a value that exceeds
         // our original limits
         double X0 = src[0].fX;
         double Y0 = src[0].fY;
         double X1 = src[1].fX;
         double Y1 = src[1].fY;
         double result = Y0 + ((double)X - X0) * (Y1 - Y0) / (X1 - X0);
         return (float)result;
     }
 }
 ///////////////////////////////////////////////////////////////////////////////
 static inline bool nestedLT(SkScalar a, SkScalar b, SkScalar dim) {
     return a <= b && (a < b || dim > 0);
 }
 // returns true if outer contains inner, even if inner is empty.
 // note: outer.contains(inner) always returns false if inner is empty.
 static inline bool containsNoEmptyCheck(const SkRect& outer,
                                         const SkRect& inner) {
     return  outer.fLeft <= inner.fLeft && outer.fTop <= inner.fTop &&
             outer.fRight >= inner.fRight && outer.fBottom >= inner.fBottom;
 }
 bool SkLineClipper::IntersectLine(const SkPoint src[2], const SkRect& clip,
                                   SkPoint dst[2]) {
     SkRect bounds;
     bounds.set(src, 2);
     if (containsNoEmptyCheck(clip, bounds)) {
         if (src != dst) {
             memcpy(dst, src, 2 * sizeof(SkPoint));
         }
         return true;
     }
     // check for no overlap, and only permit coincident edges if the line
     // and the edge are colinear
     if (nestedLT(bounds.fRight, clip.fLeft, bounds.width()) ||
         nestedLT(clip.fRight, bounds.fLeft, bounds.width()) ||
         nestedLT(bounds.fBottom, clip.fTop, bounds.height()) ||
         nestedLT(clip.fBottom, bounds.fTop, bounds.height())) {
         return false;
     }
     int index0, index1;
     if (src[0].fY < src[1].fY) {
         index0 = 0;
         index1 = 1;
     } else {
         index0 = 1;
         index1 = 0;
     }
     SkPoint tmp[2];
     memcpy(tmp, src, sizeof(tmp));
     // now compute Y intersections
     if (tmp[index0].fY < clip.fTop) {
         tmp[index0].set(sect_with_horizontal(src, clip.fTop), clip.fTop);
     }
     if (tmp[index1].fY > clip.fBottom) {
         tmp[index1].set(sect_with_horizontal(src, clip.fBottom), clip.fBottom);
     }
     if (tmp[0].fX < tmp[1].fX) {
         index0 = 0;
         index1 = 1;
     } else {
         index0 = 1;
         index1 = 0;
     }
     // check for quick-reject in X again, now that we may have been chopped
     if ((tmp[index1].fX <= clip.fLeft || tmp[index0].fX >= clip.fRight) &&
         tmp[index0].fX < tmp[index1].fX) {
         // only reject if we have a non-zero width
         return false;
     }
     if (tmp[index0].fX < clip.fLeft) {
         tmp[index0].set(clip.fLeft, sect_with_vertical(src, clip.fLeft));
     }
     if (tmp[index1].fX > clip.fRight) {
         tmp[index1].set(clip.fRight, sect_with_vertical(src, clip.fRight));
     }
 #ifdef SK_DEBUG
     bounds.set(tmp, 2);
     SkASSERT(containsNoEmptyCheck(clip, bounds));
 #endif
     memcpy(dst, tmp, sizeof(tmp));
     return true;
 }
 #ifdef SK_DEBUG
 // return value between the two limits, where the limits are either ascending
 // or descending.
 static bool is_between_unsorted(SkScalar value,
                                 SkScalar limit0, SkScalar limit1) {
     if (limit0 < limit1) {
         return limit0 <= value && value <= limit1;
     } else {
         return limit1 <= value && value <= limit0;
     }
 }
 #endif
 #ifdef SK_DEBUG
 // This is an example of why we need to pin the result computed in
 // sect_with_horizontal. If we didn't explicitly pin, is_between_unsorted would
 // fail.
 //
 static void sect_with_horizontal_test_for_pin_results() {
     const SkPoint pts[] = {
         { -540000,    -720000 },
         { -9.10000017e-05f, 9.99999996e-13f }
     };
     float x = sect_with_horizontal(pts, 0);
     SkASSERT(is_between_unsorted(x, pts[0].fX, pts[1].fX));
 }
 #endif
 int SkLineClipper::ClipLine(const SkPoint pts[], const SkRect& clip,
                             SkPoint lines[]) {
 #ifdef SK_DEBUG
     {
         static bool gOnce;
         if (!gOnce) {
             sect_with_horizontal_test_for_pin_results();
             gOnce = true;
         }
     }
 #endif
     int index0, index1;
     if (pts[0].fY < pts[1].fY) {
         index0 = 0;
         index1 = 1;
     } else {
         index0 = 1;
         index1 = 0;
     }
     // Check if we're completely clipped out in Y (above or below
     if (pts[index1].fY <= clip.fTop) {  // we're above the clip
         return 0;
     }
     if (pts[index0].fY >= clip.fBottom) {  // we're below the clip
         return 0;
     }
     // Chop in Y to produce a single segment, stored in tmp[0..1]
     SkPoint tmp[2];
     memcpy(tmp, pts, sizeof(tmp));
     // now compute intersections
     if (pts[index0].fY < clip.fTop) {
         tmp[index0].set(sect_with_horizontal(pts, clip.fTop), clip.fTop);
         SkASSERT(is_between_unsorted(tmp[index0].fX, pts[0].fX, pts[1].fX));
     }
     if (tmp[index1].fY > clip.fBottom) {
         tmp[index1].set(sect_with_horizontal(pts, clip.fBottom), clip.fBottom);
         SkASSERT(is_between_unsorted(tmp[index1].fX, pts[0].fX, pts[1].fX));
     }
     // Chop it into 1..3 segments that are wholly within the clip in X.
     // temp storage for up to 3 segments
     SkPoint resultStorage[kMaxPoints];
     SkPoint* result;    // points to our results, either tmp or resultStorage
     int lineCount = 1;
     bool reverse;
     if (pts[0].fX < pts[1].fX) {
         index0 = 0;
         index1 = 1;
         reverse = false;
     } else {
         index0 = 1;
         index1 = 0;
         reverse = true;
     }
     if (tmp[index1].fX <= clip.fLeft) {  // wholly to the left
         tmp[0].fX = tmp[1].fX = clip.fLeft;
         result = tmp;
         reverse = false;
     } else if (tmp[index0].fX >= clip.fRight) {    // wholly to the right
         tmp[0].fX = tmp[1].fX = clip.fRight;
         result = tmp;
         reverse = false;
     } else {
         result = resultStorage;
         SkPoint* r = result;
         if (tmp[index0].fX < clip.fLeft) {
             r->set(clip.fLeft, tmp[index0].fY);
             r += 1;
             r->set(clip.fLeft, sect_with_vertical(tmp, clip.fLeft));
             SkASSERT(is_between_unsorted(r->fY, tmp[0].fY, tmp[1].fY));
         } else {
             *r = tmp[index0];
         }
         r += 1;
         if (tmp[index1].fX > clip.fRight) {
             r->set(clip.fRight, sect_with_vertical(tmp, clip.fRight));
             SkASSERT(is_between_unsorted(r->fY, tmp[0].fY, tmp[1].fY));
             r += 1;
             r->set(clip.fRight, tmp[index1].fY);
         } else {
             *r = tmp[index1];
         }
         lineCount = SkToInt(r - result);
     }
     // Now copy the results into the caller's lines[] parameter
     if (reverse) {
         // copy the pts in reverse order to maintain winding order
         for (int i = 0; i <= lineCount; i++) {
             lines[lineCount - i] = result[i];
         }
     } else {
         memcpy(lines, result, (lineCount + 1) * sizeof(SkPoint));
     }
     return lineCount;
 }

The Tor Browser / annotate

gfx/skia/trunk/src/core/SkLineClipper.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/core/SkLineClipper.cpp