Skia

https://skia.org/docs/
Admin
Skia is an open-source 2D graphics library for drawing text, geometries, and images with support for...
Tokens:56,185
Snippets:709
Trust Score:9.8
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install the Blamer tool

Source: https://skia.org/docs/dev/gardening

Use this command to install the blamer utility if Go is installed on your system.

```bash
go get go.skia.org/infra/blamer/go/blamer
```

--------------------------------

### Install pprof visualizer

Source: https://skia.org/docs/dev/testing/profiling

Install the google-pprof analysis tool on Debian/Ubuntu systems.

```bash
# On Debian/Ubuntu:
$ sudo apt-get install google-perftools
```

--------------------------------

### Setup libfuzzer Environment

Source: https://skia.org/docs/dev/testing/fuzz

Commands to install Clang and configure GN build arguments for libfuzzer integration.

```bash
sudo apt install clang-19
```

```bash
cc="clang-19"
cxx="clang++-19"
skia_build_fuzzers=true
```

--------------------------------

### Initialize RenderEngine capture

Source: https://skia.org/docs/dev/tools/android-capture

Run the setup command once before performing RenderEngine captures.

```bash
frameworks/native/libs/renderengine/skia/debug/record.sh rootandsetup
```

--------------------------------

### Install LUCI client

Source: https://skia.org/docs/dev/testing/download

Clone the client repository to your local machine.

```bash
 git clone https://github.com/luci/client-py.git

```

--------------------------------

### Configure Multiple Build Folders

Source: https://skia.org/docs/user/build

Examples of generating build files with various configurations.

```bash
bin/gn gen out/Debug
bin/gn gen out/Release  --args='is_debug=false'
bin/gn gen out/Clang    --args='cc="clang" cxx="clang++"'
bin/gn gen out/Cached   --args='cc_wrapper="ccache"'
bin/gn gen out/RTTI     --args='extra_cflags_cc=["-frtti"]'
```

--------------------------------

### Install depot_tools

Source: https://skia.org/docs/user/download

Clone the depot_tools repository and add it to your system PATH.

```bash
git clone 'https://chromium.googlesource.com/chromium/tools/depot_tools.git'
export PATH="${PWD}/depot_tools:${PATH}"
```

--------------------------------

### Install gperftool headers

Source: https://skia.org/docs/dev/testing/profiling

Install the necessary headers for compiling and shared libraries for linking.

```bash
# On Debian/Ubuntu:
$ sudo apt-get install libgoogle-perftools-dev
```

--------------------------------

### Install Dependencies

Source: https://skia.org/docs/user/build

Installs missing system dependencies required for building.

```bash
tools/install_dependencies.sh
```

--------------------------------

### Install node.js and ios-deploy

Source: https://skia.org/docs/dev/testing/ios

Updates Homebrew and installs the necessary Node.js environment and ios-deploy tool.

```bash
$ brew update
$ brew install node
$ npm install ios-deploy
```

--------------------------------

### Run SkQP tests via ADB

Source: https://skia.org/docs/dev/testing/skqp

Install the universal APK and execute the instrumentation tests on the device.

```bash
adb install -r skqp-universal-{APK_SHA_HERE}.apk
adb logcat -c
adb shell am instrument -w org.skia.skqp
```

--------------------------------

### Configure Clang-cl Installation Path

Source: https://skia.org/docs/user/build

Set the LLVM installation directory for clang-cl builds.

```text
clang_win = "C:\Program Files\LLVM"
```

--------------------------------

### Launch Viewer with arguments

Source: https://skia.org/docs/user/sample/viewer

Start the Viewer activity on an Android device using ADB with specific command line flags.

```bash
adb shell am start -a android.intent.action.MAIN -n org.skia.viewer/org.skia.viewer.ViewerActivity --es args '"--androidndkfonts"'
```

--------------------------------

### Install libimobiledevice and dependencies

Source: https://skia.org/docs/dev/testing/ios

Installs the core libraries and utilities required to communicate with iOS devices and mount application directories.

```bash
brew install libimobiledevice
brew install ideviceinstaller
brew install caskroom/cask/brew-cask
brew install Caskroom/cask/osxfuse
brew install ifuse
```

--------------------------------

### Demonstrate Raw Image Shader Usage

Source: https://skia.org/docs/user/sksl

Example showing how to use makeRawShader to prevent color management from corrupting normal map data.

