src/pdf/SkPDFShader.cpp - Issue 944643002: PDF: Now threadsafe!

Unified Diff: src/pdf/SkPDFShader.cpp

Issue 944643002: PDF: Now threadsafe! (Closed) Base URL: https://skia.googlesource.com/skia.git@master

Patch Set: formatting Created 5 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: src/pdf/SkPDFShader.cpp

diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp

index e9283bc2756f98d333c9d0de2344206e91f29f7b..f94369bef9f06ddefdfbedb2472183e290807fb5 100644

--- a/src/pdf/SkPDFShader.cpp

+++ b/src/pdf/SkPDFShader.cpp

@@ -507,13 +507,12 @@ private:

////////////////////////////////////////////////////////////////////////////////

-SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)

- : SkPDFDict("Pattern"), fShaderState(state) {}

+SkPDFFunctionShader::SkPDFFunctionShader(SkPDFCanon* canon,

+ SkPDFShader::State* state)

+ : SkPDFDict("Pattern"), fCanon(canon), fShaderState(state) {}

SkPDFFunctionShader::~SkPDFFunctionShader() {

- SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());

- SkPDFCanon::GetCanon().removeFunctionShader(this);

- lock.release();

+ fCanon->removeFunctionShader(this);

fResources.unrefAll();

}

@@ -523,38 +522,36 @@ bool SkPDFFunctionShader::equals(const SkPDFShader::State& state) const {

////////////////////////////////////////////////////////////////////////////////

-SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)

- : fShaderState(state) {}

+SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFCanon* canon,

+ SkPDFShader::State* state)

+ : fCanon(canon), fShaderState(state) {}

bool SkPDFAlphaFunctionShader::equals(const SkPDFShader::State& state) const {

return state == *fShaderState;

}

SkPDFAlphaFunctionShader::~SkPDFAlphaFunctionShader() {

- SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());

- SkPDFCanon::GetCanon().removeAlphaShader(this);

+ fCanon->removeAlphaShader(this);

}

////////////////////////////////////////////////////////////////////////////////

-SkPDFImageShader::SkPDFImageShader(SkPDFShader::State* state)

- : fShaderState(state) {}

+SkPDFImageShader::SkPDFImageShader(SkPDFCanon* canon, SkPDFShader::State* state)

+ : fCanon(canon), fShaderState(state) {}

bool SkPDFImageShader::equals(const SkPDFShader::State& state) const {

return state == *fShaderState;

}

SkPDFImageShader::~SkPDFImageShader() {

- SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());

- SkPDFCanon::GetCanon().removeImageShader(this);

- lock.release();

+ fCanon->removeImageShader(this);

fResources.unrefAll();

}

////////////////////////////////////////////////////////////////////////////////

