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

gfx/skia/trunk/src/effects/SkLayerRasterizer.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/effects/SkLayerRasterizer.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 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.
  */
 #include "SkLayerRasterizer.h"
 #include "SkDraw.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMask.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPathEffect.h"
 #include "../core/SkRasterClip.h"
 #include "SkXfermode.h"
 #include <new>
 struct SkLayerRasterizer_Rec {
     SkPaint     fPaint;
     SkVector    fOffset;
 };
 SkLayerRasterizer::SkLayerRasterizer()
     : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))))
 {
 }
 SkLayerRasterizer::SkLayerRasterizer(SkDeque* layers) : fLayers(layers)
 {
 }
 SkLayerRasterizer::~SkLayerRasterizer() {
     SkASSERT(fLayers);
     SkDeque::F2BIter        iter(*fLayers);
     SkLayerRasterizer_Rec*  rec;
     while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
         rec->fPaint.~SkPaint();
     SkDELETE(fLayers);
 }
 #ifdef SK_SUPPORT_LEGACY_LAYERRASTERIZER_API
 void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx,
                                  SkScalar dy) {
     SkASSERT(fLayers);
     SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back();
     SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint));
     rec->fOffset.set(dx, dy);
 }
 #endif
 static bool compute_bounds(const SkDeque& layers, const SkPath& path,
                            const SkMatrix& matrix,
                            const SkIRect* clipBounds, SkIRect* bounds) {
     SkDeque::F2BIter        iter(layers);
     SkLayerRasterizer_Rec*  rec;
     bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
     while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
         const SkPaint&  paint = rec->fPaint;
         SkPath          fillPath, devPath;
         const SkPath*   p = &path;
         if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
             paint.getFillPath(path, &fillPath);
             p = &fillPath;
         }
         if (p->isEmpty()) {
             continue;
         }
         // apply the matrix and offset
         {
             SkMatrix m = matrix;
             m.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
             p->transform(m, &devPath);
         }
         SkMask  mask;
         if (!SkDraw::DrawToMask(devPath, clipBounds, paint.getMaskFilter(),
                                 &matrix, &mask,
                                 SkMask::kJustComputeBounds_CreateMode,
                                 SkPaint::kFill_Style)) {
             return false;
         }
         bounds->join(mask.fBounds);
     }
     return true;
 }
 bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
                                     const SkIRect* clipBounds,
                                     SkMask* mask, SkMask::CreateMode mode) const {
     SkASSERT(fLayers);
     if (fLayers->empty()) {
         return false;
     }
     if (SkMask::kJustRenderImage_CreateMode != mode) {
         if (!compute_bounds(*fLayers, path, matrix, clipBounds, &mask->fBounds))
             return false;
     }
     if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) {
         mask->fFormat   = SkMask::kA8_Format;
         mask->fRowBytes = mask->fBounds.width();
         size_t size = mask->computeImageSize();
         if (0 == size) {
             return false;   // too big to allocate, abort
         }
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, size);
     }
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         SkBitmap        device;
         SkRasterClip    rectClip;
         SkDraw          draw;
         SkMatrix        translatedMatrix;  // this translates us to our local pixels
         SkMatrix        drawMatrix;        // this translates the path by each layer's offset
         rectClip.setRect(SkIRect::MakeWH(mask->fBounds.width(), mask->fBounds.height()));
         translatedMatrix = matrix;
         translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft),
                                        -SkIntToScalar(mask->fBounds.fTop));
         device.installMaskPixels(*mask);
         draw.fBitmap    = &device;
         draw.fMatrix    = &drawMatrix;
         draw.fRC        = &rectClip;
         draw.fClip      = &rectClip.bwRgn();
         // we set the matrixproc in the loop, as the matrix changes each time (potentially)
         draw.fBounder   = NULL;
         SkDeque::F2BIter        iter(*fLayers);
         SkLayerRasterizer_Rec*  rec;
         while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
             drawMatrix = translatedMatrix;
             drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY);
             draw.drawPath(path, rec->fPaint);
         }
     }
     return true;
 }
 SkLayerRasterizer::SkLayerRasterizer(SkReadBuffer& buffer)
     : SkRasterizer(buffer), fLayers(ReadLayers(buffer)) {}
 SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) {
     int count = buffer.readInt();
     SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)));
     for (int i = 0; i < count; i++) {
         SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)layers->push_back();
         SkNEW_PLACEMENT(&rec->fPaint, SkPaint);
         buffer.readPaint(&rec->fPaint);
         buffer.readPoint(&rec->fOffset);
     }
     return layers;
 }
 void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     SkASSERT(fLayers);
     buffer.writeInt(fLayers->count());
     SkDeque::F2BIter                iter(*fLayers);
     const SkLayerRasterizer_Rec*    rec;
     while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) {
         buffer.writePaint(rec->fPaint);
         buffer.writePoint(rec->fOffset);
     }
 }
 SkLayerRasterizer::Builder::Builder()
         : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))))
 {
 }
 SkLayerRasterizer::Builder::~Builder()
 {
     SkDELETE(fLayers);
 }
 void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx,
                                           SkScalar dy) {
     SkASSERT(fLayers);
     SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back();
     SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint));
     rec->fOffset.set(dx, dy);
 }
 SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() {
     SkLayerRasterizer* rasterizer = SkNEW_ARGS(SkLayerRasterizer, (fLayers));
     fLayers = NULL;
     return rasterizer;
 }

The Tor Browser / annotate

gfx/skia/trunk/src/effects/SkLayerRasterizer.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/effects/SkLayerRasterizer.cpp