```cpp
void draw(SkCanvas* canvas) {
  // Make a hemispherical normal map image:
  auto imageInfo = SkImageInfo::MakeN32Premul(128, 128);
  auto imageShader = SkRuntimeEffect::MakeForShader(SkString(R"(
    vec4 main(vec2 p) {
      p = (p / 128) * 2 - 1;
      float len2 = dot(p, p);
      vec3 v = (len2 > 1) ? vec3(0, 0, 1) : vec3(p, sqrt(1 - len2));
      return (v * 0.5 + 0.5).xyz1;
    }
  )")).effect;
  auto normalImage = make_image(imageShader, imageInfo);

  // Make a simple lighting effect:
  auto litEffect = SkRuntimeEffect::MakeForShader(SkString(R"(
    uniform shader normals;
    vec4 main(vec2 p) {
      vec3 n = normalize(normals.eval(p).xyz * 2 - 1);
      vec3 l = normalize(vec3(-1, -1, 0.5));
      return saturate(dot(n, l)).xxx1;
    }
  )")).effect;
  SkRuntimeShaderBuilder builder(litEffect);
  SkPaint paint;

  // FIRST: Draw the lighting to our (not color managed) canvas.
  // This is our CORRECT, reference result:
  builder.child("normals") = normalImage->makeShader(SkSamplingOptions{});
  paint.setShader(builder.makeShader());
  canvas->drawRect({0,0,128,128}, paint);

  // Make an offscreen surface with a wide gamut:
  auto rec2020 = SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
                                       SkNamedGamut::kRec2020);
  auto info = SkImageInfo::Make(128, 128, kRGBA_F16_SkColorType,
                                kPremul_SkAlphaType, rec2020);
  auto surface = SkSurfaces::Raster(info);

  // SECOND: Draw the lighting to the offscreen surface. Color management
  // changes the normals, producing INCORRECT (wrong direction) lighting:
  surface->getCanvas()->drawPaint(paint);
  canvas->drawImage(surface->makeImageSnapshot(), 128, 0);

  // THIRD: Convert the normals to a raw image shader. This ignores color
  // management for that image, so we get CORRECT lighting again:
  builder.child("normals") = normalImage->makeRawShader(SkSamplingOptions{});
  paint.setShader(builder.makeShader());
  surface->getCanvas()->drawPaint(paint);
  canvas->drawImage(surface->makeImageSnapshot(), 256, 0);
}
```

--------------------------------

### Console Trace Output Example

Source: https://skia.org/docs/dev/tools/tracing

Example output format when tracing is directed to the console.

```text
[ 0] <skia.gpu> GrDrawingManager::internalFlush id=1 #0 {
[ 0] } GrDrawingManager::internalFlush
[ 0] <skia.gpu> GrGpu::createTexture id=1 #1 {
[ 0] } GrGpu::createTexture
[ 0] <skia.gpu> GrRenderTargetContext::discard id=1 #2 {
[ 0] } GrRenderTargetContext::discard
[ 0] <skia.gpu> SkGpuDevice::clearAll id=1 #3 {
[ 1]  <skia.gpu> GrRenderTargetContext::clear id=1 #4 {
[ 1]  } GrRenderTargetContext::clear
[ 0] } SkGpuDevice::clearAll
[ 0] <skia> SkCanvas::drawRect() #5 {
[ 1]  <skia.gpu> SkGpuDevice::drawRect id=1 #6 {
[ 2]   <skia.gpu> GrRenderTargetContext::drawRect id=1 #7 {
[ 3]    <skia.gpu> GrRenderTargetContext::addDrawOp id=1 #8 {
[ 3]    } GrRenderTargetContext::addDrawOp
[ 2]   } GrRenderTargetContext::drawRect
[ 1]  } SkGpuDevice::drawRect
[ 0] } SkCanvas::drawRect()
...
```

--------------------------------

### TextProperties Usage Example

Source: https://skia.org/docs/dev/design/uni_characterize

Demonstrates configuring property requests and calling the characterize method on a string.

```javascript
const properties = {
    isWhiteSpace: true,
    lineBreak: true,
};

const text = "Because I could not stop for Death\nHe kindly stopped for me";

const results = properties.characterize(text);

// expected results

results[7,9,15,19,24,28,37,44,52,65] --> IsWhiteSpace | SoftLineBreak
results[34] --> HardLineBreak
```

--------------------------------

### Shaping and Formatting Example

Source: https://skia.org/docs/dev/design/text_shaper

A practical example of defining text blocks with specific fonts and formatting the resulting shaped text.

```javascript
const fontA = new Font({family-name: "Helvetica", size: 14});
const fontB = new Font({family-name: "Times", size: 18});
const blocks = [
  { length: 6, font: fontA },
  { length: 5, font: fontB },
  { length: 6, font: fontA },
];

const shaped = builder.shape("Hello text world.", blocks);

// now we can format the shaped text to get access to glyphs and positions.

const formatted = shaped.format({width: 50, alignment: CENTER});
```

--------------------------------

### Complete PDF Document Example

Source: https://skia.org/docs/dev/design/pdftheory

A full example of a PDF document structure with catalog, page, and content objects.

```text
%PDF-1.4
2 0 obj <<
  /Type /Catalog
  /Pages 1 0 R
>>
endobj
3 0 obj <<
  /Type /Page
  /Parent 1 0 R
  /Resources <>
  /MediaBox [0 0 612 792]
  /Contents 4 0 R
>>
endobj
4 0 obj <> stream
endstream
endobj
1 0 obj <<
  /Type /Pages
  /Kids [3 0 R]
  /Count 1
>>
endobj
xref
0 5
0000000000 65535 f
0000000236 00000 n
0000000009 00000 n
0000000062 00000 n
0000000190 00000 n
trailer
<</Size 5 /Root 2 0 R>>
startxref
299
%%EOF
```

