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

gfx/skia/trunk/src/gpu/GrSWMaskHelper.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/gpu/GrSWMaskHelper.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 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrSWMaskHelper.h"
 #include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "SkStrokeRec.h"
 // TODO: try to remove this #include
 #include "GrContext.h"
 namespace {
 /*
  * Convert a boolean operation into a transfer mode code
  */
 SkXfermode::Mode op_to_mode(SkRegion::Op op) {
     static const SkXfermode::Mode modeMap[] = {
         SkXfermode::kDstOut_Mode,   // kDifference_Op
         SkXfermode::kModulate_Mode, // kIntersect_Op
         SkXfermode::kSrcOver_Mode,  // kUnion_Op
         SkXfermode::kXor_Mode,      // kXOR_Op
         SkXfermode::kClear_Mode,    // kReverseDifference_Op
         SkXfermode::kSrc_Mode,      // kReplace_Op
     };
     return modeMap[op];
 }
 }
 /**
  * Draw a single rect element of the clip stack into the accumulation bitmap
  */
 void GrSWMaskHelper::draw(const SkRect& rect, SkRegion::Op op,
                           bool antiAlias, uint8_t alpha) {
     SkPaint paint;
     SkXfermode* mode = SkXfermode::Create(op_to_mode(op));
     paint.setXfermode(mode);
     paint.setAntiAlias(antiAlias);
     paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
     fDraw.drawRect(rect, paint);
     SkSafeUnref(mode);
 }
 /**
  * Draw a single path element of the clip stack into the accumulation bitmap
  */
 void GrSWMaskHelper::draw(const SkPath& path, const SkStrokeRec& stroke, SkRegion::Op op,
                           bool antiAlias, uint8_t alpha) {
     SkPaint paint;
     if (stroke.isHairlineStyle()) {
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(SK_Scalar1);
     } else {
         if (stroke.isFillStyle()) {
             paint.setStyle(SkPaint::kFill_Style);
         } else {
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeJoin(stroke.getJoin());
             paint.setStrokeCap(stroke.getCap());
             paint.setStrokeWidth(stroke.getWidth());
         }
     }
     paint.setAntiAlias(antiAlias);
     if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
         SkASSERT(0xFF == paint.getAlpha());
         fDraw.drawPathCoverage(path, paint);
     } else {
         paint.setXfermodeMode(op_to_mode(op));
         paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
         fDraw.drawPath(path, paint);
     }
 }
 bool GrSWMaskHelper::init(const SkIRect& resultBounds,
                           const SkMatrix* matrix) {
     if (NULL != matrix) {
         fMatrix = *matrix;
     } else {
         fMatrix.setIdentity();
     }
     // Now translate so the bound's UL corner is at the origin
     fMatrix.postTranslate(-resultBounds.fLeft * SK_Scalar1,
                           -resultBounds.fTop * SK_Scalar1);
     SkIRect bounds = SkIRect::MakeWH(resultBounds.width(),
                                      resultBounds.height());
     if (!fBM.allocPixels(SkImageInfo::MakeA8(bounds.fRight, bounds.fBottom))) {
         return false;
     }
     sk_bzero(fBM.getPixels(), fBM.getSafeSize());
     sk_bzero(&fDraw, sizeof(fDraw));
     fRasterClip.setRect(bounds);
     fDraw.fRC    = &fRasterClip;
     fDraw.fClip  = &fRasterClip.bwRgn();
     fDraw.fMatrix = &fMatrix;
     fDraw.fBitmap = &fBM;
     return true;
 }
 /**
  * Get a texture (from the texture cache) of the correct size & format.
  * Return true on success; false on failure.
  */
 bool GrSWMaskHelper::getTexture(GrAutoScratchTexture* texture) {
     GrTextureDesc desc;
     desc.fWidth = fBM.width();
     desc.fHeight = fBM.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
     texture->set(fContext, desc);
     return NULL != texture->texture();
 }
 /**
  * Move the result of the software mask generation back to the gpu
  */
 void GrSWMaskHelper::toTexture(GrTexture *texture) {
     SkAutoLockPixels alp(fBM);
     // If we aren't reusing scratch textures we don't need to flush before
     // writing since no one else will be using 'texture'
     bool reuseScratch = fContext->getGpu()->caps()->reuseScratchTextures();
     // Since we're uploading to it, 'texture' shouldn't have a render target.
     SkASSERT(NULL == texture->asRenderTarget());
     texture->writePixels(0, 0, fBM.width(), fBM.height(),
                          kAlpha_8_GrPixelConfig,
                          fBM.getPixels(), fBM.rowBytes(),
                          reuseScratch ? 0 : GrContext::kDontFlush_PixelOpsFlag);
 }
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * Software rasterizes path to A8 mask (possibly using the context's matrix)
  * and uploads the result to a scratch texture. Returns the resulting
  * texture on success; NULL on failure.
  */
 GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context,
                                                  const SkPath& path,
                                                  const SkStrokeRec& stroke,
                                                  const SkIRect& resultBounds,
                                                  bool antiAlias,
                                                  SkMatrix* matrix) {
     GrAutoScratchTexture ast;
     GrSWMaskHelper helper(context);
     if (!helper.init(resultBounds, matrix)) {
         return NULL;
     }
     helper.draw(path, stroke, SkRegion::kReplace_Op, antiAlias, 0xFF);
     if (!helper.getTexture(&ast)) {
         return NULL;
     }
     helper.toTexture(ast.texture());
     return ast.detach();
 }
 void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture,
                                               GrDrawTarget* target,
                                               const SkIRect& rect) {
     GrDrawState* drawState = target->drawState();
     GrDrawState::AutoViewMatrixRestore avmr;
     if (!avmr.setIdentity(drawState)) {
         return;
     }
     GrDrawState::AutoRestoreEffects are(drawState);
     SkRect dstRect = SkRect::MakeLTRB(SK_Scalar1 * rect.fLeft,
                                       SK_Scalar1 * rect.fTop,
                                       SK_Scalar1 * rect.fRight,
                                       SK_Scalar1 * rect.fBottom);
     // We want to use device coords to compute the texture coordinates. We set our matrix to be
     // equal to the view matrix followed by a translation so that the top-left of the device bounds
     // maps to 0,0, and then a scaling matrix to normalized coords. We apply this matrix to the
     // vertex positions rather than local coords.
     SkMatrix maskMatrix;
     maskMatrix.setIDiv(texture->width(), texture->height());
     maskMatrix.preTranslate(SkIntToScalar(-rect.fLeft), SkIntToScalar(-rect.fTop));
     maskMatrix.preConcat(drawState->getViewMatrix());
     drawState->addCoverageEffect(
                          GrSimpleTextureEffect::Create(texture,
                                                        maskMatrix,
                                                        GrTextureParams::kNone_FilterMode,
                                                        kPosition_GrCoordSet))->unref();
     target->drawSimpleRect(dstRect);
 }

The Tor Browser / annotate

gfx/skia/trunk/src/gpu/GrSWMaskHelper.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/gpu/GrSWMaskHelper.cpp