SkCanvasStateUtils Class Reference

#include <SkCanvasStateUtils.h>

Static Public Member Functions
static SkCanvasState *	CaptureCanvasState (SkCanvas *canvas)
static std::unique_ptr< SkCanvas >	MakeFromCanvasState (const SkCanvasState *state)
static void	ReleaseCanvasState (SkCanvasState *state)

Detailed Description

A set of functions that are useful for copying the state of an SkCanvas across a library boundary where the Skia library on the other side of the boundary may be newer. The expected usage is outline below...

                     Lib Boundary

CaptureCanvasState(...) ||| SkCanvas --> SkCanvasState ||| ||| CreateFromCanvasState(...) ||| SkCanvasState --> SkCanvas ||| Draw into SkCanvas ||| Unref SkCanvas` ReleaseCanvasState(...) |||

Definition at line 33 of file SkCanvasStateUtils.h.

Member Function Documentation

CaptureCanvasState()

SkCanvasState * SkCanvasStateUtils::CaptureCanvasState ( SkCanvas *  canvas )

static

Captures the current state of the canvas into an opaque ptr that is safe to pass to a different instance of Skia (which may be the same version, or may be newer). The function will return NULL in the event that one of the following conditions are true. 1) the canvas device type is not supported (currently only raster is supported) 2) the canvas clip type is not supported (currently only non-AA clips are supported)

It is recommended that the original canvas also not be used until all canvases that have been created using its captured state have been dereferenced.

Finally, it is important to note that any draw filters attached to the canvas are NOT currently captured.

Parameters

canvas

The canvas you wish to capture the current state of.

Returns

NULL or an opaque ptr that can be passed to CreateFromCanvasState to reconstruct the canvas. The caller is responsible for calling ReleaseCanvasState to free the memory associated with this state.

Definition at line 178 of file SkCanvasStateUtils.cpp.

                                                                      {
    SkASSERT(canvas);
 
    // Check the clip can be decomposed into rectangles (i.e. no soft clips).
    if (canvas->androidFramework_isClipAA()) {
        return nullptr;
    }
 
    std::unique_ptr<SkCanvasState_v1> canvasState(new SkCanvasState_v1(canvas));
 
    setup_MC_state(&canvasState->mcState, canvas->getTotalMatrix(), canvas->getDeviceClipBounds());
 
    // Historically, the canvas state could report multiple top-level layers because SkCanvas
    // supported unclipped layers. With that feature removed, all required information is contained
    // by the canvas' top-most device.
    SkDevice* device = canvas->topDevice();
    SkASSERT(device);
 
    SkSWriter32<sizeof(SkCanvasLayerState)> layerWriter;
    // we currently only work for bitmap backed devices
    SkPixmap pmap;
    if (!device->accessPixels(&pmap) || 0 == pmap.width() || 0 == pmap.height()) {
        return nullptr;
    }
    // and for axis-aligned devices (so not transformed for an image filter)
    if (!device->isPixelAlignedToGlobal()) {
        return nullptr;
    }
 
    SkIPoint origin = device->getOrigin(); // safe since it's pixel aligned
 
    SkCanvasLayerState* layerState =
            (SkCanvasLayerState*) layerWriter.reserve(sizeof(SkCanvasLayerState));
    layerState->type = kRaster_CanvasBackend;
    layerState->x = origin.x();
    layerState->y = origin.y();
    layerState->width = pmap.width();
    layerState->height = pmap.height();
 
    switch (pmap.colorType()) {
        case kN32_SkColorType:
            layerState->raster.config = kARGB_8888_RasterConfig;
            break;
        case kRGB_565_SkColorType:
            layerState->raster.config = kRGB_565_RasterConfig;
            break;
        default:
            return nullptr;
    }
    layerState->raster.rowBytes = pmap.rowBytes();
    layerState->raster.pixels = pmap.writable_addr();
 
    setup_MC_state(&layerState->mcState, device->localToDevice(), device->devClipBounds());
 
    // allocate memory for the layers and then and copy them to the struct
    SkASSERT(layerWriter.bytesWritten() == sizeof(SkCanvasLayerState));
    canvasState->layerCount = 1;
    canvasState->layers = (SkCanvasLayerState*) sk_malloc_throw(layerWriter.bytesWritten());
    layerWriter.flatten(canvasState->layers);
 
    return canvasState.release();
}

MakeFromCanvasState()

std::unique_ptr< SkCanvas > SkCanvasStateUtils::MakeFromCanvasState ( const SkCanvasState *  state )

static

Create a new SkCanvas from the captured state of another SkCanvas. The function will return NULL in the event that one of the following conditions are true. 1) the captured state is in an unrecognized format 2) the captured canvas device type is not supported

Parameters

state

Opaque object created by CaptureCanvasState.

Returns

NULL or an SkCanvas* whose devices and matrix/clip state are identical to the captured canvas. The caller is responsible for calling unref on the SkCanvas.

Definition at line 299 of file SkCanvasStateUtils.cpp.

                                                                                          {
    SkASSERT(state);
    // Currently there is only one possible version.
    SkASSERT(SkCanvasState_v1::kVersion == state->version);
 
    const SkCanvasState_v1* state_v1 = static_cast<const SkCanvasState_v1*>(state);
 
    if (state_v1->layerCount < 1) {
        return nullptr;
    }
 
    std::unique_ptr<SkCanvasStack> canvas(new SkCanvasStack(state->width, state->height));
 
    // setup the matrix and clip on the n-way canvas
    setup_canvas_from_MC_state(state_v1->mcState, canvas.get());
 
    // Iterate over the layers and add them to the n-way canvas. New clients will only send one
    // layer since unclipped layers are no longer supported, but old canvas clients may still
    // create them.
    for (int i = state_v1->layerCount - 1; i >= 0; --i) {
        std::unique_ptr<SkCanvas> canvasLayer = make_canvas_from_canvas_layer(state_v1->layers[i]);
        if (!canvasLayer) {
            return nullptr;
        }
        canvas->pushCanvas(std::move(canvasLayer), SkIPoint::Make(state_v1->layers[i].x,
                                                                  state_v1->layers[i].y));
    }
 
    return canvas;
}

ReleaseCanvasState()

void SkCanvasStateUtils::ReleaseCanvasState ( SkCanvasState *  state )

static

Free the memory associated with the captured canvas state. The state should not be released until all SkCanvas objects created using that state have been dereferenced. Must be called from the same library instance that created the state via CaptureCanvasState.

Parameters

state

The captured state you wish to dispose of.

Definition at line 332 of file SkCanvasStateUtils.cpp.

                                                                {
    SkASSERT(!state || SkCanvasState_v1::kVersion == state->version);
    // Upcast to the correct version of SkCanvasState. This avoids having a virtual destructor on
    // SkCanvasState. That would be strange since SkCanvasState has no other virtual functions, and
    // instead uses the field "version" to determine how to behave.
    delete static_cast<SkCanvasState_v1*>(state);
}

---

The documentation for this class was generated from the following files:

• third_party/skia/include/utils/SkCanvasStateUtils.h
• third_party/skia/src/utils/SkCanvasStateUtils.cpp