--------------------------------

### Minimal CanvasKit Application

Source: https://skia.org/docs/user/modules/quickstart

A complete example demonstrating how to initialize CanvasKit, create a surface, and draw a rounded rectangle.

```html
<canvas id=foo width=300 height=300></canvas>

<script type="text/javascript"
  src="https://unpkg.com/canvaskit-wasm@0.19.0/bin/canvaskit.js"></script>
<script type="text/javascript">
  const ckLoaded = CanvasKitInit({
    locateFile: (file) => 'https://unpkg.com/canvaskit-wasm@0.19.0/bin/'+file});
  ckLoaded.then((CanvasKit) => {
    const surface = CanvasKit.MakeCanvasSurface('foo');

    const paint = new CanvasKit.Paint();
    paint.setColor(CanvasKit.Color4f(0.9, 0, 0, 1.0));
    paint.setStyle(CanvasKit.PaintStyle.Stroke);
    paint.setAntiAlias(true);
    const rr = CanvasKit.RRectXY(CanvasKit.LTRBRect(10, 60, 210, 260), 25, 15);

    function draw(canvas) {
      canvas.clear(CanvasKit.WHITE);
      canvas.drawRRect(rr, paint);
    }
    surface.drawOnce(draw);
  });
</script>
```

--------------------------------

### Create a local revert branch

Source: https://skia.org/docs/dev/contrib/revert

Initializes a new local branch starting from the current origin/main.

```bash
git checkout -b revert$RANDOM origin/main
```

--------------------------------

### Deploy iOS test binaries

Source: https://skia.org/docs/user/build

Use ios-deploy to install and run signed test binaries on a connected iOS device.

```bash
ios-deploy -b out/Debug/dm.app -d --args "--match foo"
```

--------------------------------

### Comprehensive Drawing Example

Source: https://skia.org/docs/user/api/skcanvas_overview

Demonstrates various drawing primitives including rectangles, rounded rectangles, circles, paths, images, and text blobs.

```cpp
void draw(SkCanvas* canvas) {
    canvas->drawColor(SK_ColorWHITE);

    SkPaint paint;
    paint.setStyle(SkPaint::kStroke_Style);
    paint.setStrokeWidth(4);
    paint.setColor(SK_ColorRED);

    SkRect rect = SkRect::MakeXYWH(50, 50, 40, 60);
    canvas->drawRect(rect, paint);

    SkRRect oval;
    oval.setOval(rect);
    oval.offset(40, 60);
    paint.setColor(SK_ColorBLUE);
    canvas->drawRRect(oval, paint);

    paint.setColor(SK_ColorCYAN);
    canvas->drawCircle(180, 50, 25, paint);

    rect.offset(80, 0);
    paint.setColor(SK_ColorYELLOW);
    canvas->drawRoundRect(rect, 10, 10, paint);

    SkPath path = SkPathBuilder().cubicTo(768, 0, -512, 256, 256, 256).detach();
    paint.setColor(SK_ColorGREEN);
    canvas->drawPath(path, paint);

    canvas->drawImage(image, 128, 128, SkSamplingOptions(), &paint);

    SkRect rect2 = SkRect::MakeXYWH(0, 0, 40, 60);
    canvas->drawImageRect(image, rect2, SkSamplingOptions(), &paint);

    SkPaint paint2;
    auto text = SkTextBlob::MakeFromString("Hello, Skia!", SkFont(nullptr, 18));
    canvas->drawTextBlob(text.get(), 50, 25, paint2);
}
```

--------------------------------

### PDF File Structure Example

Source: https://skia.org/docs/dev/design/pdftheory

A representation of a basic PDF file structure including the cross-reference table and trailer.

```text
%PDF-1.4
…objects...
xref
0 31  % Total number of entries in the table of contents.
0000000000 65535 f
0000210343 00000 n
…
0000117055 00000 n
trailer
<</Size 31 /Root 1 0 R>>
startxref
210399  % Byte offset to the start of the table of contents.
%%EOF
```

--------------------------------

### Demonstrate Premultiplied vs Unpremultiplied Alpha in SkSL

Source: https://skia.org/docs/user/sksl

This example shows how to correctly return a premultiplied color in SkSL versus an incorrect unpremultiplied approach, and how to apply the resulting shader to a canvas.

```cpp
void draw(SkCanvas* canvas) {
  const char* sksl =

  "const half3 iColor = half3(0, 0.5, 0.75);"
  "half4 main(float2 coord) {"
  "  float alpha = 1 - (coord.y / 150);"
  "  if (coord.x < 100) {"
  "    /* Correctly premultiplied version of color */"
  "    return iColor.rgb1 * alpha;"
  "  } else {"
  "    /* Returning an unpremultiplied color (just setting alpha) leads to over-bright colors. */"
  "    return half4(iColor, alpha);"
  "  }"
  "}";

  auto [effect, err] = SkRuntimeEffect::MakeForShader(SkString(sksl));
  sk_sp<SkShader> myShader = effect->makeShader(/*uniforms=*/ nullptr,
                                                /*children=*/ {});

  // Fill canvas with gray, first:
  canvas->drawColor(SK_ColorGRAY);

  // Blend our test shader on top of that:
  SkPaint p;
  p.setShader(myShader);
  canvas->drawPaint(p);
}
```