static SkPDFObject* get_pdf_shader_by_state(

- SkAutoTDelete<SkPDFShader::State>* autoState) {

+ SkPDFCanon* canon, SkAutoTDelete<SkPDFShader::State>* autoState) {

const SkPDFShader::State& state = **autoState;

if (state.fType == SkShader::kNone_GradientType && state.fImage.isNull()) {

// TODO(vandebo) This drops SKComposeShader on the floor. We could

@@ -563,28 +560,30 @@ static SkPDFObject* get_pdf_shader_by_state(

// second shader, then applying the layer to the original drawing.

return NULL;

} else if (state.fType == SkShader::kNone_GradientType) {

- SkPDFObject* shader = SkPDFCanon::GetCanon().findImageShader(state);

- return shader ? SkRef(shader) : SkPDFImageShader::Create(autoState);

+ SkPDFObject* shader = canon->findImageShader(state);

+ return shader ? SkRef(shader)

+ : SkPDFImageShader::Create(canon, autoState);

} else if (state.GradientHasAlpha()) {

- SkPDFObject* shader = SkPDFCanon::GetCanon().findAlphaShader(state);

+ SkPDFObject* shader = canon->findAlphaShader(state);

return shader ? SkRef(shader)

- : SkPDFAlphaFunctionShader::Create(autoState);

+ : SkPDFAlphaFunctionShader::Create(canon, autoState);

} else {

- SkPDFObject* shader = SkPDFCanon::GetCanon().findFunctionShader(state);

- return shader ? SkRef(shader) : SkPDFFunctionShader::Create(autoState);

+ SkPDFObject* shader = canon->findFunctionShader(state);

+ return shader ? SkRef(shader)

+ : SkPDFFunctionShader::Create(canon, autoState);

}

// static

-SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,

+SkPDFObject* SkPDFShader::GetPDFShader(SkPDFCanon* canon,

+ const SkShader& shader,

const SkMatrix& matrix,

const SkIRect& surfaceBBox,

SkScalar rasterScale) {

// There is only one mutex becasue we don't know which one we'll need.

- SkAutoMutexAcquire lock(SkPDFCanon::GetShaderMutex());

SkAutoTDelete<SkPDFShader::State> state(

SkNEW_ARGS(State, (shader, matrix, surfaceBBox, rasterScale)));

- return get_pdf_shader_by_state(&state);

+ return get_pdf_shader_by_state(canon, &state);

}

static SkPDFResourceDict* get_gradient_resource_dict(

@@ -647,14 +646,14 @@ static SkStream* create_pattern_fill_content(int gsIndex, SkRect& bounds) {

* luminosity mode. The shader pattern extends to the bbox.

static SkPDFGraphicState* create_smask_graphic_state(

- const SkPDFShader::State& state) {

+ SkPDFCanon* canon, const SkPDFShader::State& state) {

SkRect bbox;

bbox.set(state.fBBox);

SkAutoTDelete<SkPDFShader::State> alphaToLuminosityState(

state.CreateAlphaToLuminosityState());

SkAutoTUnref<SkPDFObject> luminosityShader(

- get_pdf_shader_by_state(&alphaToLuminosityState));

+ get_pdf_shader_by_state(canon, &alphaToLuminosityState));

SkAutoTDelete<SkStream> alphaStream(create_pattern_fill_content(-1, bbox));

@@ -670,24 +669,25 @@ static SkPDFGraphicState* create_smask_graphic_state(

}

SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create(

- SkAutoTDelete<SkPDFShader::State>* autoState) {

+ SkPDFCanon* canon, SkAutoTDelete<SkPDFShader::State>* autoState) {

const SkPDFShader::State& state = **autoState;

SkRect bbox;

bbox.set(state.fBBox);

SkAutoTDelete<SkPDFShader::State> opaqueState(state.CreateOpaqueState());

- SkPDFObject* colorShader = get_pdf_shader_by_state(&opaqueState);

+ SkPDFObject* colorShader = get_pdf_shader_by_state(canon, &opaqueState);

if (!colorShader) {

return NULL;

}

// Create resource dict with alpha graphics state as G0 and

// pattern shader as P0, then write content stream.

- SkAutoTUnref<SkPDFGraphicState> alphaGs(create_smask_graphic_state(state));

+ SkAutoTUnref<SkPDFGraphicState> alphaGs(

+ create_smask_graphic_state(canon, state));

SkPDFAlphaFunctionShader* alphaFunctionShader =

- SkNEW_ARGS(SkPDFAlphaFunctionShader, (autoState->detach()));

+ SkNEW_ARGS(SkPDFAlphaFunctionShader, (canon, autoState->detach()));

alphaFunctionShader->fColorShader.reset(colorShader);

@@ -701,7 +701,7 @@ SkPDFAlphaFunctionShader* SkPDFAlphaFunctionShader::Create(

populate_tiling_pattern_dict(alphaFunctionShader, bbox,

alphaFunctionShader->fResourceDict.get(),

SkMatrix::I());

- SkPDFCanon::GetCanon().addAlphaShader(alphaFunctionShader);

+ canon->addAlphaShader(alphaFunctionShader);

return alphaFunctionShader;

}

@@ -774,7 +774,7 @@ static SkPDFStream* make_ps_function(const SkString& psCode,

}

SkPDFFunctionShader* SkPDFFunctionShader::Create(

- SkAutoTDelete<SkPDFShader::State>* autoState) {

+ SkPDFCanon* canon, SkAutoTDelete<SkPDFShader::State>* autoState) {

const SkPDFShader::State& state = **autoState;

SkString (*codeFunction)(const SkShader::GradientInfo& info,

@@ -893,7 +893,7 @@ SkPDFFunctionShader* SkPDFFunctionShader::Create(

SkPDFUtils::MatrixToArray(finalMatrix));

SkPDFFunctionShader* pdfFunctionShader =

- SkNEW_ARGS(SkPDFFunctionShader, (autoState->detach()));

+ SkNEW_ARGS(SkPDFFunctionShader, (canon, autoState->detach()));

pdfFunctionShader->fResources.push(function);

// Pass ownership to resource list.

@@ -902,12 +902,12 @@ SkPDFFunctionShader* SkPDFFunctionShader::Create(

pdfFunctionShader->insert("Matrix", matrixArray.get());

pdfFunctionShader->insert("Shading", pdfShader.get());

- SkPDFCanon::GetCanon().addFunctionShader(pdfFunctionShader);

+ canon->addFunctionShader(pdfFunctionShader);

return pdfFunctionShader;

}

SkPDFImageShader* SkPDFImageShader::Create(

- SkAutoTDelete<SkPDFShader::State>* autoState) {

+ SkPDFCanon* canon, SkAutoTDelete<SkPDFShader::State>* autoState) {

const SkPDFShader::State& state = **autoState;

state.fImage.lockPixels();

@@ -949,8 +949,10 @@ SkPDFImageShader* SkPDFImageShader::Create(

SkScalarRoundToInt(deviceBounds.height()));

// TODO(edisonn): should we pass here the DCT encoder of the destination device?

// TODO(edisonn): NYI Perspective, use SkPDFDeviceFlattener.

- SkPDFDevice pattern(size, size, unflip);

- SkCanvas canvas(&pattern);

+ const SkScalar dpi = 72.0f; /*TODO: get this right*/

mtklein 2015/02/19 23:50:38 Is that, pull it from the device instead of making

hal.canary 2015/02/20 01:22:28 I meant to do that. Done

+ SkAutoTUnref<SkPDFDevice> patternDevice(

+ SkPDFDevice::CreateUnflipped(size, dpi, canon));

+ SkCanvas canvas(patternDevice.get());

SkRect patternBBox;

image->getBounds(&patternBBox);

@@ -1108,18 +1110,18 @@ SkPDFImageShader* SkPDFImageShader::Create(

}

// Put the canvas into the pattern stream (fContent).

- SkAutoTDelete<SkStream> content(pattern.content());

+ SkAutoTDelete<SkStream> content(patternDevice->content());

SkPDFImageShader* imageShader =

- SkNEW_ARGS(SkPDFImageShader, (autoState->detach()));

+ SkNEW_ARGS(SkPDFImageShader, (canon, autoState->detach()));

imageShader->setData(content.get());

populate_tiling_pattern_dict(imageShader, patternBBox,

- pattern.getResourceDict(), finalMatrix);

+ patternDevice->getResourceDict(), finalMatrix);

imageShader->fShaderState->fImage.unlockPixels();

- SkPDFCanon::GetCanon().addImageShader(imageShader);

+ canon->addImageShader(imageShader);

return imageShader;

}

« src/pdf/SkPDFGraphicState.cpp ('K') | « src/pdf/SkPDFShader.h ('k') | tests/AnnotationTest.cpp » ('j') | no next file with comments »