--------------------------------

### PDF Page Object and Content Stream Example

Source: https://skia.org/docs/dev/design/pdftheory

Demonstrates a PDF page object referencing resources and a content stream containing text and rectangle drawing commands.

```text
4 0 obj <<
  /Type /Page
  /Resources <<
    /Font <</F1 9 0 R>>
    /XObject <</Image1 22 0 R /Image2 73 0 R>>
  >>
  /Content 5 0 R
>> endobj

5 0 obj <</Length 227>> stream
% In the font specified in object 9 and a height
% of 12 points, at (72, 96) draw ‘Hello World.’
BT
  /F1 12 Tf
  72 96 Td
  (Hello World) Tj
ET
% Draw a filled rectange.
200 96 72 72 re B
...
endstream
endobj
```

--------------------------------

### Lighting Calculation with Linear Color Space

Source: https://skia.org/docs/user/sksl

Example demonstrating the use of color space conversion to achieve physically accurate light falloff in a shader.

```C++
void draw(SkCanvas* canvas) {
  // Make a simple lighting effect:
  auto litEffect = SkRuntimeEffect::MakeForShader(SkString(R"(
    layout(color) uniform vec3 surfaceColor;
    uniform int doLinearLighting;

    vec3 normal_at(vec2 p) {
      p = (p / 128) * 2 - 1;
      float len2 = dot(p, p);
      vec3 n = (len2 > 1) ? vec3(0, 0, 1) : vec3(p, sqrt(1 - len2));
      return normalize(n);
    }

    vec4 main(vec2 p) {
      vec3 n = normal_at(p);
      vec3 l = normalize(vec3(-1, -1, 0.5));
      vec3 C = surfaceColor;

      if (doLinearLighting != 0) { C = toLinearSrgb(C); }
      C *= saturate(dot(n, l));
      if (doLinearLighting != 0) { C = fromLinearSrgb(C); }

      return C.rgb1;
    })")).effect;
  SkRuntimeShaderBuilder builder(litEffect);
  builder.uniform("surfaceColor") = SkV3{0.8, 0.8, 0.8};
  SkPaint paint;

  // FIRST: Draw the lit sphere without converting to linear sRGB.
  // This produces INCORRECT light falloff.
  builder.uniform("doLinearLighting") = 0;
  paint.setShader(builder.makeShader());
  canvas->drawRect({0,0,128,128}, paint);

  // SECOND: Draw the lit sphere with math done in linear sRGB.
  // This produces sharper falloff, which is CORRECT.
  builder.uniform("doLinearLighting") = 1;
  paint.setShader(builder.makeShader());
  canvas->translate(128, 0);
  canvas->drawRect({0,0,128,128}, paint);
}
```

--------------------------------

### Run the Skia Viewer with Resources

Source: https://skia.org/docs/user/sample/viewer

Launch the Viewer while specifying the path to external resources required for certain slides.

```bash
<skia-path>/out/Release/viewer --resourcePath <skia-path>/resources
```

--------------------------------

### Compile and Run Benchmarks

Source: https://skia.org/docs/dev/testing/tests

Build the nanobench binary and execute benchmarks matching a specific name.

```bash
ninja -C out/Release nanobench
out/Release/nanobench --match Foo
```

--------------------------------

### Set up Android SDK environment

Source: https://skia.org/docs/user/sample/viewer

Commands to initialize the Android SDK command line tools and set the required environment variable.

```bash
mkdir ~/android-sdk
cd ~/android-sdk
unzip ~/Downloads/commandlinetools-*.zip
yes | cmdline-tools/bin/sdkmanager --licenses --sdk_root=.
export ANDROID_HOME=~/android-sdk  # Or wherever you installed the Android SDK.
```

--------------------------------

### Generate Meta Visual Studio Solution

Source: https://skia.org/docs/user/build

Run this script to create a solution file that supports multiple GN configurations.

```bash
python3 gn/gn_meta_sln.py
```

--------------------------------

### Build Clang Binaries from Source

Source: https://skia.org/docs/dev/testing/xsan

Sync dependencies and build the Clang toolchain locally.

```bash
CLANGDIR="${HOME}/clang"

python3 tools/git-sync-deps
CC= CXX= infra/bots/assets/clang_linux/create.py -t "$CLANGDIR"
```

--------------------------------

### Initialize Skia Build Environment

Source: https://skia.org/docs/dev/testing/tests

Sync dependencies and generate build configurations for Debug and Release modes.

```bash
python3 tools/git-sync-deps
bin/gn gen out/Debug
bin/gn gen out/Release --args='is_debug=false'
```

--------------------------------

### DM Execution Output

Source: https://skia.org/docs/dev/testing/testing

Example of the console output generated during a DM test run.

```text
Skipping nonrendering: Don't understand 'nonrendering'.
Skipping angle: Don't understand 'angle'.
Skipping nvprmsaa4: Could not create a surface.
492 srcs * 3 sinks + 382 tests == 1858 tasks

(  25MB  1857) 1.36ms   8888 image mandrill_132x132_12x12.astc-5-subsets
(  25MB  1856) 1.41ms   8888 image mandrill_132x132_6x6.astc-5-subsets
(  25MB  1855) 1.35ms   8888 image mandrill_132x130_6x5.astc-5-subsets
(  25MB  1854) 1.41ms   8888 image mandrill_132x130_12x10.astc-5-subsets
(  25MB  1853) 151µs    8888 image mandrill_130x132_10x6.astc-5-subsets
(  25MB  1852) 154µs    8888 image mandrill_130x130_5x5.astc-5-subsets
                                  ...
( 748MB     5) 9.43ms   unit test GLInterfaceValidation
( 748MB     4) 30.3ms   unit test HalfFloatTextureTest
( 748MB     3) 31.2ms   unit test FloatingPointTextureTest
( 748MB     2) 32.9ms   unit test DeferredCanvas_GPU
( 748MB     1) 49.4ms   unit test ClipCache
( 748MB     0) 37.2ms   unit test Blur
```

--------------------------------

### Draw page content

Source: https://skia.org/docs/user/sample/pdf

Example implementation of a page drawing callback using SkPathBuilder and SkPaint.

```cpp
void write_page(SkCanvas* canvas, int) {
    const SkScalar R = 115.2f, C = 128.0f;
    SkPathBuilder path;
    path.moveTo(C + R, C);
    for (int i = 1; i < 8; ++i) {
        SkScalar a = 2.6927937f * i;
        path.lineTo(C + R * cos(a), C + R * sin(a));
    }
    SkPaint paint;
    paint.setStyle(SkPaint::kStroke_Style);
    canvas->drawPath(path.detach(), paint);
}
```

--------------------------------

### Prepare Android device for capture

Source: https://skia.org/docs/dev/tools/android-capture

Run these commands to enable root access and remount the file system for writing capture files.

```bash
adb root
adb remount
```

--------------------------------

### Build the Skia Viewer

Source: https://skia.org/docs/user/sample/viewer

Use GN and Ninja to compile the Viewer application from the Skia source tree.

```bash
bin/gn gen out/Release --args='is_debug=false'
ninja -C out/Release viewer
```

--------------------------------

### Compile and Run Rendering Tests

Source: https://skia.org/docs/dev/testing/tests

Build the dm binary to run rendering tests or the viewer binary to visualize them.

```bash
ninja -C out/Debug dm
out/Debug/dm --match newgmtest
```

```bash
ninja -C out/Debug viewer
out/Debug/viewer --slide GM_newgmtest
```

--------------------------------

### Build a Skia target on Mac

Source: https://skia.org/docs/dev/contrib/bazel

Compiles a target on a Mac host, requiring Xcode to be installed and configured.

```bash
bazel build //example:bazel_test_exe
```

--------------------------------

### Implement a Unit Test

Source: https://skia.org/docs/dev/testing/tests

Create a test file using the DEF_TEST macro and verify assertions with REPORTER_ASSERT.

```cpp
/*
 * Copyright ........
 *
 * Use of this source code is governed by a BSD-style license
 * that can be found in the LICENSE file.
 */
#include "Test.h"
DEF_TEST(NewUnitTest, reporter) {
    if (1 + 1 != 2) {
        ERRORF(reporter, "%d + %d != %d", 1, 1, 2);
    }
    bool lifeIsGood = true;
    REPORTER_ASSERT(reporter, lifeIsGood);
}
```

--------------------------------

### Identify test output path

Source: https://skia.org/docs/dev/testing/skqp

Example of the log output indicating where the test report is saved on the device.

```text
01-23 15:22:12.688 27158 27173 I org.skia.skqp:
output written to "/storage/emulated/0/Android/data/org.skia.skqp/files/skqp_report_2019-02-28T102058"
```

--------------------------------

### Run Android GDB script

Source: https://skia.org/docs/dev/tools/android_gdb

Execute the native GDB script to start a command-line debugging session.

```bash
platform_tools/android/bin/android_gdb_native -C out/android dm -i /data/local/tmp/resources <args>

```

--------------------------------

### Deploy and Run on Android

Source: https://skia.org/docs/user/build

Build the project with ninja and push the resulting binaries and resources to an Android device for testing.

```bash
ninja -C out/arm64
adb push out/arm64/dm /data/local/tmp
adb push resources /data/local/tmp
adb shell "cd /data/local/tmp; ./dm --src gm --config gl"
```

--------------------------------

### Configure Git user identity

Source: https://skia.org/docs/dev/contrib/submit

Set your global git username and email address before starting contributions.

```bash
git config --global user.name "Your Name"
git config --global user.email you@example.com

```

--------------------------------

### Build DM and gdbserver

Source: https://skia.org/docs/dev/tools/android_gdb

Build the required targets using ninja.

```bash
ninja -C out/android dm gdbserver

```

--------------------------------

### Initialize and use SkPaint objects

Source: https://skia.org/docs/user/api/skpaint_overview

Demonstrates creating multiple SkPaint instances with different styles and colors to draw text blobs on a canvas.

```cpp
void draw(SkCanvas* canvas) {
    SkPaint paint1, paint2, paint3;

    paint1.setAntiAlias(true);
    paint1.setColor(SkColorSetRGB(255, 0, 0));
    paint1.setStyle(SkPaint::kFill_Style);

    paint2.setAntiAlias(true);
    paint2.setColor(SkColorSetRGB(0, 136, 0));
    paint2.setStyle(SkPaint::kStroke_Style);
    paint2.setStrokeWidth(SkIntToScalar(3));

    paint3.setAntiAlias(true);
    paint3.setColor(SkColorSetRGB(136, 136, 136));

    sk_sp<SkTextBlob> blob1 =
            SkTextBlob::MakeFromString("Skia!", SkFont(nullptr, 64.0f, 1.0f, 0.0f));
    sk_sp<SkTextBlob> blob2 =
            SkTextBlob::MakeFromString("Skia!", SkFont(nullptr, 64.0f, 1.5f, 0.0f));

    canvas->clear(SK_ColorWHITE);
    canvas->drawTextBlob(blob1.get(), 20.0f, 64.0f, paint1);
    canvas->drawTextBlob(blob1.get(), 20.0f, 144.0f, paint2);
    canvas->drawTextBlob(blob2.get(), 20.0f, 224.0f, paint3);
}
```

--------------------------------

### Initialize GrDirectContext with Vulkan

Source: https://skia.org/docs/user/special/vulkan

Steps to create a Vulkan-backed GrDirectContext by initializing the VulkanBackendContext.

```cpp
skgpu::VulkanBackendContext vkContext;
vkBackendContext.fInstance = vkInstance;
vkBackendContext.fPhysicalDevice = vkPhysDevice;
...

sk_sp<GrContext> context = GrDirectContexts::MakeVulkan::MakeVulkan(vkBackendContext);
```

--------------------------------

### Common DM Command-Line Flags

Source: https://skia.org/docs/dev/testing/testing

Examples of useful flags for filtering tests, controlling hardware backends, and dry-running operations.

```bash
out/Debug/dm --help        # Print all flags, their defaults, and a brief explanation of each.
out/Debug/dm --src tests   # Run only unit tests.
out/Debug/dm --nocpu       # Test only GPU-backed work.
out/Debug/dm --nogpu       # Test only CPU-backed work.
out/Debug/dm --match blur  # Run only work with "blur" in its name.
out/Debug/dm --dryRun      # Don't really do anything, just print out what we'd do.
```

--------------------------------

### Visualize Profiles with pprof Web Interface

Source: https://skia.org/docs/dev/testing/profiling

Generate web-based visualizations for CPU and heap profiles using GraphViz.

```bash
$ pprof -web ./out/Profile/nanobench <output.prof>
```

```bash
$ pprof -alloc_space -web ./out/Profile/nanobench output.heap.0005.heap
```

--------------------------------

### Initialize a feature branch

Source: https://skia.org/docs/dev/contrib/submit

Configure rebase settings and create a new branch based on origin/main.

```bash
git config branch.autosetuprebase always
git checkout -b my_feature origin/main

```

--------------------------------

### View RBE authentication error

Source: https://skia.org/docs/dev/contrib/bazel

Example of an error message encountered when RBE fails to retrieve security tokens from Compute Engine metadata.

```text
ERROR: Failed to query remote execution capabilities:
Error code 404 trying to get security access token from Compute Engine metadata for the default
service account. This may be because the virtual machine instance does not have permission
scopes specified. It is possible to skip checking for Compute Engine metadata by specifying the
environment variable NO_GCE_CHECK=true.
```

--------------------------------

### Compile and Run Unit Tests

Source: https://skia.org/docs/dev/testing/tests

Build the dm binary and execute specific tests using the --match flag.

```bash
ninja -C out/Debug dm
out/Debug/dm --match NewUnitTest
```

--------------------------------

### List Build Arguments

Source: https://skia.org/docs/user/build

Displays all available build arguments for a specific build directory.

```bash
bin/gn args out/Debug --list
```

--------------------------------

### Configure and Compile Skia with MSAN

Source: https://skia.org/docs/dev/testing/xsan

Set up the GN build arguments for Memory Sanitizer and compile the project.

```bash
CLANGDIR="${HOME}/clang"
mkdir -p out/msan
cat > out/msan/args.gn <<- EOF
    cc = "${CLANGDIR}/bin/clang"
    cxx = "${CLANGDIR}/bin/clang++"
    extra_cflags = [ "-B${CLANGDIR}/bin" ]
    extra_ldflags = [
        "-B${CLANGDIR}/bin",
        "-fuse-ld=lld",
        "-L${CLANGDIR}/msan",
        "-Wl,-rpath,${CLANGDIR}/msan" ]
    sanitize = "MSAN"
    skia_use_fontconfig = false
EOF
python3 tools/git-sync-deps
bin/gn gen out/msan
ninja -C out/msan
```

--------------------------------

### Configure GN for Windows Toolchain

Source: https://skia.org/docs/user/build

Set the VC and SDK paths in your GN arguments.

```text
win_vc = "C:\toolchain\VC"
win_sdk = "C:\toolchain\win_sdk"
```

--------------------------------

### Configure and Compile Skia with ASAN

Source: https://skia.org/docs/dev/testing/xsan

Set up the GN build arguments for Address Sanitizer and compile the project.

```bash
CLANGDIR="${HOME}/clang"
mkdir -p out/asan
cat > out/asan/args.gn <<- EOF
    cc = "${CLANGDIR}/bin/clang"
    cxx = "${CLANGDIR}/bin/clang++"
    sanitize = "ASAN"
    extra_ldflags = [ "-fuse-ld=lld", "-Wl,-rpath,${CLANGDIR}/lib/x86_64-unknown-linux-gnu" ]
EOF
python3 tools/git-sync-deps
bin/gn gen out/asan
ninja -C out/asan
```

--------------------------------

### Define a PDF Graphic State Object

Source: https://skia.org/docs/dev/design/pdftheory

Example of a PDF ExtGState object defining drawing parameters like alpha, line cap, line join, line width, miter limit, and blend mode.

```pdf
6 0 obj <<
  /Type /ExtGState
  /CA 1  % Opaque - alpha = 1
  /LC 0  % Butt linecap
  /LJ 0  % Miter line-join
  /LW 2  % Line width of 2
  /ML 6  % Miter limit of 6
  /BM /Normal  % Blend mode is normal i.e. source over
>>
endobj
```

--------------------------------

### Initialize Skia in Chromium

Source: https://skia.org/docs/dev/chrome/repo

Commands to sync dependencies and generate build files for Skia within a Chromium checkout.

```bash
cd chromium/src/third_party/skia
python3 tools/git-sync-deps
bin/gn gen out/Debug
```

--------------------------------

### Build Skia with Ninja

Source: https://skia.org/docs/dev/chrome/repo

Command to build Skia after the environment has been initialized.

```bash
ninja -C out/Debug dm
```

--------------------------------

### Configure args.gn for profiling

Source: https://skia.org/docs/dev/testing/profiling

Set the required build arguments to enable profiling instrumentation and improve line-level attribution.

```gn
# Example args.gn in out/Profile
is_debug = false
skia_use_pprof = true
extra_cflags = ["-Og"]
```

--------------------------------

### Generate Heap Profile with Nanobench

Source: https://skia.org/docs/dev/testing/profiling

Use the --memprofile flag to capture heap snapshots during execution.

```bash
$ ./out/Profile/nanobench --match <bench_name> --memprofile <output.heap>
...
Dumping heap profile to output.heap.0001.heap
...
Dumping heap profile to output.heap.0002.heap
```

--------------------------------

### Configure SkPaint for different drawing styles

Source: https://skia.org/docs/user/api/skpaint_overview

Demonstrates setting up fill and stroke paints, modifying stroke width, and drawing shapes and text blobs.

```cpp
void draw(SkCanvas* canvas) {
    SkPaint fillPaint;
    SkPaint strokePaint;
    strokePaint.setStyle(SkPaint::kStroke_Style);
    strokePaint.setStrokeWidth(3.0f);

    canvas->drawRect(SkRect::MakeXYWH(10, 10, 60, 20), fillPaint);
    canvas->drawRect(SkRect::MakeXYWH(80, 10, 60, 20), strokePaint);

    strokePaint.setStrokeWidth(5.0f);
    canvas->drawOval(SkRect::MakeXYWH(150, 10, 60, 20), strokePaint);

    sk_sp<SkTextBlob> blob = SkTextBlob::MakeFromString("SKIA", SkFont(nullptr, 80));

    fillPaint.setColor(SkColorSetARGB(0xFF, 0xFF, 0x00, 0x00));
    canvas->drawTextBlob(blob.get(), 20, 120, fillPaint);

    fillPaint.setColor(SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF));
    canvas->drawTextBlob(blob.get(), 20, 220, fillPaint);
}
```

--------------------------------

### Execute PDF generation

Source: https://skia.org/docs/user/sample/pdf

Main entry point to initialize the memory stream, trigger PDF writing, and output the resulting data.

```cpp
void draw(SkCanvas*) {
    constexpr SkSize ansiLetterSize{8.5f * 72, 11.0f * 72};
    SkDynamicMemoryWStream buffer;
    WritePDF(&buffer, "SkPDF Example", &write_page, 1, ansiLetterSize);
    sk_sp<SkData> pdfData = buffer.detachAsData();
    print_data(pdfData.get(), "skpdf_example.pdf");
}
```

--------------------------------

### Build and Run DM

Source: https://skia.org/docs/dev/testing/testing

Commands to synchronize dependencies, generate build files, compile, and execute the DM tool.

```bash
python3 tools/git-sync-deps
bin/gn gen out/Debug
ninja -C out/Debug dm
out/Debug/dm -v -w dm_output
```

--------------------------------

### List Build Targets

Source: https://skia.org/docs/user/build

Lists all available targets for a specific build directory.

```bash
gn ls out/Debug
```

--------------------------------

### Sync Dependencies

Source: https://skia.org/docs/user/build

Ensures all required dependencies are present before building.

```bash
python3 tools/git-sync-deps
```

--------------------------------

### Configure Windows ARM64 build

Source: https://skia.org/docs/user/build

Sets the target CPU to ARM64 and enables ANGLE for rendering, as OpenGL is unsupported on Windows 10 ARM.

```bash
bin/gn gen out/win-arm64 --args='target_cpu="arm64" skia_use_angle=true'
```

--------------------------------

### View Annotated Source with pprof

Source: https://skia.org/docs/dev/testing/profiling

Use the -weblist flag to inspect performance metrics at the line or instruction level.

```bash
$ pprof -weblist <function> ./out/Profile/nanobench <output.prof>
# Pick a function you want to zoom in. You can run the command w/o providing
# a function (or function regex), but it's quite noisy.
```

```bash
$ pprof -alloc_space -weblist <function> ./out/Profile/nanobench output.heap.0005.heap
```

--------------------------------

### Configure Skia for SwiftShader on Mac

Source: https://skia.org/docs/user/special/vulkan

GN arguments to enable Vulkan and point to the compiled SwiftShader library.

```text
skia_use_vulkan = true
extra_cflags = [ "-D", "SK_GPU_TOOLS_VK_LIBRARY_NAME=$(SKIA_DIR)/third_party/externals/swiftshader/build/Darwin/libvk_swiftshader.dylib" ]
```

--------------------------------

### Generate Flame Graphs with pprof

Source: https://skia.org/docs/dev/testing/profiling

Create flame graph visualizations for CPU and heap profiles.

```bash
$ pprof -flame ./out/Profile/nanobench <output.prof>
$ pprof -alloc_space -flame ./out/Profile/nanobench output.heap.0005.heap
```

--------------------------------

### Download Clang Binaries

Source: https://skia.org/docs/dev/testing/xsan

Use gcloud to authenticate and download the required Clang toolchain for Linux.

```bash
gcloud auth application-default login
CLANGDIR="${HOME}/clang"
./bin/sk asset download clang_linux $CLANGDIR
```

--------------------------------

### List available try jobs

Source: https://skia.org/docs/dev/contrib/submit

Use the bin/try wrapper to list all available try jobs from a Skia checkout.

```bash
bin/try --list
```

--------------------------------

### Generate CPU Profile with Nanobench

Source: https://skia.org/docs/dev/testing/profiling

Use the --cpuprofile flag to capture CPU usage data during a benchmark run.

```bash
$ ./out/Profile/nanobench --match <bench_name> --cpuprofile <output.prof> --ms 1000
```

--------------------------------

### Download Windows Toolchain

Source: https://skia.org/docs/user/build

Command to download the packaged 2019 toolchain used by build bots.

```bash
./bin/sk.exe asset download win_toolchain C:/toolchain
```

--------------------------------

### Configure and Compile Skia with TSAN

Source: https://skia.org/docs/dev/testing/xsan

Set up the GN build arguments for Thread Sanitizer and compile the project.

```bash
CLANGDIR="${HOME}/clang"
mkdir -p out/tsan
cat > out/tsan/args.gn <<- EOF
    cc = "${CLANGDIR}/bin/clang"
    cxx = "${CLANGDIR}/bin/clang++"
    sanitize = "TSAN"
    is_debug = false
    extra_ldflags = [ "-Wl,-rpath,${CLANGDIR}/lib" ]
EOF
python3 tools/git-sync-deps
bin/gn gen out/tsan
ninja -C out/tsan
```

--------------------------------

### Enable Android ATrace

Source: https://skia.org/docs/dev/tools/tracing

Configures a tool to forward tracing events to the Android atrace system.

```bash
adb shell "cd /data/local/tmp; ./nanobench --trace atrace ..."
```

--------------------------------

### Construct Multi-Contour Path

Source: https://skia.org/docs/user/api/skpath_overview

Shows how to construct a path with multiple contours using moveTo, lineTo, quadTo, and conicTo.

```cpp
void draw(SkCanvas* canvas) {
    SkPaint paint;
    paint.setAntiAlias(true);
    canvas->drawString("1st contour", 150, 100, paint);
    canvas->drawString("2nd contour", 130, 160, paint);
    canvas->drawString("3rd contour", 40, 30, paint);
    paint.setStyle(SkPaint::kStroke_Style);
    SkPath path;
    path.moveTo(124, 108);
    path.lineTo(172, 24);
    path.moveTo(36, 148);
    path.quadTo(66, 188, 120, 136);
    path.close();
    path.conicTo(70, 20, 110, 40, 0.6f);
    canvas->drawPath(path, paint);
}
```
Tokens:
Raw