• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Copyright 2016 Google Inc.
2#
3# Use of this source code is governed by a BSD-style license that can be
4# found in the LICENSE file.
5
6import("//build/ohos.gni")
7import("//foundation/arkui/ace_engine/ace_config.gni")
8import("//foundation/graphic/graphic_2d/graphic_config.gni")
9import("gn/flutter_defines.gni")
10import("gn/fuchsia_defines.gni")
11import("gn/shared_sources.gni")
12import("gn/skia.gni")
13
14if (defined(is_mingw) && is_mingw == true) {
15  is_win = true
16}
17
18if (is_fuchsia) {
19  import("${skia_root_dir}/build/fuchsia/sdk.gni")
20  import("build/fuchsia/fuchsia_download_sdk.gni")
21}
22
23if (skia_use_dawn) {
24  import("${skia_third_party_dir}/externals/dawn/scripts/dawn_features.gni")
25}
26
27if (defined(skia_settings)) {
28  import(skia_settings)
29}
30
31import("gn/ios.gni")
32
33config("skia_wno") {
34  cflags = [
35    "-Wno-deprecated-declarations",
36    "-Wno-pessimizing-move",
37    "-Wno-return-type",
38    "-Wno-sign-compare",
39    "-Wno-sometimes-uninitialized",
40    "-Wno-unknown-pragmas",
41    "-Wno-unused-function",
42    "-Wno-unused-private-field",
43    "-Wno-unused-variable",
44    "-Wno-c++17-extensions",
45  ]
46  ldflags = [
47    "--stdlib=libc++",
48    "-lc++",
49    "-lc++abi",
50  ]
51}
52
53# Skia public API, generally provided by :skia.
54config("skia_public") {
55  include_dirs = [ "." ]
56
57  defines = [ "NEW_SKIA" ]
58  if (defined(skia_ohos_debug) && skia_ohos_debug) {
59    include_dirs += [ "//base/hiviewdfx/hitrace/interfaces/native/innerkits/include/hitrace_meter" ]
60    defines += [ "SKIA_OHOS_DEBUG" ]
61  }
62  cflags_objcc = []
63  if (is_skia_dev_build) {
64    defines += [ "GR_TEST_UTILS=1" ]
65  }
66  if (is_skia_component_build) {
67    defines += [ "SKIA_DLL" ]
68  }
69  if (is_arkui_x && defined(is_android) && is_android) {
70    defines += [ "SK_BUILD_FOR_ANDROID" ]
71  }
72  defines += [ "SK_BUILD_FOR_OHOS" ]
73  if (is_fuchsia || is_linux) {
74    defines += [ "SK_R32_SHIFT=16" ]
75  }
76  if (skia_enable_flutter_defines) {
77    defines += flutter_defines
78  }
79  if (!skia_enable_gpu) {
80    defines += [ "SK_SUPPORT_GPU=0" ]
81  }
82  if (skia_enable_sksl) {
83    defines += [ "SK_ENABLE_SKSL" ]
84  }
85  if (is_fuchsia) {
86    defines += fuchsia_defines
87  }
88  if (skia_gl_standard == "gles") {
89    defines += [ "SK_ASSUME_GL_ES=1" ]
90  } else if (skia_gl_standard == "gl") {
91    defines += [ "SK_ASSUME_GL=1" ]
92  } else if (skia_gl_standard == "webgl") {
93    defines += [
94      "SK_ASSUME_WEBGL=1",
95      "SK_USE_WEBGL",
96    ]
97  }
98  if (!skia_enable_skgpu_v1) {
99    defines += [ "SK_GPU_V1=0" ]
100  }
101  if (ace_enable_skia_small_page_texture && is_ohos) {
102    defines += [ "SK_ENABLE_SMALL_PAGE" ]
103  }
104
105  # Some older versions of the Clang toolchain change the visibility of
106  # symbols decorated with API_AVAILABLE macro to be visible. Users of such
107  # toolchains suppress the use of this macro till toolchain updates are made.
108  if (is_mac) {
109    defines += [ "SK_GL_ENABLE_330_MAC" ]
110  }
111  if (is_mac || is_ios) {
112    if (skia_enable_api_available_macro) {
113      defines += [ "SK_ENABLE_API_AVAILABLE" ]
114    } else {
115      cflags_objcc += [ "-Wno-unguarded-availability" ]
116    }
117  }
118  if (is_win) {
119    defines += [ "SK_BUILD_FOR_WIN" ]
120  }
121}
122
123# Skia internal APIs, used by Skia itself and a few test tools.
124config("skia_private") {
125  visibility = [ "./*" ]
126
127  cflags = [
128    "-Wno-format",
129    "-fvisibility=hidden",
130  ]
131
132  cflags_cc = [
133    "-Wno-array-parameter",
134    "-fvisibility-inlines-hidden",
135  ]
136
137  defines = [ "SK_GAMMA_APPLY_TO_A8" ]
138  if (target_cpu == "x86_64" || current_os == "windows" ||
139      current_os == "mac" || current_os == "linux" || current_os == "ios") {
140    cflags_cc += [ "-Wno-psabi" ]
141  }
142  if (skia_use_fixed_gamma_text) {
143    defines += [
144      "SK_GAMMA_EXPONENT=1.4",
145      "SK_GAMMA_CONTRAST=0.0",
146    ]
147  }
148  if (is_skia_dev_build) {
149    defines += [ "SK_ALLOW_STATIC_GLOBAL_INITIALIZERS=1" ]
150    if (skia_enable_graphite) {
151      defines += [ "GRAPHITE_TEST_UTILS=1" ]
152    }
153  }
154  libs = []
155  lib_dirs = []
156  if (skia_use_gl && skia_use_angle) {
157    defines += [ "SK_ANGLE" ]
158  }
159  if (skia_use_vma) {
160    defines += [ "SK_USE_VMA" ]
161  }
162  if (skia_enable_winuwp) {
163    defines += [ "SK_WINUWP" ]
164  }
165}
166
167# Any code that's linked into Skia-the-library should use this config via += skia_library_configs.
168config("skia_library") {
169  visibility = [ "./*" ]
170  defines = [ "SKIA_IMPLEMENTATION=1" ]
171}
172
173skia_library_configs = [
174  ":skia_public",
175  ":skia_private",
176  ":skia_library",
177]
178
179# Use for CPU-specific Skia code that needs particular compiler flags.
180template("opts") {
181  if (invoker.enabled) {
182    skia_source_set(target_name) {
183      visibility = [ ":*" ]
184      check_includes = false
185      configs = skia_library_configs
186      forward_variables_from(invoker, "*")
187      if (defined(invoker.configs)) {
188        configs += invoker.configs
189      }
190    }
191  } else {
192    # If not enabled, a phony empty target that swallows all otherwise unused variables.
193    skia_source_set(target_name) {
194      visibility = [ ":*" ]
195      check_includes = false
196      forward_variables_from(invoker,
197                             "*",
198                             [
199                               "sources",
200                               "cflags",
201                             ])
202    }
203  }
204}
205
206is_x86 = current_cpu == "x64" || current_cpu == "x86"
207
208opts("none") {
209  enabled = !is_x86 && current_cpu != "arm" && current_cpu != "arm64"
210  sources = skia_opts.none_sources
211  cflags = []
212}
213
214opts("armv7") {
215  enabled = current_cpu == "arm"
216  sources = skia_opts.armv7_sources + skia_opts.neon_sources
217  cflags = []
218}
219
220opts("arm64") {
221  enabled = current_cpu == "arm64"
222  sources = skia_opts.arm64_sources
223  cflags = []
224}
225
226opts("crc32") {
227  enabled = current_cpu == "arm64"
228  sources = skia_opts.crc32_sources
229  cflags = [ "-march=armv8-a+crc" ]
230}
231
232opts("sse2") {
233  enabled = is_x86
234  sources = skia_opts.sse2_sources
235  if (!is_clang && is_win) {
236    defines = [ "SK_CPU_SSE_LEVEL=SK_CPU_SSE_LEVEL_SSE2" ]
237  } else {
238    cflags = [ "-msse2" ]
239  }
240}
241
242opts("ssse3") {
243  enabled = is_x86
244  sources = skia_opts.ssse3_sources
245  if (!is_clang && is_win) {
246    defines = [ "SK_CPU_SSE_LEVEL=SK_CPU_SSE_LEVEL_SSSE3" ]
247  } else {
248    cflags = [ "-mssse3" ]
249  }
250}
251
252opts("sse41") {
253  enabled = is_x86
254  sources = skia_opts.sse41_sources
255  if (!is_clang && is_win) {
256    defines = [ "SK_CPU_SSE_LEVEL=SK_CPU_SSE_LEVEL_SSE41" ]
257  } else {
258    cflags = [ "-msse4.1" ]
259  }
260}
261
262opts("sse42") {
263  enabled = is_x86
264  sources = skia_opts.sse42_sources
265  if (!is_clang && is_win) {
266    defines = [ "SK_CPU_SSE_LEVEL=SK_CPU_SSE_LEVEL_SSE42" ]
267  } else {
268    cflags = [ "-msse4.2" ]
269  }
270}
271
272opts("avx") {
273  enabled = is_x86
274  sources = skia_opts.avx_sources
275  if (is_win && !is_mingw) {
276    cflags = [ "/arch:AVX" ]
277  } else {
278    cflags = [ "-mavx" ]
279    if (is_mac && is_debug) {
280      cflags += [ "-fno-stack-check" ]  # Work around skia:9709
281    }
282  }
283}
284
285opts("hsw") {
286  enabled = is_x86
287  sources = skia_opts.hsw_sources
288  if (is_win && !is_mingw) {
289    cflags = [ "/arch:AVX2" ]
290  } else {
291    cflags = [ "-march=haswell" ]
292    if (is_mac && is_debug) {
293      cflags += [ "-fno-stack-check" ]  # Work around skia:9709
294    }
295  }
296}
297
298opts("skx") {
299  enabled = is_x86
300  sources = skia_opts.skx_sources
301  if (is_win && !is_mingw) {
302    cflags = [ "/arch:AVX512" ]
303  } else {
304    cflags = [ "-march=skylake-avx512" ]
305    if (is_mac && is_debug) {
306      cflags += [ "-fno-stack-check" ]  # Work around skia:9709
307    }
308  }
309}
310
311# Any feature of Skia that requires third-party code should be optional and use this template.
312template("optional") {
313  if (invoker.enabled) {
314    config(target_name + "_public") {
315      if (defined(invoker.public_defines)) {
316        defines = invoker.public_defines
317      }
318      if (defined(invoker.public_configs)) {
319        configs = invoker.public_configs
320      }
321      if (defined(invoker.public_include_dirs)) {
322        include_dirs = invoker.public_include_dirs
323      }
324    }
325    skia_source_set(target_name) {
326      visibility = [ ":*" ]
327      check_includes = false
328      configs = skia_library_configs
329      configs += [ ":skia_wno" ]
330
331      # "*" clobbers the current scope; append to existing configs
332      forward_variables_from(invoker,
333                             "*",
334                             [
335                               "configs",
336                               "public_defines",
337                               "sources_for_tests",
338                               "sources_when_disabled",
339                             ])
340      if (defined(invoker.configs)) {
341        configs += invoker.configs
342      }
343      all_dependent_configs = [ ":" + target_name + "_public" ]
344    }
345    if (defined(invoker.sources_for_tests) && skia_enable_tools) {
346      skia_source_set(target_name + "_tests") {
347        visibility = [ ":*" ]
348        check_includes = false
349        configs = skia_library_configs
350
351        # "*" clobbers the current scope; append to existing configs
352        forward_variables_from(invoker,
353                               "*",
354                               [
355                                 "configs",
356                                 "public_defines",
357                                 "sources",
358                                 "sources_for_tests",
359                                 "sources_when_disabled",
360                               ])
361        if (defined(invoker.configs)) {
362          configs += invoker.configs
363        }
364        testonly = true
365        sources = invoker.sources_for_tests
366        if (!defined(deps)) {
367          deps = []
368        }
369        deps += [ ":test" ]
370        all_dependent_configs = [ ":" + target_name + "_public" ]
371      }
372    }
373  } else {
374    skia_source_set(target_name) {
375      visibility = [ ":*" ]
376      configs = skia_library_configs
377
378      # "*" clobbers the current scope; append to existing configs
379      forward_variables_from(invoker,
380                             "*",
381                             [
382                               "configs",
383                               "public",
384                               "public_defines",
385                               "public_deps",
386                               "deps",
387                               "libs",
388                               "frameworks",
389                               "sources",
390                               "sources_for_tests",
391                               "sources_when_disabled",
392                             ])
393      if (defined(invoker.configs)) {
394        configs += invoker.configs
395      }
396      if (defined(invoker.sources_when_disabled)) {
397        sources = invoker.sources_when_disabled
398      }
399    }
400    if (defined(invoker.sources_for_tests)) {
401      skia_source_set(target_name + "_tests") {
402        visibility = [ ":*" ]
403      }
404    }
405  }
406}
407
408optional("android_utils") {
409  enabled = skia_enable_android_utils
410
411  public = [
412    "client_utils/android/BRDAllocator.h",
413    "client_utils/android/BitmapRegionDecoder.h",
414    "client_utils/android/FrontBufferedStream.h",
415  ]
416  public_defines = [ "SK_ENABLE_ANDROID_UTILS" ]
417  sources = [
418    "client_utils/android/BitmapRegionDecoder.cpp",
419    "client_utils/android/FrontBufferedStream.cpp",
420  ]
421}
422
423group("fontmgr_factory") {
424  public_deps = [ skia_fontmgr_factory ]
425}
426
427optional("fontmgr_empty_factory") {
428  if (use_oh_skia) {
429    enabled = false
430  } else {
431    enabled = true
432  }
433  sources = [ "src/ports/SkFontMgr_empty_factory.cpp" ]
434}
435
436optional("fontmgr_android") {
437  enabled = skia_enable_fontmgr_android
438
439  deps = [
440    ":typeface_freetype",
441    "${skia_third_party_dir}/expat",
442  ]
443  public = [ "include/ports/SkFontMgr_android.h" ]
444  sources = [
445    "src/ports/SkFontMgr_android.cpp",
446    "src/ports/SkFontMgr_android_parser.cpp",
447    "src/ports/SkFontMgr_android_parser.h",
448  ]
449  sources_for_tests = [ "tests/FontMgrAndroidParserTest.cpp" ]
450}
451optional("fontmgr_android_factory") {
452  enabled = skia_enable_fontmgr_android
453  deps = [ ":fontmgr_android" ]
454  sources = [ "src/ports/SkFontMgr_android_factory.cpp" ]
455}
456
457optional("fontmgr_custom") {
458  enabled =
459      skia_enable_fontmgr_custom_directory ||
460      skia_enable_fontmgr_custom_embedded || skia_enable_fontmgr_custom_empty
461
462  deps = [ ":typeface_freetype" ]
463  public = [ "src/ports/SkFontMgr_custom.h" ]
464  sources = [ "src/ports/SkFontMgr_custom.cpp" ]
465}
466
467optional("fontmgr_custom_directory") {
468  enabled = skia_enable_fontmgr_custom_directory
469
470  deps = [
471    ":fontmgr_custom",
472    ":typeface_freetype",
473  ]
474  public = [ "include/ports/SkFontMgr_directory.h" ]
475  sources = [ "src/ports/SkFontMgr_custom_directory.cpp" ]
476}
477optional("fontmgr_custom_directory_factory") {
478  enabled = skia_enable_fontmgr_custom_directory
479  deps = [ ":fontmgr_custom_directory" ]
480  sources = [ "src/ports/SkFontMgr_custom_directory_factory.cpp" ]
481  if (defined(use_rosen_drawing) && use_rosen_drawing) {
482    defines = [ "USE_ROSEN_DRAWING" ]
483    if (use_linux) {
484      defines += [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_LINUX" ]
485    }
486  }
487  if (is_arkui_x) {
488    sources -= [ "src/ports/SkFontMgr_custom_directory_factory.cpp" ]
489  }
490}
491
492optional("fontmgr_custom_embedded") {
493  enabled = skia_enable_fontmgr_custom_embedded
494
495  deps = [
496    ":fontmgr_custom",
497    ":typeface_freetype",
498  ]
499  sources = [ "src/ports/SkFontMgr_custom_embedded.cpp" ]
500}
501optional("fontmgr_custom_embedded_factory") {
502  enabled = skia_enable_fontmgr_custom_embedded
503  deps = [ ":fontmgr_custom_embedded" ]
504  sources = [ "src/ports/SkFontMgr_custom_embedded_factory.cpp" ]
505}
506
507optional("fontmgr_custom_empty") {
508  enabled = skia_enable_fontmgr_custom_empty
509
510  deps = [
511    ":fontmgr_custom",
512    ":typeface_freetype",
513  ]
514  public = [ "include/ports/SkFontMgr_empty.h" ]
515  sources = [ "src/ports/SkFontMgr_custom_empty.cpp" ]
516}
517optional("fontmgr_custom_empty_factory") {
518  enabled = skia_enable_fontmgr_custom_empty
519  deps = [ ":fontmgr_custom_empty" ]
520  sources = [ "src/ports/SkFontMgr_custom_empty_factory.cpp" ]
521}
522
523optional("fontmgr_fontconfig") {
524  if (use_oh_skia) {
525    enabled = false
526  } else {
527    enabled = skia_enable_fontmgr_fontconfig
528  }
529
530  # The public header includes fontconfig.h and uses FcConfig*
531  public_deps = [ "${skia_third_party_dir}:fontconfig" ]
532  public = [ "include/ports/SkFontMgr_fontconfig.h" ]
533  deps = [ ":typeface_freetype" ]
534  sources = [ "src/ports/SkFontMgr_fontconfig.cpp" ]
535  sources_for_tests = [ "tests/FontMgrFontConfigTest.cpp" ]
536}
537optional("fontmgr_fontconfig_factory") {
538  if (use_oh_skia) {
539    enabled = false
540  } else {
541    enabled = skia_enable_fontmgr_fontconfig
542  }
543
544  deps = [ ":fontmgr_fontconfig" ]
545  sources = [ "src/ports/SkFontMgr_fontconfig_factory.cpp" ]
546}
547
548optional("fontmgr_FontConfigInterface") {
549  if (use_oh_skia) {
550    enabled = false
551  } else {
552    enabled = skia_enable_fontmgr_FontConfigInterface
553  }
554
555  deps = [
556    ":typeface_freetype",
557    "${skia_third_party_dir}:fontconfig",
558  ]
559  public = [
560    "include/ports/SkFontConfigInterface.h",
561    "include/ports/SkFontMgr_FontConfigInterface.h",
562  ]
563  sources = [
564    "src/ports/SkFontConfigInterface.cpp",
565    "src/ports/SkFontConfigInterface_direct.cpp",
566    "src/ports/SkFontConfigInterface_direct_factory.cpp",
567    "src/ports/SkFontConfigTypeface.h",
568    "src/ports/SkFontMgr_FontConfigInterface.cpp",
569  ]
570}
571optional("fontmgr_FontConfigInterface_factory") {
572  enabled = skia_enable_fontmgr_FontConfigInterface
573  deps = [ ":fontmgr_FontConfigInterface" ]
574  sources = [ "src/ports/SkFontMgr_FontConfigInterface_factory.cpp" ]
575}
576
577optional("fontmgr_fuchsia") {
578  enabled = skia_enable_fontmgr_fuchsia
579
580  deps = []
581
582  if (is_fuchsia && using_fuchsia_sdk) {
583    deps += [ "${skia_root_dir}/build/fuchsia/fidl:fuchsia.fonts" ]
584  } else {
585    deps = [ "${skia_root_dir}/sdk/fidl/fuchsia.fonts" ]
586  }
587  public = [ "src/ports/SkFontMgr_fuchsia.h" ]
588  sources = [ "src/ports/SkFontMgr_fuchsia.cpp" ]
589}
590
591optional("fontmgr_mac_ct") {
592  enabled = skia_use_fonthost_mac
593
594  public = [
595    "include/ports/SkFontMgr_mac_ct.h",
596    "include/ports/SkTypeface_mac.h",
597  ]
598  sources = [
599    "src/ports/SkFontMgr_mac_ct.cpp",
600    "src/ports/SkScalerContext_mac_ct.cpp",
601    "src/ports/SkScalerContext_mac_ct.h",
602    "src/ports/SkTypeface_mac_ct.cpp",
603    "src/ports/SkTypeface_mac_ct.h",
604  ]
605  if (use_oh_skia && !is_arkui_x) {
606    # Use hos font
607    sources += [
608      "//third_party/skia/src/ports/SkFontMgr_config_parser.cpp",
609      "//third_party/skia/src/ports/SkFontMgr_config_parser.h",
610      "//third_party/skia/src/ports/SkFontMgr_preview.cpp",
611      "//third_party/skia/src/ports/SkFontMgr_preview.h",
612    ]
613    defines = [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_MAC" ]
614  }
615  sources_for_tests = [ "tests/TypefaceMacTest.cpp" ]
616
617  if (is_mac) {
618    frameworks = [
619      # AppKit symbols NSFontWeightXXX may be dlsym'ed.
620      "AppKit.framework",
621      "ApplicationServices.framework",
622    ]
623  }
624
625  if (is_ios) {
626    frameworks = [
627      "CoreFoundation.framework",
628      "CoreGraphics.framework",
629      "CoreText.framework",
630
631      # UIKit symbols UIFontWeightXXX may be dlsym'ed.
632      "UIKit.framework",
633    ]
634  }
635}
636optional("fontmgr_mac_ct_factory") {
637  enabled = skia_use_fonthost_mac
638  deps = [ ":fontmgr_mac_ct" ]
639  sources = [ "src/ports/SkFontMgr_mac_ct_factory.cpp" ]
640  defines = [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_MAC" ]
641  if (is_arkui_x) {
642    defines += [ "USE_DEFAULT_FONT" ]
643  }
644}
645
646optional("fontmgr_win") {
647  enabled = skia_enable_fontmgr_win
648
649  public = [ "include/ports/SkTypeface_win.h" ]
650  sources = [
651    "src/fonts/SkFontMgr_indirect.cpp",
652    "src/ports/SkFontMgr_win_dw.cpp",
653    "src/ports/SkScalerContext_win_dw.cpp",
654    "src/ports/SkScalerContext_win_dw.h",
655    "src/ports/SkTypeface_win_dw.cpp",
656    "src/ports/SkTypeface_win_dw.h",
657  ]
658  if (use_oh_skia) {
659    # Use hos font
660    sources += [
661      "//third_party/skia/src/ports/SkFontMgr_config_parser.cpp",
662      "//third_party/skia/src/ports/SkFontMgr_config_parser.h",
663      "//third_party/skia/src/ports/SkFontMgr_preview.cpp",
664      "//third_party/skia/src/ports/SkFontMgr_preview.h",
665    ]
666    defines = [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_WIN" ]
667    deps = [ "${skia_third_party_dir}/expat" ]
668  }
669}
670
671if (use_oh_skia && !is_arkui_x) {
672  ohos_prebuilt_etc("ohos_fontconfig.json") {
673    source = "//third_party/skia/src/ports/skia_ohos/config/fontconfig.json"
674    part_name = "skia"
675    subsystem_name = "thirdparty"
676  }
677
678  optional("fontmgr_ohos") {
679    enabled = skia_enable_fontmgr_ohos
680
681    public = [
682      "src/ports/skia_ohos/FontConfig_ohos.h",
683      "src/ports/skia_ohos/FontInfo_ohos.h",
684      "src/ports/skia_ohos/SkFontMgr_ohos.h",
685      "src/ports/skia_ohos/SkFontStyleSet_ohos.h",
686      "src/ports/skia_ohos/SkTypeface_ohos.h",
687    ]
688    sources = [
689      "src/ports/skia_ohos/FontConfig_ohos.cpp",
690      "src/ports/skia_ohos/SkFontMgr_ohos.cpp",
691      "src/ports/skia_ohos/SkFontMgr_ohos_factory.cpp",
692      "src/ports/skia_ohos/SkFontStyleSet_ohos.cpp",
693      "src/ports/skia_ohos/SkTypeface_ohos.cpp",
694    ]
695
696    include_dirs = [
697      "//third_party/skia/include/private",
698      "//third_party/skia/include/core",
699      "//third_party/skia/src/core",
700      "//third_party/skia/src/ports",
701      "//third_party/skia/src/ports/skia_ohos",
702    ]
703
704    deps = [
705      ":typeface_freetype",
706      "${skia_third_party_dir}/expat",
707      "//third_party/jsoncpp:jsoncpp_static",
708    ]
709    if (is_component_build) {
710      deps += [ "//third_party/bounds_checking_function:libsec_shared" ]
711    } else {
712      deps += [ "//third_party/bounds_checking_function:libsec_static" ]
713    }
714
715    deps += [ ":ohos_fontconfig.json" ]
716
717    if (graphic_2d_feature_wuji_enable) {
718      deps += [ "$ace_graphic_ext:ohos_fonts_wuji" ]
719    } else if (ace_engine_standard_fonts_enable) {
720      deps += [ "//base/global/system_resources:ohos_fonts" ]
721    }
722
723    if (use_mingw_win) {
724      defines = [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_WIN" ]
725    } else if (use_mac) {
726      defines = [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_MAC" ]
727    } else if (use_linux) {
728      defines = [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_LINUX" ]
729    } else if (is_ohos) {
730      defines = [ "SK_BUILD_FONT_MGR_FOR_OHOS" ]
731    }
732  }
733}
734
735optional("fontmgr_win_factory") {
736  enabled = skia_enable_fontmgr_win
737  deps = [ ":fontmgr_win" ]
738  sources = [ "src/ports/SkFontMgr_win_dw_factory.cpp" ]
739  defines = [ "SK_BUILD_FONT_MGR_FOR_PREVIEW_WIN" ]
740}
741
742optional("fontmgr_win_gdi") {
743  enabled = skia_enable_fontmgr_win_gdi
744
745  public = [ "include/ports/SkTypeface_win.h" ]
746  sources = [ "src/ports/SkFontHost_win.cpp" ]
747
748  # libs = [ "Gdi32.lib" ]
749  libs = [ "gdi32" ]
750}
751
752if (skia_lex) {
753  skia_executable("sksllex") {
754    sources = [
755      "src/sksl/lex/DFA.h",
756      "src/sksl/lex/DFAState.h",
757      "src/sksl/lex/LexUtil.h",
758      "src/sksl/lex/Main.cpp",
759      "src/sksl/lex/NFA.cpp",
760      "src/sksl/lex/NFA.h",
761      "src/sksl/lex/NFAState.h",
762      "src/sksl/lex/NFAtoDFA.h",
763      "src/sksl/lex/RegexNode.cpp",
764      "src/sksl/lex/RegexNode.h",
765      "src/sksl/lex/RegexParser.cpp",
766      "src/sksl/lex/RegexParser.h",
767      "src/sksl/lex/TransitionTable.cpp",
768      "src/sksl/lex/TransitionTable.h",
769    ]
770    include_dirs = [ "." ]
771  }
772
773  action("run_sksllex") {
774    script = "gn/run_sksllex.py"
775    deps = [ ":sksllex(//gn/toolchain:$host_toolchain)" ]
776    sources = [ "src/sksl/lex/sksl.lex" ]
777
778    # GN insists its outputs should go somewhere underneath target_out_dir, so we trick it with a
779    # path that starts with target_out_dir and then uses ".." to back up into the src dir.
780    outputs = [
781      "$target_out_dir/" + rebase_path("src/sksl/SkSLLexer.h", target_out_dir),
782      # the script also modifies the corresponding .cpp file, but if we tell GN that it gets
783      # confused due to the same file being named by two different paths
784    ]
785    sksllex_path = "$root_out_dir/"
786    sksllex_path += "sksllex"
787    if (host_os == "win") {
788      sksllex_path += ".exe"
789    }
790    args = [
791      rebase_path(sksllex_path),
792      rebase_path("bin/clang-format"),
793      rebase_path("bin/fetch-clang-format"),
794      rebase_path("src"),
795    ]
796  }
797} else {
798  group("run_sksllex") {
799  }
800}
801
802# `Compile SkSL Tests` relies on skslc.
803if (skia_compile_sksl_tests) {
804  skia_executable("skslc") {
805    defines = [
806      "SKSL_STANDALONE",
807      "SK_DISABLE_TRACING",
808      "SK_ENABLE_SPIRV_CROSS",
809      "SK_ENABLE_SPIRV_VALIDATION",
810    ]
811    sources = [
812      "src/core/SkArenaAlloc.cpp",
813      "src/core/SkBlockAllocator.cpp",
814      "src/core/SkCpu.cpp",
815      "src/core/SkData.cpp",
816      "src/core/SkHalf.cpp",
817      "src/core/SkMalloc.cpp",
818      "src/core/SkMath.cpp",
819      "src/core/SkMatrixInvert.cpp",
820      "src/core/SkSemaphore.cpp",
821      "src/core/SkStream.cpp",
822      "src/core/SkString.cpp",
823      "src/core/SkStringUtils.cpp",
824      "src/core/SkStringView.cpp",
825      "src/core/SkThreadID.cpp",
826      "src/core/SkUtils.cpp",
827      "src/core/SkVM.cpp",
828      "src/gpu/GrMemoryPool.cpp",
829      "src/gpu/GrShaderUtils.cpp",
830      "src/ports/SkMemory_malloc.cpp",
831      "src/ports/SkOSFile_stdio.cpp",
832      "src/sksl/SkSLMain.cpp",
833      "src/utils/SkJSON.cpp",
834      "src/utils/SkJSONWriter.cpp",
835      "src/utils/SkParse.cpp",
836      "src/utils/SkUTF.cpp",
837    ]
838    if (is_win) {
839      sources += [ "src/ports/SkOSFile_win.cpp" ]
840    } else {
841      sources += [ "src/ports/SkOSFile_posix.cpp" ]
842    }
843    sources += skia_sksl_sources
844    sources += skia_sksl_gpu_sources
845    include_dirs = [ "." ]
846    deps = [
847      ":run_sksllex",
848      "${skia_third_party_dir}/externals/spirv-tools:spvtools",
849      "${skia_third_party_dir}/externals/spirv-tools:spvtools_val",
850      "${skia_third_party_dir}/spirv-cross:spirv_cross",
851    ]
852  }
853
854  skslc_path = "$root_out_dir/"
855  if (host_toolchain != default_toolchain_name) {
856    skslc_path += "$host_toolchain/"
857  }
858  skslc_path += "skslc"
859  if (host_os == "win") {
860    skslc_path += ".exe"
861  }
862
863  copy("sksl_pre_includes") {
864    sources = [
865      "src/sksl/sksl_frag.sksl",
866      "src/sksl/sksl_gpu.sksl",
867      "src/sksl/sksl_public.sksl",
868      "src/sksl/sksl_rt_shader.sksl",
869      "src/sksl/sksl_vert.sksl",
870    ]
871    outputs = [ "$root_out_dir/{{source_file_part}}" ]
872  }
873
874  dehydrate_sksl_sources = get_target_outputs(":sksl_pre_includes")
875
876  dehydrate_sksl_outputs = []
877  foreach(src, dehydrate_sksl_sources) {
878    name = get_path_info(src, "name")
879
880    # GN insists its outputs should go somewhere underneath target_out_dir, so we trick it with a
881    # path that starts with target_out_dir and then uses ".." to back up into the src dir.
882    dehydrate_sksl_outputs += [ "$target_out_dir/" + rebase_path(
883                                    "src/sksl/generated/$name.dehydrated.sksl",
884                                    target_out_dir) ]
885  }
886
887  action("dehydrate_sksl") {
888    script = "gn/dehydrate_sksl.py"
889    deps = [
890      ":sksl_pre_includes",
891      ":skslc(//gn/toolchain:$host_toolchain)",
892    ]
893    sources = dehydrate_sksl_sources
894    outputs = dehydrate_sksl_outputs
895    args = [
896      rebase_path(skslc_path),
897      rebase_path("src/sksl/generated"),
898    ]
899    args += rebase_path(dehydrate_sksl_sources)
900  }
901} else {
902  group("dehydrate_sksl") {
903  }
904}
905
906if (skia_compile_sksl_tests) {
907  import("gn/sksl_tests.gni")
908
909  template("compile_sksl") {
910    # Compile the passed-in `sources` into `outputs` using skslc, with the given language/settings.
911    action("compile_sksl_${target_name}") {
912      script = "gn/compile_sksl_tests.py"
913      deps = [
914        ":sksl_pre_includes",
915        ":skslc(//gn/toolchain:$host_toolchain)",
916      ]
917      sources = []
918      outputs = []
919      response_file_contents = []
920      args = [
921        rebase_path(skslc_path),
922        invoker.lang,
923        invoker.settings,
924        "{{response_file_name}}",
925      ]
926
927      testsDir = get_path_info("tests", "abspath")
928      resourcesDir = get_path_info("resources", "abspath")
929
930      foreach(partialPath, invoker.sources) {
931        dst = testsDir + partialPath
932        src = resourcesDir + partialPath
933
934        dir = get_path_info(dst, "dir")
935
936        # We want to support double-extensions (for '.dsl.cpp') but GN doesn't natively handle this.
937        # Workaround: http://go/ggroup/a/chromium.org/g/gn-dev/c/RdEpjeYtb-4
938        # For input path "file.aa.bb", name will contain "file" and ext will contain ".aa.bb".
939        # For input path "file.cc", name will contain "file" and ext will contain ".cc".
940        nameTmp = get_path_info(dst, "name")
941        name = get_path_info(nameTmp, "name")
942        ext = get_path_info(nameTmp, "extension")
943        ext += get_path_info(dst, "extension")
944        response_file_contents += rebase_path([
945                                                src,
946                                                dir,
947                                              ])
948        sources += [ src ]
949
950        foreach(outExtension, invoker.outExtensions) {
951          # SPIR-V uses separate extensions for .vert shaders.
952          if (ext == "vert" && outExtension == ".asm.frag") {
953            outExtension = ".asm.vert"
954          }
955          outputs +=
956              [ target_out_dir + "/" +
957                rebase_path(dir + "/" + name + outExtension, target_out_dir) ]
958        }
959      }
960    }
961  }
962  compile_sksl("glsl_tests") {
963    sources = sksl_glsl_tests_sources + sksl_glsl_settings_tests_sources
964    outExtensions = [ ".glsl" ]
965    lang = "--glsl"
966    settings = "--settings"
967  }
968  compile_sksl("glsl_nosettings_tests") {
969    sources = sksl_glsl_settings_tests_sources
970    outExtensions = [ "StandaloneSettings.glsl" ]
971    lang = "--glsl"
972    settings = "--nosettings"
973  }
974  compile_sksl("metal_tests") {
975    sources = sksl_metal_tests_sources
976    outExtensions = [ ".metal" ]
977    lang = "--metal"
978    settings = "--settings"
979  }
980  compile_sksl("skvm_tests") {
981    sources = sksl_skvm_tests_sources
982    outExtensions = [ ".skvm" ]
983    lang = "--skvm"
984    settings = "--settings"
985  }
986  compile_sksl("stage_tests") {
987    sources = sksl_stage_tests_sources
988    outExtensions = [ ".stage" ]
989    lang = "--stage"
990    settings = "--settings"
991  }
992  compile_sksl("spirv_tests") {
993    sources = sksl_spirv_tests_sources
994    outExtensions = [ ".asm.frag" ]
995    lang = "--spirv"
996    settings = "--settings"
997  }
998} else {
999  group("compile_sksl_glsl_tests") {
1000  }
1001  group("compile_sksl_glsl_nosettings_tests") {
1002  }
1003  group("compile_sksl_metal_tests") {
1004  }
1005  group("compile_sksl_skvm_tests") {
1006  }
1007  group("compile_sksl_spirv_tests") {
1008  }
1009}
1010
1011optional("gpu_shared") {
1012  enabled = skia_enable_gpu || skia_enable_graphite
1013
1014  sources = skia_shared_gpu_sources
1015}
1016
1017optional("gpu") {
1018  enabled = skia_enable_gpu
1019  deps = [
1020    ":compile_sksl_glsl_nosettings_tests",
1021    ":compile_sksl_glsl_tests",
1022    ":compile_sksl_metal_tests",
1023    ":compile_sksl_skvm_tests",
1024    ":compile_sksl_spirv_tests",
1025    ":dehydrate_sksl",
1026    ":gpu_shared",
1027    ":run_sksllex",
1028  ]
1029  if (skia_generate_workarounds) {
1030    deps += [ ":workaround_list" ]
1031  }
1032  public_defines = []
1033  public_configs = []
1034  public_deps = []
1035
1036  sources = skia_gpu_sources + skia_sksl_gpu_sources
1037  if (!skia_enable_skgpu_v1) {
1038    sources -= skia_skgpu_v1_sources
1039  }
1040
1041  libs = []
1042  frameworks = []
1043
1044  if (skia_use_gl) {
1045    public_defines += [ "SK_GL" ]
1046    if (is_android) {
1047      sources += [
1048        "src/gpu/gl/egl/GrGLMakeEGLInterface.cpp",
1049        "src/gpu/gl/egl/GrGLMakeNativeInterface_egl.cpp",
1050      ]
1051
1052      # this lib is required to link against AHardwareBuffer
1053      libs += [ "android" ]
1054    } else if (skia_use_egl || is_ohos) {
1055      sources += [
1056        "src/gpu/gl/egl/GrGLMakeEGLInterface.cpp",
1057        "src/gpu/gl/egl/GrGLMakeNativeInterface_egl.cpp",
1058      ]
1059      if (use_oh_skia) {
1060        include_dirs = [
1061          "//third_party/EGL/api",
1062          "//third_party/openGLES/api",
1063        ]
1064        deps += [ "//foundation/graphic/graphic_2d:libgl" ]
1065      } else {
1066        libs += [ "EGL" ]
1067      }
1068    } else if (skia_use_webgl) {
1069      sources += [ "src/gpu/gl/webgl/GrGLMakeNativeInterface_webgl.cpp" ]
1070    } else if (is_linux && skia_use_x11) {
1071      sources += [
1072        "src/gpu/gl/glx/GrGLMakeGLXInterface.cpp",
1073        "src/gpu/gl/glx/GrGLMakeNativeInterface_glx.cpp",
1074      ]
1075      libs += [ "GL" ]
1076    } else if (is_mac) {
1077      sources += [ "src/gpu/gl/mac/GrGLMakeNativeInterface_mac.cpp" ]
1078    } else if (is_ios) {
1079      sources += [ "src/gpu/gl/iOS/GrGLMakeNativeInterface_iOS.cpp" ]
1080    } else if (is_win && !skia_enable_winuwp) {
1081      sources += [ "src/gpu/gl/win/GrGLMakeNativeInterface_win.cpp" ]
1082      libs += [ "opengl32" ]
1083    } else {
1084      sources += [ "src/gpu/gl/GrGLMakeNativeInterface_none.cpp" ]
1085    }
1086    sources += skia_gl_gpu_sources
1087  }
1088
1089  if (skia_use_vulkan) {
1090    public_defines += [ "SK_VULKAN" ]
1091    if (skia_use_vma) {
1092      deps += [ "third_party/vulkanmemoryallocator" ]
1093    }
1094    sources += skia_vk_sources
1095    if (skia_enable_vulkan_debug_layers) {
1096      public_defines += [ "SK_ENABLE_VK_LAYERS" ]
1097    }
1098    if (is_fuchsia) {
1099      if (using_fuchsia_sdk) {
1100        public_deps += [ "$fuchsia_sdk_root/pkg:vulkan" ]
1101      } else {
1102        public_deps += [ "${skia_root_dir}/src/graphics/lib/vulkan" ]
1103      }
1104    }
1105  }
1106
1107  if (is_android && (skia_use_gl || skia_use_vulkan)) {
1108    # this lib is required to link against AHardwareBuffer
1109    if (defined(ndk_api) && ndk_api >= 26) {
1110      libs += [ "android" ]
1111    }
1112  }
1113
1114  if (skia_use_dawn) {
1115    public_defines += [ "SK_DAWN" ]
1116    sources += skia_dawn_sources
1117    public_deps +=
1118        [ "${skia_third_party_dir}/externals/dawn/src/dawn:dawn_headers" ]
1119    deps += [
1120      "${skia_third_party_dir}/externals/dawn/src/dawn:dawn_proc",
1121      "${skia_third_party_dir}/externals/dawn/src/dawn:dawncpp",
1122    ]
1123    if (dawn_enable_d3d12 || dawn_enable_desktop_gl || dawn_enable_metal ||
1124        dawn_enable_opengles || dawn_enable_vulkan) {
1125      deps += [ "${skia_third_party_dir}/externals/dawn/src/dawn_native" ]
1126    }
1127    if (dawn_enable_d3d12) {
1128      libs += [
1129        "d3d12.lib",
1130        "dxgi.lib",
1131        "d3dcompiler.lib",
1132      ]
1133    } else if (dawn_enable_metal) {
1134      frameworks += [ "Metal.framework" ]
1135    }
1136  }
1137
1138  if (skia_use_direct3d) {
1139    public_defines += [
1140      "SK_DIRECT3D",
1141      "SK_ENABLE_SPIRV_CROSS",
1142    ]
1143    deps += [
1144      "${skia_third_party_dir}/d3d12allocator",
1145      "${skia_third_party_dir}/spirv-cross:spirv_cross",
1146    ]
1147    sources += skia_direct3d_sources
1148    if (skia_enable_direct3d_debug_layer) {
1149      public_defines += [ "SK_ENABLE_D3D_DEBUG_LAYER" ]
1150    }
1151    libs += [
1152      "d3d12.lib",
1153      "dxgi.lib",
1154      "d3dcompiler.lib",
1155    ]
1156  }
1157
1158  cflags_objcc = []
1159  if (skia_use_metal) {
1160    public_defines += [ "SK_METAL" ]
1161    sources += skia_metal_sources
1162    if (skia_enable_metal_debug_info) {
1163      public_defines += [ "SK_ENABLE_MTL_DEBUG_INFO" ]
1164    }
1165    frameworks += [ "Metal.framework" ]
1166    frameworks += [ "Foundation.framework" ]
1167    if (is_ios) {
1168      frameworks += [ "UIKit.framework" ]
1169    }
1170    cflags_objcc += [ "-fobjc-arc" ]
1171  }
1172
1173  if (is_debug) {
1174    public_defines += [ "SK_ENABLE_DUMP_GPU" ]
1175  }
1176}
1177
1178optional("gif") {
1179  enabled = !skia_use_wuffs && skia_use_libgifcodec
1180  _libgifcodec_gni_path = "third_party/externals/libgifcodec/libgifcodec.gni"
1181  if ("True" ==
1182      exec_script("gn/checkpath.py",
1183                  [ rebase_path(_libgifcodec_gni_path, root_build_dir) ],
1184                  "trim string")) {
1185    public_defines = [ "SK_USE_LIBGIFCODEC" ]
1186    public_include_dirs = [
1187      ".",
1188      skia_libgifcodec_path,
1189    ]
1190    include_dirs = public_include_dirs
1191    import(_libgifcodec_gni_path)
1192    sources = rebase_path(libgifcodec_sources + libgifcodec_public,
1193                          ".",
1194                          skia_libgifcodec_path)
1195  }
1196}
1197
1198optional("heif") {
1199  enabled = skia_use_libheif
1200  public_defines = [ "SK_HAS_HEIF_LIBRARY" ]
1201
1202  # This HEIF decoding functionality is a part of the Android Framework.
1203  # https://android.googlesource.com/platform/frameworks/av/+/master/media/libheif/include/HeifDecoderAPI.h
1204  # There isn't a way to compile that library outside of it, so we just link against
1205  # the library. This feature is not supported on other platforms (and we haven't
1206  # yet tried something like https://github.com/strukturag/libheif/tree/master/libheif).
1207  # The dependency for Android is set in gn_to_bp.py.
1208  deps = []
1209
1210  sources = [ "src/codec/SkHeifCodec.cpp" ]
1211}
1212
1213optional("jpeg_decode") {
1214  enabled = skia_use_libjpeg_turbo_decode
1215  public_defines = [ "SK_CODEC_DECODES_JPEG" ]
1216
1217  deps = [ "${skia_third_party_dir}/libjpeg-turbo:libjpeg" ]
1218  sources = [
1219    "src/codec/SkJpegCodec.cpp",
1220    "src/codec/SkJpegDecoderMgr.cpp",
1221    "src/codec/SkJpegUtility.cpp",
1222  ]
1223}
1224
1225optional("jpeg_encode") {
1226  enabled = skia_use_libjpeg_turbo_encode
1227  public_defines = [ "SK_ENCODE_JPEG" ]
1228
1229  deps = [ "${skia_third_party_dir}/libjpeg-turbo:libjpeg" ]
1230  public = [ "include/encode/SkJpegEncoder.h" ]
1231  sources = [
1232    "src/images/SkJPEGWriteUtility.cpp",
1233    "src/images/SkJpegEncoder.cpp",
1234  ]
1235}
1236
1237optional("ndk_images") {
1238  enabled = skia_use_ndk_images
1239  public_defines = [ "SK_ENABLE_NDK_IMAGES" ]
1240  sources = [
1241    "src/ports/SkImageEncoder_NDK.cpp",
1242    "src/ports/SkImageGeneratorNDK.cpp",
1243    "src/ports/SkNDKConversions.cpp",
1244  ]
1245  libs = [ "jnigraphics" ]
1246}
1247
1248optional("graphite") {
1249  libs = []
1250  frameworks = []
1251
1252  enabled = skia_enable_graphite
1253  deps = [ ":gpu_shared" ]
1254  public_defines = [ "SK_GRAPHITE_ENABLED" ]
1255  public = skia_graphite_public
1256  sources = skia_graphite_sources
1257  if (skia_use_metal) {
1258    public_defines += [ "SK_METAL" ]
1259    sources += skia_graphite_mtl_sources
1260    if (skia_enable_metal_debug_info) {
1261      public_defines += [ "SK_ENABLE_MTL_DEBUG_INFO" ]
1262    }
1263    frameworks += [ "Metal.framework" ]
1264    frameworks += [ "Foundation.framework" ]
1265  }
1266}
1267
1268optional("pdf") {
1269  enabled = skia_use_zlib && skia_enable_pdf
1270  public_defines = [ "SK_SUPPORT_PDF" ]
1271
1272  if (use_oh_skia) {
1273    deps = [ "//third_party/zlib:libz" ]
1274  } else {
1275    deps = [ "${skia_third_party_dir}/zlib" ]
1276  }
1277  if (skia_use_libjpeg_turbo_decode) {
1278    deps += [ ":jpeg_decode" ]
1279  }
1280  if (skia_use_libjpeg_turbo_encode) {
1281    deps += [ ":jpeg_encode" ]
1282  }
1283  public = skia_pdf_public
1284  sources = skia_pdf_sources
1285  sources_when_disabled = [ "src/pdf/SkDocument_PDF_None.cpp" ]
1286  if (skia_use_icu && skia_use_harfbuzz && skia_pdf_subset_harfbuzz) {
1287    deps += [ "${skia_third_party_dir}/harfbuzz" ]
1288    defines = [ "SK_PDF_USE_HARFBUZZ_SUBSET" ]
1289  } else if (skia_use_icu && skia_use_sfntly) {
1290    deps += [ "${skia_third_party_dir}/sfntly" ]
1291    defines = [ "SK_PDF_USE_SFNTLY" ]
1292  }
1293}
1294
1295optional("xps") {
1296  enabled = skia_use_xps && is_win && !is_mingw
1297  public_defines = [ "SK_SUPPORT_XPS" ]
1298  public = skia_xps_public
1299  sources = skia_xps_sources
1300}
1301
1302optional("png_decode") {
1303  enabled = skia_use_libpng_decode
1304  public_defines = [ "SK_CODEC_DECODES_PNG" ]
1305
1306  deps = [ "${skia_third_party_dir}/libpng" ]
1307  sources = [
1308    "src/codec/SkIcoCodec.cpp",
1309    "src/codec/SkPngCodec.cpp",
1310  ]
1311}
1312
1313optional("png_encode") {
1314  enabled = skia_use_libpng_encode
1315  public_defines = [ "SK_ENCODE_PNG" ]
1316
1317  deps = [ "${skia_third_party_dir}/libpng" ]
1318  sources = [ "src/images/SkPngEncoder.cpp" ]
1319}
1320
1321optional("raw") {
1322  enabled = skia_use_dng_sdk && skia_use_libjpeg_turbo_decode && skia_use_piex
1323  public_defines = [ "SK_CODEC_DECODES_RAW" ]
1324
1325  deps = [
1326    "${skia_third_party_dir}/dng_sdk",
1327    "${skia_third_party_dir}/libjpeg-turbo:libjpeg",
1328    "${skia_third_party_dir}/piex",
1329  ]
1330
1331  # SkRawCodec catches any exceptions thrown by dng_sdk, insulating the rest of
1332  # Skia.
1333  configs = [ "gn/portable:add_exceptions" ]
1334
1335  sources = [ "src/codec/SkRawCodec.cpp" ]
1336}
1337
1338import("third_party/skcms/skcms.gni")
1339skia_source_set("skcms") {
1340  cflags = []
1341  if (!is_win || is_clang) {
1342    cflags += [
1343      "-w",
1344      "-std=c++11",
1345    ]
1346  }
1347
1348  public = [ "include/third_party/skcms/skcms.h" ]
1349  include_dirs = [ "include/third_party/skcms" ]
1350  sources = rebase_path(skcms_sources, ".", "third_party/skcms")
1351}
1352
1353optional("typeface_freetype") {
1354  if (use_oh_skia) {
1355    enabled = skia_use_freetype2
1356  } else {
1357    enabled = skia_use_freetype
1358  }
1359
1360  deps = [ "${skia_third_party_dir}/freetype2" ]
1361  sources = [
1362    "src/ports/SkFontHost_FreeType.cpp",
1363    "src/ports/SkFontHost_FreeType_common.cpp",
1364    "src/ports/SkFontHost_FreeType_common.h",
1365  ]
1366}
1367
1368optional("webp_decode") {
1369  enabled = skia_use_libwebp_decode
1370  public_defines = [ "SK_CODEC_DECODES_WEBP" ]
1371
1372  deps = [ "${skia_third_party_dir}/libwebp" ]
1373  sources = [ "src/codec/SkWebpCodec.cpp" ]
1374}
1375
1376optional("webp_encode") {
1377  enabled = skia_use_libwebp_encode
1378  public_defines = [ "SK_ENCODE_WEBP" ]
1379
1380  deps = [ "${skia_third_party_dir}/libwebp" ]
1381  sources = [ "src/images/SkWebpEncoder.cpp" ]
1382}
1383
1384optional("wuffs") {
1385  enabled = skia_use_wuffs
1386  public_defines = [ "SK_HAS_WUFFS_LIBRARY" ]
1387
1388  deps = [ "${skia_third_party_dir}/wuffs" ]
1389  sources = [ "src/codec/SkWuffsCodec.cpp" ]
1390}
1391
1392optional("xml") {
1393  enabled = skia_use_expat
1394  public_defines = [ "SK_XML" ]
1395
1396  deps = [ "${skia_third_party_dir}/expat" ]
1397  sources = [
1398    "src/svg/SkSVGCanvas.cpp",
1399    "src/svg/SkSVGDevice.cpp",
1400    "src/xml/SkDOM.cpp",
1401    "src/xml/SkDOMParser.cpp",
1402    "src/xml/SkXMLParser.cpp",
1403    "src/xml/SkXMLWriter.cpp",
1404  ]
1405}
1406
1407optional("skvm_jit") {
1408  enabled = skia_enable_skvm_jit_when_possible
1409  public_defines = [ "SKVM_JIT_WHEN_POSSIBLE" ]
1410  if (skia_vtune_path != "") {
1411    public_defines += [ "SKVM_JIT_VTUNE" ]
1412    public_include_dirs = [ "$skia_vtune_path/include" ]
1413    libs = [ "$skia_vtune_path/lib64/jitprofiling.lib" ]
1414  }
1415}
1416
1417if (skia_enable_gpu && skia_generate_workarounds) {
1418  action("workaround_list") {
1419    script = "tools/build_workaround_header.py"
1420
1421    inputs = [ "src/gpu/gpu_workaround_list.txt" ]
1422
1423    # GN insists its outputs should go somewhere underneath root_out_dir, so we trick it with a
1424    # path that starts with root_out_dir and then uses ".." to back up into the src dir.
1425    output_file =
1426        rebase_path("include/gpu/GrDriverBugWorkaroundsAutogen.h", root_out_dir)
1427
1428    outputs = [ "$root_out_dir/$output_file" ]
1429    args = [
1430      "--output-file",
1431      "$output_file",
1432    ]
1433
1434    foreach(file, inputs) {
1435      args += [ rebase_path(file, root_build_dir) ]
1436    }
1437  }
1438}
1439
1440skia_component("skia") {
1441}
1442
1443if (use_oh_skia) {
1444  config("skia_config") {
1445    include_dirs = [ "//third_party/skia" ]
1446
1447    defines = skia_common_defines
1448  }
1449
1450  config("harfbuzz_config") {
1451    include_dirs = [ "//third_party/skia/third_party/externals/harfbuzz/src" ]
1452
1453    defines = [
1454      "HAVE_ICU",
1455      "HAVE_ICU_BUILTIN",
1456      "HAVE_OT",
1457      "HAVE_CONFIG_OVERRIDE_H",
1458      "HB_NO_FALLBACK_SHAPE",
1459      "HB_NO_WIN1256",
1460    ]
1461  }
1462
1463  config("icu_config") {
1464    include_dirs = [ "${skia_third_party_dir}/externals/icu/source/common" ]
1465  }
1466
1467  template("make_skia_deps") {
1468    forward_variables_from(invoker, "*")
1469    ohos_source_set("skia_$platform") {
1470      part_name = "skia"
1471      subsystem_name = "thirdparty"
1472      license_file = "//third_party/skia/LICENSE"
1473      public_configs = [
1474        ":skia_config",
1475        ":harfbuzz_config",
1476        ":icu_config",
1477      ]
1478
1479      if (is_arkui_x) {
1480        public_deps = [ ":skia_canvaskit_static" ]
1481      } else {
1482        public_deps = [ ":skia_canvaskit" ]
1483      }
1484    }
1485  }
1486
1487  ohos_source_set("skia_canvaskit_static") {
1488    part_name = "skia"
1489    subsystem_name = "thirdparty"
1490
1491    include_dirs = [ "${skia_third_party_dir}/externals/libgifcodec" ]
1492    public_configs = [ ":skia_public" ]
1493    configs = skia_library_configs
1494    public_deps = [
1495      ":fontmgr_FontConfigInterface",
1496      ":fontmgr_android",
1497      ":fontmgr_custom_directory",
1498      ":fontmgr_custom_directory_factory",
1499      ":fontmgr_custom_embedded",
1500      ":fontmgr_fontconfig",
1501      ":skcms",
1502      ":xps",
1503    ]
1504
1505    if (is_ios) {
1506      public_deps += [ ":gpu" ]
1507    } else {
1508      if (defined(ace_enable_gpu) && ace_enable_gpu) {
1509        public_deps += [ ":gpu" ]
1510      }
1511    }
1512    deps = [
1513      ":android_utils",
1514      ":arm64",
1515      ":armv7",
1516      ":avx",
1517      ":crc32",
1518      ":fontmgr_factory",
1519      ":gif",
1520      ":heif",
1521      ":hsw",
1522      ":jpeg_decode",
1523      ":jpeg_encode",
1524      ":none",
1525      ":png_decode",
1526      ":png_encode",
1527      ":skvm_jit",
1528      ":skx",
1529      ":sse2",
1530      ":sse41",
1531      ":sse42",
1532      ":ssse3",
1533      ":webp_decode",
1534      ":webp_encode",
1535      ":xml",
1536      "modules/skresources",
1537      "modules/skshaper",
1538      "modules/skunicode",
1539      "modules/svg",
1540    ]
1541
1542    public = skia_core_public
1543    public += skia_utils_public
1544    public += skia_effects_public
1545    public += skia_effects_imagefilter_public
1546
1547    sources = []
1548    sources += skia_core_sources
1549    sources += skia_utils_sources
1550    sources += skia_effects_sources
1551    sources += skia_effects_imagefilter_sources
1552    sources += [
1553      "src/android/SkAndroidFrameworkUtils.cpp",
1554      "src/android/SkAnimatedImage.cpp",
1555      "src/codec/SkAndroidCodec.cpp",
1556      "src/codec/SkAndroidCodecAdapter.cpp",
1557      "src/codec/SkBmpBaseCodec.cpp",
1558      "src/codec/SkBmpCodec.cpp",
1559      "src/codec/SkBmpMaskCodec.cpp",
1560      "src/codec/SkBmpRLECodec.cpp",
1561      "src/codec/SkBmpStandardCodec.cpp",
1562      "src/codec/SkCodec.cpp",
1563      "src/codec/SkCodecImageGenerator.cpp",
1564      "src/codec/SkColorTable.cpp",
1565      "src/codec/SkEncodedInfo.cpp",
1566      "src/codec/SkMaskSwizzler.cpp",
1567      "src/codec/SkMasks.cpp",
1568      "src/codec/SkParseEncodedOrigin.cpp",
1569      "src/codec/SkSampledCodec.cpp",
1570      "src/codec/SkSampler.cpp",
1571      "src/codec/SkStreamBuffer.cpp",
1572      "src/codec/SkSwizzler.cpp",
1573      "src/codec/SkWbmpCodec.cpp",
1574      "src/images/SkImageEncoder.cpp",
1575      "src/ports/SkDiscardableMemory_none.cpp",
1576      "src/ports/SkGlobalInitialization_default.cpp",
1577      "src/ports/SkImageGenerator_skia.cpp",
1578      "src/ports/SkMemory_malloc.cpp",
1579      "src/ports/SkOSFile_stdio.cpp",
1580      "src/sfnt/SkOTTable_name.cpp",
1581      "src/sfnt/SkOTUtils.cpp",
1582    ]
1583
1584    defines = skia_common_defines
1585    cflags = skia_common_cflags
1586    if (!defined(ace_enable_gpu) || !ace_enable_gpu) {
1587      defines += [
1588        "SK_BUILD_FOR_UNIX",
1589        "SK_SUPPORT_GPU=0",
1590      ]
1591      defines -= [ "SK_GL" ]
1592    }
1593    cflags_cc = [ "-Wno-unknown-pragmas" ]
1594    libs = []
1595
1596    if (skia_enable_sksl) {
1597      deps += [ ":dehydrate_sksl" ]
1598      sources += skia_sksl_sources
1599    }
1600
1601    if (is_android) {
1602      deps += [ "${skia_third_party_dir}/expat" ]
1603      if (defined(ndk) && ndk != "") {
1604        deps += [ "${skia_third_party_dir}/cpu-features" ]
1605      }
1606      sources += [ "src/ports/SkDebug_android.cpp" ]
1607      libs += [
1608        "EGL",
1609        "GLESv2",
1610        "log",
1611      ]
1612    }
1613
1614    if (is_mac) {
1615      public += [ "include/ports/SkCFObject.h" ]
1616      sources += [
1617        "src/ports/SkDebug_stdio.cpp",
1618        "src/ports/SkImageEncoder_CG.cpp",
1619        "src/ports/SkImageGeneratorCG.cpp",
1620      ]
1621      frameworks = [
1622        "ApplicationServices.framework",
1623        "OpenGL.framework",
1624      ]
1625    }
1626
1627    if (is_ios) {
1628      public += [ "include/ports/SkCFObject.h" ]
1629      sources += [
1630        "src/ports/SkDebug_stdio.cpp",
1631        "src/ports/SkImageEncoder_CG.cpp",
1632        "src/ports/SkImageGeneratorCG.cpp",
1633      ]
1634      frameworks = [
1635        "CoreFoundation.framework",
1636        "ImageIO.framework",
1637        "MobileCoreServices.framework",
1638      ]
1639    }
1640
1641    if (is_win) {
1642      sources += [ "src/ports/SkOSFile_win.cpp" ]
1643    } else {
1644      sources += [ "src/ports/SkOSFile_posix.cpp" ]
1645    }
1646
1647    if (skia_include_multiframe_procs) {
1648      sources += [ "tools/SkSharingProc.cpp" ]
1649    }
1650  }
1651
1652  ohos_shared_library("skia_canvaskit") {
1653    part_name = "skia"
1654    innerapi_tags = [ "platformsdk" ]
1655    subsystem_name = "thirdparty"
1656
1657    include_dirs = [ "${skia_third_party_dir}/externals/libgifcodec" ]
1658    public_configs = [ ":skia_public" ]
1659    configs = skia_library_configs
1660    public_deps = [
1661      ":fontmgr_FontConfigInterface",
1662      ":fontmgr_android",
1663      ":fontmgr_custom_directory",
1664      ":fontmgr_custom_directory_factory",
1665      ":fontmgr_custom_embedded",
1666      ":fontmgr_fontconfig",
1667      ":fontmgr_mac_ct",
1668      ":fontmgr_ohos",
1669      ":fontmgr_win",
1670      ":fontmgr_win_gdi",
1671      ":pdf",
1672      ":skcms",
1673      ":xps",
1674    ]
1675
1676    if (is_arkui_x) {
1677      public_deps -= [ ":fontmgr_ohos" ]
1678    }
1679
1680    if (is_ios) {
1681      public_deps += [ ":gpu" ]
1682    } else {
1683      if (defined(ace_enable_gpu) && ace_enable_gpu) {
1684        public_deps += [ ":gpu" ]
1685      }
1686    }
1687    deps = [
1688      ":android_utils",
1689      ":arm64",
1690      ":armv7",
1691      ":avx",
1692      ":crc32",
1693      ":fontmgr_factory",
1694      ":gif",
1695      ":heif",
1696      ":hsw",
1697      ":jpeg_decode",
1698      ":jpeg_encode",
1699      ":none",
1700      ":png_decode",
1701      ":png_encode",
1702      ":skvm_jit",
1703      ":skx",
1704      ":sse2",
1705      ":sse41",
1706      ":sse42",
1707      ":ssse3",
1708      ":webp_decode",
1709      ":webp_encode",
1710      ":xml",
1711      "modules/skresources",
1712      "modules/skshaper",
1713      "modules/skunicode",
1714      "modules/svg",
1715    ]
1716
1717    public = skia_core_public
1718    public += skia_utils_public
1719    public += skia_effects_public
1720    public += skia_effects_imagefilter_public
1721
1722    sources = []
1723    sources += skia_core_sources
1724    sources += skia_utils_sources
1725    sources += skia_effects_sources
1726    sources += skia_effects_imagefilter_sources
1727    sources += [
1728      "src/android/SkAndroidFrameworkUtils.cpp",
1729      "src/android/SkAnimatedImage.cpp",
1730      "src/codec/SkAndroidCodec.cpp",
1731      "src/codec/SkAndroidCodecAdapter.cpp",
1732      "src/codec/SkBmpBaseCodec.cpp",
1733      "src/codec/SkBmpCodec.cpp",
1734      "src/codec/SkBmpMaskCodec.cpp",
1735      "src/codec/SkBmpRLECodec.cpp",
1736      "src/codec/SkBmpStandardCodec.cpp",
1737      "src/codec/SkCodec.cpp",
1738      "src/codec/SkCodecImageGenerator.cpp",
1739      "src/codec/SkColorTable.cpp",
1740      "src/codec/SkEncodedInfo.cpp",
1741      "src/codec/SkMaskSwizzler.cpp",
1742      "src/codec/SkMasks.cpp",
1743      "src/codec/SkParseEncodedOrigin.cpp",
1744      "src/codec/SkSampledCodec.cpp",
1745      "src/codec/SkSampler.cpp",
1746      "src/codec/SkStreamBuffer.cpp",
1747      "src/codec/SkSwizzler.cpp",
1748      "src/codec/SkWbmpCodec.cpp",
1749      "src/images/SkImageEncoder.cpp",
1750      "src/ports/SkDiscardableMemory_none.cpp",
1751      "src/ports/SkGlobalInitialization_default.cpp",
1752      "src/ports/SkImageGenerator_skia.cpp",
1753      "src/ports/SkMemory_malloc.cpp",
1754      "src/ports/SkOSFile_stdio.cpp",
1755      "src/sfnt/SkOTTable_name.cpp",
1756      "src/sfnt/SkOTUtils.cpp",
1757    ]
1758
1759    defines = skia_common_defines
1760    cflags = skia_common_cflags
1761    if (!defined(ace_enable_gpu) || !ace_enable_gpu) {
1762      defines += [
1763        "SK_BUILD_FOR_UNIX",
1764        "SK_SUPPORT_GPU=0",
1765      ]
1766      defines -= [ "SK_GL" ]
1767    }
1768    cflags_cc = [ "-Wno-unknown-pragmas" ]
1769    libs = []
1770
1771    if (skia_enable_sksl) {
1772      deps += [ ":dehydrate_sksl" ]
1773      sources += skia_sksl_sources
1774    }
1775
1776    if (is_win) {
1777      sources += [
1778        "src/ports/SkDebug_win.cpp",
1779        "src/ports/SkImageEncoder_WIC.cpp",
1780        "src/ports/SkImageGeneratorWIC.cpp",
1781        "src/ports/SkOSFile_win.cpp",
1782        "src/ports/SkOSLibrary_win.cpp",
1783      ]
1784      libs += [
1785        # "Ole32.lib",
1786        # "OleAut32.lib",
1787      ]
1788
1789      if (!skia_enable_winuwp) {
1790        libs += [
1791          # "FontSub.lib",
1792          # "User32.lib",
1793          # "Usp10.lib",
1794        ]
1795      }
1796      libs += [
1797        "kernel32",
1798        "gdi32",
1799        "fontsub",
1800        "ole32",
1801        "oleaut32",
1802        "psapi",
1803        "user32",
1804        "usp10",
1805        "uuid",
1806        "windowscodecs",
1807      ]
1808    } else {
1809      sources += [
1810        "src/ports/SkOSFile_posix.cpp",
1811        "src/ports/SkOSLibrary_posix.cpp",
1812      ]
1813      libs += [ "dl" ]
1814    }
1815    if (is_ohos) {
1816      sources += [ "//third_party/skia/src/ports/SkDebug_ohos.cpp" ]
1817      external_deps = [ "hilog:libhilog" ]
1818      if (defined(skia_ohos_debug) && skia_ohos_debug) {
1819        external_deps += [ "hitrace_native:hitrace_meter" ]
1820      }
1821    }
1822
1823    if (is_android) {
1824      deps += [ "${skia_third_party_dir}/expat" ]
1825      if (defined(ndk) && ndk != "") {
1826        deps += [ "${skia_third_party_dir}/cpu-features" ]
1827      }
1828      sources += [ "src/ports/SkDebug_android.cpp" ]
1829      libs += [
1830        "EGL",
1831        "GLESv2",
1832        "log",
1833      ]
1834    }
1835
1836    if (is_linux || target_cpu == "wasm") {
1837      sources += [ "src/ports/SkDebug_stdio.cpp" ]
1838      if (skia_use_egl) {
1839        libs += [ "GLESv2" ]
1840      }
1841    }
1842
1843    if (is_mac) {
1844      public += [ "include/ports/SkCFObject.h" ]
1845      sources += [
1846        "src/ports/SkDebug_stdio.cpp",
1847        "src/ports/SkImageEncoder_CG.cpp",
1848        "src/ports/SkImageGeneratorCG.cpp",
1849      ]
1850      frameworks = [
1851        "ApplicationServices.framework",
1852        "OpenGL.framework",
1853      ]
1854    }
1855
1856    if (is_ios) {
1857      public += [ "include/ports/SkCFObject.h" ]
1858      sources += [
1859        "src/ports/SkDebug_stdio.cpp",
1860        "src/ports/SkImageEncoder_CG.cpp",
1861        "src/ports/SkImageGeneratorCG.cpp",
1862      ]
1863      frameworks = [
1864        "CoreFoundation.framework",
1865        "ImageIO.framework",
1866        "MobileCoreServices.framework",
1867      ]
1868    }
1869
1870    if (is_fuchsia) {
1871      sources += [ "src/ports/SkDebug_stdio.cpp" ]
1872    }
1873
1874    #if (skia_enable_spirv_validation) {
1875    #  deps += [ "${skia_third_party_dir}/externals/spirv-tools:spvtools_val" ]
1876    #  defines += [ "SK_ENABLE_SPIRV_VALIDATION" ]
1877    #}
1878
1879    if (skia_include_multiframe_procs) {
1880      sources += [ "tools/SkSharingProc.cpp" ]
1881    }
1882
1883    if (defined(ddgr_ext_configs)) {
1884      defines += ddgr_ext_configs.ddgr_defines
1885    }
1886  }
1887
1888  foreach(item, ace_platforms) {
1889    make_skia_deps(item.name) {
1890      platform = item.name
1891      config = {
1892      }
1893
1894      if (defined(item.config)) {
1895        config = item.config
1896      }
1897    }
1898  }
1899}
1900
1901# DebugCanvas used in experimental/wasm-skp-debugger
1902if (target_cpu == "wasm") {
1903  skia_static_library("debugcanvas") {
1904    public_configs = [ ":skia_public" ]
1905
1906    sources = [
1907      "tools/SkSharingProc.cpp",
1908      "tools/UrlDataManager.cpp",
1909      "tools/debugger/DebugCanvas.cpp",
1910      "tools/debugger/DebugLayerManager.cpp",
1911      "tools/debugger/DrawCommand.cpp",
1912      "tools/debugger/JsonWriteBuffer.cpp",
1913    ]
1914  }
1915}
1916
1917skia_static_library("pathkit") {
1918  check_includes = false
1919  public_configs = [ ":skia_public" ]
1920  configs = skia_library_configs
1921
1922  deps = [
1923    ":arm64",
1924    ":armv7",
1925    ":avx",
1926    ":crc32",
1927    ":hsw",
1928    ":none",
1929    ":sse2",
1930    ":sse41",
1931    ":sse42",
1932    ":ssse3",
1933  ]
1934
1935  sources = []
1936  sources += skia_pathops_sources
1937  sources += skia_pathops_public
1938  sources += [
1939    "src/core/SkAnalyticEdge.cpp",
1940    "src/core/SkArenaAlloc.cpp",
1941    "src/core/SkContourMeasure.cpp",
1942    "src/core/SkCubicMap.cpp",
1943    "src/core/SkEdge.cpp",
1944    "src/core/SkEdgeBuilder.cpp",
1945    "src/core/SkEdgeClipper.cpp",
1946    "src/core/SkGeometry.cpp",
1947    "src/core/SkIDChangeListener.cpp",
1948    "src/core/SkLineClipper.cpp",
1949    "src/core/SkMalloc.cpp",
1950    "src/core/SkMallocPixelRef.cpp",
1951    "src/core/SkMath.cpp",
1952    "src/core/SkMatrix.cpp",
1953    "src/core/SkOpts.cpp",
1954    "src/core/SkPaint.cpp",
1955    "src/core/SkPaintPriv.cpp",
1956    "src/core/SkPath.cpp",
1957    "src/core/SkPathBuilder.cpp",
1958    "src/core/SkPathEffect.cpp",
1959    "src/core/SkPathMeasure.cpp",
1960    "src/core/SkPathRef.cpp",
1961    "src/core/SkPoint.cpp",
1962    "src/core/SkRRect.cpp",
1963    "src/core/SkReadBuffer.cpp",
1964    "src/core/SkRect.cpp",
1965    "src/core/SkSemaphore.cpp",
1966    "src/core/SkStream.cpp",
1967    "src/core/SkString.cpp",
1968    "src/core/SkStringUtils.cpp",
1969    "src/core/SkStroke.cpp",
1970    "src/core/SkStrokeRec.cpp",
1971    "src/core/SkStrokerPriv.cpp",
1972    "src/core/SkThreadID.cpp",
1973    "src/core/SkUtils.cpp",
1974    "src/effects/SkDashPathEffect.cpp",
1975    "src/effects/SkTrimPathEffect.cpp",
1976    "src/ports/SkDebug_stdio.cpp",
1977    "src/ports/SkMemory_malloc.cpp",
1978    "src/utils/SkDashPath.cpp",
1979    "src/utils/SkParse.cpp",
1980    "src/utils/SkParsePath.cpp",
1981    "src/utils/SkUTF.cpp",
1982  ]
1983}
1984
1985group("modules") {
1986  deps = [
1987    "modules/particles",
1988    "modules/skottie",
1989    "modules/skparagraph",
1990    "modules/skshaper",
1991    "modules/svg",
1992  ]
1993}
1994
1995group("experimental") {
1996  deps = [ "experimental/sktext" ]
1997}
1998
1999config("our_vulkan_headers") {
2000  include_dirs = [ "include/third_party/vulkan" ]
2001}
2002
2003# Targets guarded by skia_enable_tools may use //third_party freely.
2004if (skia_enable_tools) {
2005  skia_public_includes = [
2006    "client_utils/android",
2007    "include/android",
2008    "include/c",
2009    "include/codec",
2010    "include/config",
2011    "include/core",
2012    "include/docs",
2013    "include/effects",
2014    "include/encode",
2015    "include/gpu",
2016    "include/pathops",
2017    "include/ports",
2018    "include/svg",
2019    "include/utils",
2020    "include/utils/mac",
2021    "modules/particles/include",
2022    "modules/skottie/include",
2023    "modules/skparagraph/include",
2024    "modules/skshaper/include",
2025    "modules/svg/include",
2026  ]
2027
2028  # Used by gn_to_bp.py to list our public include dirs.
2029  skia_source_set("public") {
2030    configs = [ ":skia_public" ]
2031    include_dirs = skia_public_includes
2032  }
2033
2034  config("skia.h_config") {
2035    include_dirs = [ "$target_gen_dir" ]
2036  }
2037  action("skia.h") {
2038    public_configs = [ ":skia.h_config" ]
2039    skia_h = "$target_gen_dir/skia.h"
2040    script = "gn/find_headers.py"
2041
2042    args = [ rebase_path("${skia_root_dir}/bin/gn") ] + [ rebase_path("//") ] +
2043           [ rebase_path(skia_h, root_build_dir) ] +
2044           rebase_path(skia_public_includes)
2045    depfile = "$skia_h.deps"
2046    outputs = [ skia_h ]
2047  }
2048
2049  if (target_cpu == "x64") {
2050    skia_executable("fiddle") {
2051      check_includes = false
2052      libs = []
2053      sources = [
2054        "tools/fiddle/draw.cpp",
2055        "tools/fiddle/fiddle_main.cpp",
2056      ]
2057
2058      if (skia_use_egl) {
2059        sources += [ "tools/fiddle/egl_context.cpp" ]
2060      } else {
2061        sources += [ "tools/fiddle/null_context.cpp" ]
2062      }
2063      testonly = true
2064      deps = [
2065        ":flags",
2066        ":gpu_tool_utils",
2067        ":skia",
2068        ":skia.h",
2069        "modules/particles",
2070        "modules/skottie",
2071        "modules/skparagraph",
2072        "modules/skshaper",
2073        "modules/svg",
2074      ]
2075    }
2076  }
2077
2078  config("cpp14") {
2079    if (is_win && !is_mingw) {
2080      cflags_cc = [ "/std:c++14" ]
2081    } else {
2082      cflags_cc = [ "-std=c++14" ]
2083    }
2084  }
2085
2086  skia_source_set("public_headers_warnings_check") {
2087    sources = [ "tools/public_headers_warnings_check.cpp" ]
2088    configs = [
2089      ":our_vulkan_headers",
2090      ":cpp14",
2091    ]
2092    if (defined(skia_header_target_default_configs)) {
2093      configs += skia_header_target_default_configs
2094    }
2095    deps = [
2096      ":skia",
2097      ":skia.h",
2098      "modules/skottie",
2099      "modules/skshaper",
2100    ]
2101
2102    if (skia_use_dawn) {
2103      deps += [ "${skia_third_party_dir}/externals/dawn/src/dawn:dawn_headers" ]
2104    }
2105  }
2106
2107  template("test_lib") {
2108    config(target_name + "_config") {
2109      if (defined(invoker.public_defines)) {
2110        defines = invoker.public_defines
2111      }
2112    }
2113    skia_source_set(target_name) {
2114      forward_variables_from(invoker, "*", [])
2115      check_includes = false
2116      public_configs = [
2117        ":" + target_name + "_config",
2118        ":skia_private",
2119        ":skia_wno",
2120      ]
2121
2122      if (!defined(deps)) {
2123        deps = []
2124      }
2125      deps += [ ":skia" ]
2126      if (use_oh_skia) {
2127        deps -= [ ":skia" ]
2128        deps += [ ":skia_canvaskit" ]
2129      }
2130      testonly = true
2131    }
2132  }
2133
2134  template("test_app") {
2135    if (is_ios) {
2136      ios_app_bundle(target_name) {
2137        forward_variables_from(invoker,
2138                               "*",
2139                               [
2140                                 "output_name",
2141                                 "visibility",
2142                                 "is_shared_library",
2143                               ])
2144        testonly = true
2145        extra_configs = [ ":skia_private" ]
2146        launchscreen = "platform_tools/ios/app/LaunchScreen.storyboard"
2147        data_sources = [ "resources" ]
2148        if ("True" == exec_script("${skia_root_dir}/gn/checkdir.py",
2149                                  [ rebase_path("skps", root_build_dir) ],
2150                                  "trim string")) {
2151          data_sources += [ "skps" ]
2152        }
2153        if ("True" == exec_script("${skia_root_dir}/gn/checkdir.py",
2154                                  [ rebase_path("mskps", root_build_dir) ],
2155                                  "trim string")) {
2156          data_sources += [ "mskps" ]
2157        }
2158      }
2159    } else {
2160      # !is_ios
2161
2162      if (defined(invoker.is_shared_library) && invoker.is_shared_library) {
2163        skia_shared_library("lib" + target_name) {
2164          output_dir = root_build_dir
2165          forward_variables_from(invoker, "*", [ "is_shared_library" ])
2166          if (!defined(configs)) {
2167            configs = []
2168          }
2169          configs += [
2170            ":skia_private",
2171            ":skia_wno",
2172          ]
2173          testonly = true
2174        }
2175      } else {
2176        _executable = target_name
2177        skia_executable(_executable) {
2178          check_includes = false
2179          output_dir = root_build_dir
2180          forward_variables_from(invoker, "*", [ "is_shared_library" ])
2181          if (!defined(configs)) {
2182            configs = []
2183          }
2184          configs += [
2185            ":skia_private",
2186            ":skia_wno",
2187          ]
2188          testonly = true
2189        }
2190      }
2191      if (is_android && skia_android_serial != "" && defined(_executable)) {
2192        action("push_" + target_name) {
2193          output_dir = root_build_dir
2194          script = "gn/push_to_android.py"
2195          deps = [ ":" + _executable ]
2196          _stamp = "$target_gen_dir/$_executable.pushed_$skia_android_serial"
2197          outputs = [ _stamp ]
2198          args = [
2199            rebase_path("$root_build_dir/$_executable"),
2200            skia_android_serial,
2201            rebase_path(_stamp),
2202          ]
2203          testonly = true
2204        }
2205      }
2206    }
2207  }
2208
2209  test_lib("gpu_tool_utils") {
2210    public_defines = []
2211
2212    # Bots and even devs may not have Vulkan headers, so put
2213    # include/third_party/vulkan on our path so they're always available.
2214    all_dependent_configs = [ ":our_vulkan_headers" ]
2215
2216    defines = []
2217    if (skia_enable_discrete_gpu) {
2218      defines += [ "SK_ENABLE_DISCRETE_GPU" ]
2219    }
2220
2221    deps = []
2222    public_deps = []
2223    sources = [
2224      "tools/gpu/BackendSurfaceFactory.cpp",
2225      "tools/gpu/BackendSurfaceFactory.h",
2226      "tools/gpu/BackendTextureImageFactory.cpp",
2227      "tools/gpu/BackendTextureImageFactory.h",
2228      "tools/gpu/FlushFinishTracker.cpp",
2229      "tools/gpu/FlushFinishTracker.h",
2230      "tools/gpu/GrContextFactory.cpp",
2231      "tools/gpu/GrTest.cpp",
2232      "tools/gpu/ManagedBackendTexture.cpp",
2233      "tools/gpu/ManagedBackendTexture.h",
2234      "tools/gpu/MemoryCache.cpp",
2235      "tools/gpu/MemoryCache.h",
2236      "tools/gpu/ProxyUtils.cpp",
2237      "tools/gpu/TestContext.cpp",
2238      "tools/gpu/TestOps.cpp",
2239      "tools/gpu/TestOps.h",
2240      "tools/gpu/YUVUtils.cpp",
2241      "tools/gpu/YUVUtils.h",
2242      "tools/gpu/gl/GLTestContext.cpp",  # See comment below about
2243                                         # GrContextFactory workaround.
2244      "tools/gpu/mock/MockTestContext.cpp",
2245    ]
2246
2247    libs = []
2248    frameworks = []
2249
2250    if (skia_use_gl) {
2251      sources +=
2252          [ "tools/gpu/gl/command_buffer/GLTestContext_command_buffer.cpp" ]
2253      if (is_ios) {
2254        sources += [ "tools/gpu/gl/iOS/CreatePlatformGLTestContext_iOS.mm" ]
2255        frameworks += [ "OpenGLES.framework" ]
2256      } else if (is_mac) {
2257        sources += [ "tools/gpu/gl/mac/CreatePlatformGLTestContext_mac.cpp" ]
2258      }
2259      if (skia_use_angle) {
2260        deps += [ "${skia_third_party_dir}/angle2" ]
2261        sources += [ "tools/gpu/gl/angle/GLTestContext_angle.cpp" ]
2262      }
2263    }
2264
2265    # We need the GLTestContext on Vulkan-only builds for the persistent GL context workaround in
2266    # in GrContextFactory. This only matters for OSes that can run Vulkan.
2267    if ((skia_use_gl || skia_use_vulkan) && target_cpu != "wasm") {
2268      if (is_android || skia_use_egl || is_ohos) {
2269        sources += [ "tools/gpu/gl/egl/CreatePlatformGLTestContext_egl.cpp" ]
2270
2271        if (is_ohos) {
2272          include_dirs = [ "//third_party/EGL/api" ]
2273          deps += [ "//foundation/graphic/graphic_2d:libgl" ]
2274        } else {
2275          libs += [ "EGL" ]
2276        }
2277      } else if (is_linux) {
2278        sources += [ "tools/gpu/gl/glx/CreatePlatformGLTestContext_glx.cpp" ]
2279        libs += [
2280          "GLU",
2281          "GL",
2282          "X11",
2283        ]
2284      } else if (is_win) {
2285        sources += [ "tools/gpu/gl/win/CreatePlatformGLTestContext_win.cpp" ]
2286
2287        # libs += [ "Gdi32.lib" ]
2288        libs += [ "gdi32" ]
2289        if (target_cpu != "arm64") {
2290          # libs += [ "OpenGL32.lib" ]
2291          libs += [ "opengl32" ]
2292        }
2293      }
2294    }
2295
2296    if (skia_use_vulkan) {
2297      sources += [ "tools/gpu/vk/VkTestContext.h" ]
2298      sources += [ "tools/gpu/vk/VkTestContext.cpp" ]
2299      sources += [ "tools/gpu/vk/VkTestHelper.h" ]
2300      sources += [ "tools/gpu/vk/VkTestHelper.cpp" ]
2301      sources += [ "tools/gpu/vk/VkTestUtils.h" ]
2302      sources += [ "tools/gpu/vk/VkTestUtils.cpp" ]
2303      sources += [ "tools/gpu/vk/VkYcbcrSamplerHelper.h" ]
2304      sources += [ "tools/gpu/vk/VkYcbcrSamplerHelper.cpp" ]
2305    }
2306    if (skia_use_metal) {
2307      sources += [ "tools/gpu/mtl/MtlTestContext.mm" ]
2308    }
2309    if (skia_use_direct3d) {
2310      sources += [ "tools/gpu/d3d/D3DTestContext.cpp" ]
2311      sources += [ "tools/gpu/d3d/D3DTestUtils.cpp" ]
2312    }
2313    if (skia_use_dawn) {
2314      public_deps +=
2315          [ "${skia_third_party_dir}/externals/dawn/src/dawn:dawn_headers" ]
2316      sources += [ "tools/gpu/dawn/DawnTestContext.cpp" ]
2317      if (is_clang) {
2318        cflags_cc = [ "-Wno-microsoft-cast" ]
2319      }
2320    }
2321    if (!skia_enable_skgpu_v1) {
2322      sources -= [ "tools/gpu/GrTest.cpp" ]
2323      sources -= [ "tools/gpu/TestOps.cpp" ]
2324      sources -= [ "tools/gpu/TestOps.h" ]
2325    }
2326    if (skia_enable_graphite) {
2327      sources += [ "tools/graphite/ContextFactory.h" ]
2328      sources += [ "tools/graphite/ContextFactory.cpp" ]
2329      sources += [ "tools/graphite/GraphiteTestContext.h" ]
2330      sources += [ "tools/graphite/GraphiteTestContext.cpp" ]
2331      if (skia_use_metal) {
2332        sources += [ "tools/graphite/mtl/GraphiteMtlTestContext.h" ]
2333        sources += [ "tools/graphite/mtl/MtlTestContext.mm" ]
2334      }
2335    }
2336
2337    if (is_fuchsia && using_fuchsia_sdk) {
2338      libs +=
2339          [ "${fuchsia_sdk_path}/arch/${target_cpu}/sysroot/lib/libzircon.so" ]
2340    }
2341  }  # test_lib("gpu_tool_utils")
2342
2343  test_lib("flags") {
2344    sources = [ "tools/flags/CommandLineFlags.cpp" ]
2345  }
2346
2347  test_lib("common_flags_config") {
2348    sources = [ "tools/flags/CommonFlagsConfig.cpp" ]
2349    deps = [ ":flags" ]
2350    public_deps = [ ":gpu_tool_utils" ]
2351  }
2352  test_lib("common_flags_gpu") {
2353    sources = [ "tools/flags/CommonFlagsGpu.cpp" ]
2354    deps = [ ":flags" ]
2355    public_deps = [ ":gpu_tool_utils" ]
2356  }
2357  test_lib("common_flags_images") {
2358    sources = [ "tools/flags/CommonFlagsImages.cpp" ]
2359    deps = [ ":flags" ]
2360  }
2361  test_lib("common_flags_fontmgr") {
2362    sources = [ "tools/flags/CommonFlagsFontMgr.cpp" ]
2363    deps = [ ":flags" ]
2364  }
2365  test_lib("common_flags_aa") {
2366    sources = [ "tools/flags/CommonFlagsAA.cpp" ]
2367    deps = [ ":flags" ]
2368  }
2369
2370  test_lib("trace") {
2371    deps = [ ":flags" ]
2372    sources = [
2373      "tools/trace/ChromeTracingTracer.cpp",
2374      "tools/trace/ChromeTracingTracer.h",
2375      "tools/trace/EventTracingPriv.cpp",
2376      "tools/trace/EventTracingPriv.h",
2377      "tools/trace/SkDebugfTracer.cpp",
2378      "tools/trace/SkDebugfTracer.h",
2379    ]
2380  }
2381
2382  test_lib("tool_utils") {
2383    sources = [
2384      "tools/AndroidSkDebugToStdOut.cpp",
2385      "tools/AutoreleasePool.h",
2386      "tools/DDLPromiseImageHelper.cpp",
2387      "tools/DDLPromiseImageHelper.h",
2388      "tools/DDLTileHelper.cpp",
2389      "tools/DDLTileHelper.h",
2390      "tools/LsanSuppressions.cpp",
2391      "tools/MSKPPlayer.cpp",
2392      "tools/MSKPPlayer.h",
2393      "tools/ProcStats.cpp",
2394      "tools/ProcStats.h",
2395      "tools/Resources.cpp",
2396      "tools/Resources.h",
2397      "tools/RuntimeBlendUtils.cpp",
2398      "tools/RuntimeBlendUtils.h",
2399      "tools/SkMetaData.cpp",
2400      "tools/SkMetaData.h",
2401      "tools/SkSharingProc.cpp",
2402      "tools/SkSharingProc.h",
2403      "tools/Stats.h",
2404      "tools/ToolUtils.cpp",
2405      "tools/ToolUtils.h",
2406      "tools/UrlDataManager.cpp",
2407      "tools/UrlDataManager.h",
2408      "tools/debugger/DebugCanvas.cpp",
2409      "tools/debugger/DebugCanvas.h",
2410      "tools/debugger/DebugLayerManager.cpp",
2411      "tools/debugger/DebugLayerManager.h",
2412      "tools/debugger/DrawCommand.cpp",
2413      "tools/debugger/DrawCommand.h",
2414      "tools/debugger/JsonWriteBuffer.cpp",
2415      "tools/debugger/JsonWriteBuffer.h",
2416      "tools/fonts/RandomScalerContext.cpp",
2417      "tools/fonts/RandomScalerContext.h",
2418      "tools/fonts/TestEmptyTypeface.h",
2419      "tools/fonts/TestFontMgr.cpp",
2420      "tools/fonts/TestFontMgr.h",
2421      "tools/fonts/TestSVGTypeface.cpp",
2422      "tools/fonts/TestSVGTypeface.h",
2423      "tools/fonts/TestTypeface.cpp",
2424      "tools/fonts/TestTypeface.h",
2425      "tools/fonts/ToolUtilsFont.cpp",
2426      "tools/random_parse_path.cpp",
2427      "tools/random_parse_path.h",
2428      "tools/timer/TimeUtils.h",
2429      "tools/timer/Timer.cpp",
2430      "tools/timer/Timer.h",
2431    ]
2432    if (target_cpu != "wasm") {
2433      sources += [ "tools/CrashHandler.cpp" ]
2434    }
2435    libs = []
2436    frameworks = []
2437    if (is_ios) {
2438      sources += [ "tools/ios_utils.m" ]
2439      sources += [ "tools/ios_utils.h" ]
2440      if (skia_use_metal) {
2441        sources += [ "tools/AutoreleasePool.mm" ]
2442      }
2443      frameworks += [ "Foundation.framework" ]
2444    } else if (is_mac) {
2445      if (skia_use_metal) {
2446        sources += [ "tools/AutoreleasePool.mm" ]
2447        frameworks += [ "Foundation.framework" ]
2448      }
2449    } else if (is_win && !is_mingw && !skia_enable_winuwp) {
2450      libs += [ "DbgHelp.lib" ]
2451    }
2452
2453    defines = []
2454    if (skia_tools_require_resources) {
2455      defines += [ "SK_TOOLS_REQUIRE_RESOURCES" ]
2456    }
2457    deps = [
2458      ":flags",
2459      "modules/svg",
2460    ]
2461    public_deps = [ ":gpu_tool_utils" ]
2462  }
2463
2464  test_lib("etc1") {
2465    sources = [ "third_party/etc1/etc1.cpp" ]
2466  }
2467
2468  import("gn/gm.gni")
2469  test_lib("gm") {
2470    sources = gm_sources
2471    if (skia_use_gl) {
2472      sources += gl_gm_sources
2473    }
2474    if (!skia_enable_skgpu_v1) {
2475      sources -= skgpu_v1_gm_sources
2476    }
2477    deps = [
2478      ":etc1",
2479      ":flags",
2480      ":skia",
2481      ":tool_utils",
2482      "modules/particles",
2483      "modules/skottie",
2484      "modules/skottie:gm",
2485      "modules/skparagraph",
2486      "modules/skparagraph:gm",
2487      "modules/skshaper",
2488    ]
2489    if (is_ohos) {
2490      deps += [
2491        "//base/hiviewdfx/hitrace/interfaces/native/innerkits:hitrace_meter",
2492      ]
2493    }
2494    if (use_oh_skia) {
2495      deps -= [
2496        ":skia",
2497        "modules/skshaper",
2498      ]
2499      deps += [ ":skia_canvaskit" ]
2500    }
2501    if (is_skia_dev_build) {
2502      sources += [ "gm/fiddle.cpp" ]
2503      deps += [ ":skia.h" ]
2504    }
2505    public_deps = [ ":gpu_tool_utils" ]
2506
2507    if (skia_use_ffmpeg) {
2508      deps += [ "experimental/ffmpeg:video_decoder" ]
2509      sources += [ "gm/video_decoder.cpp" ]
2510    }
2511  }
2512
2513  test_lib("test") {
2514    sources = [
2515      "tests/Test.cpp",
2516      "tests/Test.h",
2517      "tests/TestUtils.cpp",
2518      "tests/TestUtils.h",
2519    ]
2520    deps = [
2521      ":flags",
2522      ":skia",
2523      ":tool_utils",
2524    ]
2525    if (use_oh_skia) {
2526      deps -= [ ":skia" ]
2527      deps += [ ":skia_canvaskit" ]
2528    }
2529    public_deps = [
2530      ":gpu_tool_utils",  # Test.h #includes headers from this target.
2531    ]
2532  }
2533
2534  import("gn/tests.gni")
2535  test_lib("tests") {
2536    sources = tests_sources + pathops_tests_sources
2537    frameworks = []
2538    if (skia_use_metal) {
2539      sources += metal_tests_sources
2540      cflags_objcc = [ "-fobjc-arc" ]
2541      frameworks += [ "MetalKit.framework" ]
2542    }
2543    if (skia_use_gl) {
2544      sources += gl_tests_sources
2545    }
2546    if (skia_enable_graphite) {
2547      sources += graphite_tests_sources
2548      if (skia_use_metal) {
2549        sources += graphite_metal_tests_sources
2550      }
2551    }
2552    if (!skia_enable_skgpu_v1) {
2553      sources -= skgpu_v1_tests_sources
2554    }
2555    deps = [
2556      ":flags",
2557      ":fontmgr_android_tests",
2558      ":fontmgr_fontconfig_tests",
2559      ":fontmgr_mac_ct_tests",
2560      ":skia",
2561      ":test",
2562      ":tool_utils",
2563      "${skia_third_party_dir}/libpng",
2564      "${skia_third_party_dir}/libwebp",
2565      "${skia_third_party_dir}/zlib",
2566      "experimental/skrive:tests",
2567      "experimental/sktext:tests",
2568      "modules/skottie:tests",
2569      "modules/skparagraph:tests",
2570      "modules/sksg:tests",
2571      "modules/skshaper",
2572      "modules/svg:tests",
2573    ]
2574    if (use_oh_skia) {
2575      deps -= [
2576        ":skia",
2577        "modules/skshaper",
2578      ]
2579      deps += [ ":skia_canvaskit" ]
2580    }
2581  }
2582
2583  import("gn/bench.gni")
2584  test_lib("bench") {
2585    sources = bench_sources
2586    if (skia_enable_graphite) {
2587      sources += graphite_bench_sources
2588    }
2589    if (!skia_enable_skgpu_v1) {
2590      sources -= skgpu_v1_bench_sources
2591    }
2592    deps = [
2593      ":flags",
2594      ":gm",
2595      ":gpu_tool_utils",
2596      ":skia",
2597      ":tool_utils",
2598      "modules/skparagraph:bench",
2599      "modules/skshaper",
2600    ]
2601  }
2602
2603  test_lib("experimental_xform") {
2604    sources = [
2605      "experimental/xform/SkShape.cpp",
2606      "experimental/xform/SkXform.cpp",
2607      "experimental/xform/XContext.cpp",
2608    ]
2609    deps = [ ":skia" ]
2610  }
2611
2612  if (is_linux || is_mac) {
2613    if (skia_enable_skottie) {
2614      test_app("skottie_tool") {
2615        deps = [ "modules/skottie:tool" ]
2616      }
2617    }
2618    test_app("svg_tool") {
2619      deps = [ "modules/svg:tool" ]
2620    }
2621  }
2622
2623  test_app("make_skqp_model") {
2624    sources = [ "tools/skqp/make_skqp_model.cpp" ]
2625    deps = [ ":skia" ]
2626  }
2627
2628  import("gn/samples.gni")
2629  test_lib("samples") {
2630    sources = samples_sources
2631    if (!skia_enable_skgpu_v1) {
2632      sources -= skgpu_v1_samples_sources
2633    }
2634    public_deps = [ ":tool_utils" ]
2635    deps = [
2636      ":flags",
2637      ":gpu_tool_utils",
2638      ":xml",
2639      "${skia_third_party_dir}/imgui",
2640      "experimental/sktext:samples",
2641      "modules/audioplayer",
2642      "modules/skparagraph:samples",
2643      "modules/skshaper",
2644      "modules/svg",
2645    ]
2646  }
2647  test_lib("hash_and_encode") {
2648    sources = [
2649      "tools/HashAndEncode.cpp",
2650      "tools/HashAndEncode.h",
2651    ]
2652    deps = [
2653      ":flags",
2654      ":skia",
2655      "${skia_third_party_dir}/libpng",
2656    ]
2657    if (use_oh_skia) {
2658      deps -= [ ":skia" ]
2659      deps += [ ":skia_canvaskit" ]
2660    }
2661  }
2662  if (target_cpu != "wasm") {
2663    test_app("convert-to-nia") {
2664      sources = [ "tools/convert-to-nia.cpp" ]
2665      deps = [ ":skia" ]
2666    }
2667    test_app("imgcvt") {
2668      sources = [ "tools/imgcvt.cpp" ]
2669      deps = [
2670        ":skcms",
2671        ":skia",
2672      ]
2673    }
2674    test_app("fm") {
2675      sources = [
2676        "dm/DMGpuTestProcs.cpp",  # blech
2677        "tools/fm/fm.cpp",
2678      ]
2679      deps = [
2680        ":common_flags_aa",
2681        ":common_flags_fontmgr",
2682        ":common_flags_gpu",
2683        ":flags",
2684        ":gm",
2685        ":gpu_tool_utils",
2686        ":hash_and_encode",
2687        ":skia",
2688        ":tests",
2689        ":tool_utils",
2690        ":trace",
2691        "modules/skottie",
2692        "modules/skottie:utils",
2693        "modules/svg",
2694      ]
2695    }
2696    test_app("dm") {
2697      sources = [
2698        "dm/DM.cpp",
2699        "dm/DMGpuTestProcs.cpp",
2700        "dm/DMJsonWriter.cpp",
2701        "dm/DMJsonWriter.h",
2702        "dm/DMSrcSink.cpp",
2703        "dm/DMSrcSink.h",
2704      ]
2705      deps = [
2706        ":common_flags_aa",
2707        ":common_flags_config",
2708        ":common_flags_fontmgr",
2709        ":common_flags_gpu",
2710        ":common_flags_images",
2711        ":flags",
2712        ":gm",
2713        ":gpu_tool_utils",
2714        ":hash_and_encode",
2715        ":skia",
2716        ":tests",
2717        ":tool_utils",
2718        ":trace",
2719        "experimental/skrive",
2720        "modules/skottie",
2721        "modules/skottie:utils",
2722        "modules/svg",
2723      ]
2724      if (use_oh_skia) {
2725        deps -= [
2726          ":skia",
2727          "modules/svg",
2728        ]
2729        deps += [ ":skia_canvaskit" ]
2730      }
2731      ldflags = [
2732        "--stdlib=libc++",
2733        "-lc++",
2734        "-lc++abi",
2735      ]
2736    }
2737    test_app("sorttoy") {
2738      sources = [
2739        "experimental/sorttoy/Cmds.cpp",
2740        "experimental/sorttoy/Cmds.h",
2741        "experimental/sorttoy/Fake.cpp",
2742        "experimental/sorttoy/Fake.h",
2743        "experimental/sorttoy/SortKey.h",
2744        "experimental/sorttoy/sorttoy.cpp",
2745        "experimental/sorttoy/sorttypes.h",
2746      ]
2747      deps = [
2748        ":flags",
2749        ":skia",
2750        ":tool_utils",
2751      ]
2752    }
2753
2754    # optional separate library to dlopen when running CanvasStateTests.
2755    skia_shared_library("canvas_state_lib") {
2756      sources = [
2757        "tests/CanvasStateHelpers.cpp",
2758        "tests/CanvasStateHelpers.h",
2759      ]
2760      deps = [ ":skia" ]
2761    }
2762  }
2763
2764  if (!is_win) {
2765    test_app("remote_demo") {
2766      sources = [ "tools/remote_demo.cpp" ]
2767      deps = [ ":skia" ]
2768    }
2769  }
2770
2771  if (!is_win) {
2772    test_app("blob_cache_sim") {
2773      sources = [ "tools/blob_cache_sim.cpp" ]
2774      deps = [ ":skia" ]
2775    }
2776  }
2777
2778  test_app("nanobench") {
2779    sources = [ "bench/nanobench.cpp" ]
2780    deps = [
2781      ":bench",
2782      ":common_flags_aa",
2783      ":common_flags_config",
2784      ":common_flags_gpu",
2785      ":common_flags_images",
2786      ":flags",
2787      ":gm",
2788      ":gpu_tool_utils",
2789      ":skia",
2790      ":tool_utils",
2791      ":trace",
2792      "modules/skparagraph",
2793      "modules/skshaper",
2794      "modules/svg",
2795    ]
2796  }
2797
2798  test_app("skpinfo") {
2799    sources = [ "tools/skpinfo.cpp" ]
2800    configs = [ ":our_vulkan_headers" ]
2801    deps = [
2802      ":flags",
2803      ":skia",
2804    ]
2805  }
2806
2807  if (skia_use_ffmpeg) {
2808    test_app("skottie2movie") {
2809      sources = [ "tools/skottie2movie.cpp" ]
2810      deps = [
2811        ":flags",
2812        ":gpu_tool_utils",
2813        ":skia",
2814        "experimental/ffmpeg:video_encoder",
2815        "modules/skottie",
2816        "modules/skottie:utils",
2817      ]
2818    }
2819  }
2820
2821  test_app("skpbench") {
2822    sources = [
2823      "bench/BigPath.cpp",
2824      "tools/skpbench/skpbench.cpp",
2825    ]
2826    deps = [
2827      ":common_flags_config",
2828      ":common_flags_gpu",
2829      ":flags",
2830      ":gpu_tool_utils",
2831      ":skia",
2832      ":tool_utils",
2833    ]
2834  }
2835
2836  test_app("sktexttopdf") {
2837    sources = [ "tools/using_skia_and_harfbuzz.cpp" ]
2838    deps = [
2839      ":skia",
2840      "modules/skshaper",
2841    ]
2842  }
2843
2844  test_app("create_test_font") {
2845    sources = [ "tools/fonts/create_test_font.cpp" ]
2846    deps = [ ":skia" ]
2847    assert_no_deps = [
2848      # tool_utils requires the output of this app.
2849      ":tool_utils",
2850    ]
2851  }
2852
2853  if (skia_use_expat) {
2854    test_app("create_test_font_color") {
2855      sources = [ "tools/fonts/create_test_font_color.cpp" ]
2856      deps = [
2857        ":flags",
2858        ":skia",
2859        ":tool_utils",
2860      ]
2861    }
2862  }
2863
2864  test_app("get_images_from_skps") {
2865    sources = [ "tools/get_images_from_skps.cpp" ]
2866    deps = [
2867      ":flags",
2868      ":skia",
2869    ]
2870  }
2871
2872  if (!is_ios && target_cpu != "wasm" && !(is_win && target_cpu == "arm64")) {
2873    test_app("skiaserve") {
2874      sources = [
2875        "tools/skiaserve/Request.cpp",
2876        "tools/skiaserve/Response.cpp",
2877        "tools/skiaserve/skiaserve.cpp",
2878        "tools/skiaserve/urlhandlers/BreakHandler.cpp",
2879        "tools/skiaserve/urlhandlers/ClipAlphaHandler.cpp",
2880        "tools/skiaserve/urlhandlers/CmdHandler.cpp",
2881        "tools/skiaserve/urlhandlers/ColorModeHandler.cpp",
2882        "tools/skiaserve/urlhandlers/DataHandler.cpp",
2883        "tools/skiaserve/urlhandlers/DownloadHandler.cpp",
2884        "tools/skiaserve/urlhandlers/EnableGPUHandler.cpp",
2885        "tools/skiaserve/urlhandlers/ImgHandler.cpp",
2886        "tools/skiaserve/urlhandlers/InfoHandler.cpp",
2887        "tools/skiaserve/urlhandlers/OpBoundsHandler.cpp",
2888        "tools/skiaserve/urlhandlers/OpsHandler.cpp",
2889        "tools/skiaserve/urlhandlers/OverdrawHandler.cpp",
2890        "tools/skiaserve/urlhandlers/PostHandler.cpp",
2891        "tools/skiaserve/urlhandlers/QuitHandler.cpp",
2892        "tools/skiaserve/urlhandlers/RootHandler.cpp",
2893      ]
2894      deps = [
2895        ":flags",
2896        ":gpu_tool_utils",
2897        ":skia",
2898        ":tool_utils",
2899        "${skia_third_party_dir}/libmicrohttpd",
2900      ]
2901    }
2902  }
2903
2904  test_app("fuzz") {
2905    sources = [
2906      "fuzz/Fuzz.cpp",
2907      "fuzz/Fuzz.h",
2908      "fuzz/FuzzCanvas.cpp",
2909      "fuzz/FuzzCommon.cpp",
2910      "fuzz/FuzzCommon.h",
2911      "fuzz/FuzzCreateDDL.cpp",
2912      "fuzz/FuzzDDLThreading.cpp",
2913      "fuzz/FuzzDrawFunctions.cpp",
2914      "fuzz/FuzzEncoders.cpp",
2915      "fuzz/FuzzGradients.cpp",
2916      "fuzz/FuzzMain.cpp",
2917      "fuzz/FuzzParsePath.cpp",
2918      "fuzz/FuzzPathMeasure.cpp",
2919      "fuzz/FuzzPathop.cpp",
2920      "fuzz/FuzzPolyUtils.cpp",
2921      "fuzz/FuzzRegionOp.cpp",
2922      "fuzz/FuzzSkParagraph.cpp",
2923      "fuzz/FuzzTriangulation.cpp",
2924      "fuzz/oss_fuzz/FuzzAndroidCodec.cpp",
2925      "fuzz/oss_fuzz/FuzzAnimatedImage.cpp",
2926      "fuzz/oss_fuzz/FuzzImage.cpp",
2927      "fuzz/oss_fuzz/FuzzImageFilterDeserialize.cpp",
2928      "fuzz/oss_fuzz/FuzzIncrementalImage.cpp",
2929      "fuzz/oss_fuzz/FuzzJSON.cpp",
2930      "fuzz/oss_fuzz/FuzzPathDeserialize.cpp",
2931      "fuzz/oss_fuzz/FuzzRegionDeserialize.cpp",
2932      "fuzz/oss_fuzz/FuzzRegionSetPath.cpp",
2933      "fuzz/oss_fuzz/FuzzSKP.cpp",
2934      "fuzz/oss_fuzz/FuzzSKSL2GLSL.cpp",
2935      "fuzz/oss_fuzz/FuzzSKSL2Metal.cpp",
2936      "fuzz/oss_fuzz/FuzzSKSL2Pipeline.cpp",
2937      "fuzz/oss_fuzz/FuzzSKSL2SPIRV.cpp",
2938      "fuzz/oss_fuzz/FuzzSVG.cpp",
2939      "fuzz/oss_fuzz/FuzzSkDescriptorDeserialize.cpp",
2940      "fuzz/oss_fuzz/FuzzSkParagraph.cpp",
2941      "fuzz/oss_fuzz/FuzzSkRuntimeEffect.cpp",
2942      "fuzz/oss_fuzz/FuzzTextBlobDeserialize.cpp",
2943      "tools/UrlDataManager.cpp",
2944      "tools/debugger/DebugCanvas.cpp",
2945      "tools/debugger/DebugLayerManager.cpp",
2946      "tools/debugger/DrawCommand.cpp",
2947      "tools/debugger/JsonWriteBuffer.cpp",
2948    ]
2949    deps = [
2950      ":flags",
2951      ":gpu_tool_utils",
2952      ":skia",
2953      "modules/skottie:fuzz",
2954      "modules/skparagraph",
2955    ]
2956  }
2957
2958  test_app("pathops_unittest") {
2959    sources = pathops_tests_sources + [
2960                rebase_path("tests/skia_test.cpp"),
2961                rebase_path("tests/Test.cpp"),
2962              ]
2963    deps = [
2964      ":flags",
2965      ":gpu_tool_utils",
2966      ":skia",
2967      ":tool_utils",
2968    ]
2969  }
2970
2971  test_app("dump_record") {
2972    sources = [ "tools/dump_record.cpp" ]
2973    deps = [
2974      ":flags",
2975      ":skia",
2976    ]
2977  }
2978
2979  test_app("skdiff") {
2980    sources = [
2981      "tools/skdiff/skdiff.cpp",
2982      "tools/skdiff/skdiff_html.cpp",
2983      "tools/skdiff/skdiff_main.cpp",
2984      "tools/skdiff/skdiff_utils.cpp",
2985    ]
2986    deps = [
2987      ":skia",
2988      ":tool_utils",
2989    ]
2990  }
2991
2992  test_app("skp_parser") {
2993    sources = [ "tools/skp_parser.cpp" ]
2994    deps = [
2995      ":skia",
2996      ":tool_utils",
2997    ]
2998  }
2999
3000  if (!is_win) {
3001    source_set("skqp_lib") {  # Not a skia_source_set
3002      check_includes = false
3003      testonly = true
3004      public_configs = [ ":skia_private" ]
3005      defines =
3006          [ "SK_SKQP_GLOBAL_ERROR_TOLERANCE=$skia_skqp_global_error_tolerance" ]
3007      sources = [
3008        "dm/DMGpuTestProcs.cpp",
3009        "tools/skqp/src/skqp.cpp",
3010        "tools/skqp/src/skqp_model.cpp",
3011      ]
3012      deps = [
3013        ":gm",
3014        ":skia",
3015        ":tests",
3016        ":tool_utils",
3017      ]
3018    }
3019    test_app("skqp") {
3020      sources = [ "tools/skqp/src/skqp_main.cpp" ]
3021      include_dirs = [ "${skia_root_dir}/" ]
3022      lib_dirs = []
3023      deps = [ ":skqp_lib" ]
3024    }
3025    test_app("jitter_gms") {
3026      sources = [ "tools/skqp/jitter_gms.cpp" ]
3027      deps = [
3028        ":gm",
3029        ":skia",
3030        ":skqp_lib",
3031      ]
3032    }
3033  }
3034  if (is_fuchsia) {
3035    # Build a package repository for skqp on Fuchsia.
3036    group("skqp_repo") {
3037      testonly = true
3038      deps = [ "${skia_root_dir}/build/fuchsia/skqp:skqp_repo" ]
3039    }
3040  }
3041  if (is_android) {
3042    shared_library("libskqp_app") {  # Not a skia_shared_library
3043      configs += [ ":skia_private" ]
3044      testonly = true
3045      sources = [ "tools/skqp/src/jni_skqp.cpp" ]
3046      deps = [
3047        ":skia",
3048        ":skqp_lib",
3049        ":tool_utils",
3050      ]
3051      libs = [ "android" ]
3052    }
3053  }
3054  if (is_android && skia_use_gl) {
3055    test_app("skottie_android") {
3056      is_shared_library = true
3057
3058      sources = [ "platform_tools/android/apps/skottie/skottielib/src/main/cpp/native-lib.cpp" ]
3059      libs = []
3060
3061      deps = [
3062        ":skia",
3063        "modules/skottie",
3064      ]
3065    }
3066
3067    test_app("androidkit") {
3068      is_shared_library = true
3069
3070      sources = [
3071        "modules/androidkit/src/AndroidKit.cpp",
3072        "modules/androidkit/src/Canvas.cpp",
3073        "modules/androidkit/src/ColorFilters.cpp",
3074        "modules/androidkit/src/Font.cpp",
3075        "modules/androidkit/src/FontChainAdapter.cpp",
3076        "modules/androidkit/src/Gradients.cpp",
3077        "modules/androidkit/src/Image.cpp",
3078        "modules/androidkit/src/ImageFilter.cpp",
3079        "modules/androidkit/src/Matrix.cpp",
3080        "modules/androidkit/src/Paint.cpp",
3081        "modules/androidkit/src/Path.cpp",
3082        "modules/androidkit/src/PathBuilder.cpp",
3083        "modules/androidkit/src/RuntimeShaderBuilder.cpp",
3084        "modules/androidkit/src/Shader.cpp",
3085        "modules/androidkit/src/SkottieAnimation.cpp",
3086        "modules/androidkit/src/Surface.cpp",
3087        "modules/androidkit/src/Surface.h",
3088        "modules/androidkit/src/SurfaceThread.cpp",
3089        "modules/androidkit/src/SurfaceThread.h",
3090        "modules/androidkit/src/Text.cpp",
3091        "modules/androidkit/src/Utils.cpp",
3092      ]
3093      libs = [
3094        "android",
3095        "jnigraphics",
3096      ]
3097
3098      deps = [
3099        ":sk_app",
3100        ":skia",
3101        "experimental/sktext:sktext",
3102        "modules/skottie:skottie",
3103      ]
3104    }
3105  }
3106
3107  test_app("list_gms") {
3108    sources = [ "tools/list_gms.cpp" ]
3109    deps = [
3110      ":gm",
3111      ":skia",
3112    ]
3113  }
3114  test_app("list_gpu_unit_tests") {
3115    sources = [
3116      "dm/DMGpuTestProcs.cpp",
3117      "tools/list_gpu_unit_tests.cpp",
3118    ]
3119    deps = [
3120      ":skia",
3121      ":tests",
3122    ]
3123  }
3124
3125  test_lib("sk_app") {
3126    public_deps = [
3127      ":gpu_tool_utils",
3128      ":skia",
3129    ]
3130    sources = [
3131      "tools/sk_app/Application.h",
3132      "tools/sk_app/CommandSet.cpp",
3133      "tools/sk_app/CommandSet.h",
3134      "tools/sk_app/DisplayParams.h",
3135      "tools/sk_app/RasterWindowContext.h",
3136      "tools/sk_app/Window.cpp",
3137      "tools/sk_app/Window.h",
3138      "tools/sk_app/WindowContext.cpp",
3139      "tools/sk_app/WindowContext.h",
3140    ]
3141    libs = []
3142    frameworks = []
3143
3144    if (is_android) {
3145      sources += [
3146        "tools/sk_app/android/RasterWindowContext_android.cpp",
3147        "tools/sk_app/android/WindowContextFactory_android.h",
3148        "tools/sk_app/android/Window_android.cpp",
3149        "tools/sk_app/android/Window_android.h",
3150        "tools/sk_app/android/main_android.cpp",
3151        "tools/sk_app/android/surface_glue_android.cpp",
3152        "tools/sk_app/android/surface_glue_android.h",
3153      ]
3154      libs += [ "android" ]
3155    } else if (is_linux) {
3156      sources += [
3157        "tools/sk_app/unix/RasterWindowContext_unix.cpp",
3158        "tools/sk_app/unix/WindowContextFactory_unix.h",
3159        "tools/sk_app/unix/Window_unix.cpp",
3160        "tools/sk_app/unix/Window_unix.h",
3161        "tools/sk_app/unix/keysym2ucs.c",
3162        "tools/sk_app/unix/keysym2ucs.h",
3163        "tools/sk_app/unix/main_unix.cpp",
3164      ]
3165      libs += [
3166        "GL",  # Used by raster window context, so cannot be behind skia_use_gl.
3167        "X11",
3168      ]
3169    } else if (is_win) {
3170      sources += [
3171        "tools/sk_app/win/RasterWindowContext_win.cpp",
3172        "tools/sk_app/win/WindowContextFactory_win.h",
3173        "tools/sk_app/win/Window_win.cpp",
3174        "tools/sk_app/win/Window_win.h",
3175        "tools/sk_app/win/main_win.cpp",
3176      ]
3177    } else if (is_mac) {
3178      sources += [
3179        "tools/sk_app/mac/WindowContextFactory_mac.h",
3180        "tools/sk_app/mac/Window_mac.h",
3181        "tools/sk_app/mac/Window_mac.mm",
3182        "tools/sk_app/mac/main_mac.mm",
3183      ]
3184      frameworks += [
3185        "QuartzCore.framework",
3186        "Cocoa.framework",
3187        "Foundation.framework",
3188      ]
3189    } else if (is_ios) {
3190      sources += [
3191        "tools/sk_app/ios/WindowContextFactory_ios.h",
3192        "tools/sk_app/ios/Window_ios.h",
3193        "tools/sk_app/ios/Window_ios.mm",
3194        "tools/sk_app/ios/main_ios.mm",
3195      ]
3196      frameworks += [ "QuartzCore.framework" ]
3197    }
3198
3199    if (skia_use_gl) {
3200      sources += [ "tools/sk_app/GLWindowContext.cpp" ]
3201      sources += [ "tools/sk_app/GLWindowContext.h" ]
3202      if (is_android) {
3203        sources += [ "tools/sk_app/android/GLWindowContext_android.cpp" ]
3204      } else if (is_linux) {
3205        sources += [ "tools/sk_app/unix/GLWindowContext_unix.cpp" ]
3206      } else if (is_win) {
3207        sources += [ "tools/sk_app/win/GLWindowContext_win.cpp" ]
3208        if (skia_use_angle) {
3209          sources += [ "tools/sk_app/win/ANGLEWindowContext_win.cpp" ]
3210        }
3211      } else if (is_mac) {
3212        sources += [
3213          "tools/sk_app/mac/GLWindowContext_mac.mm",
3214          "tools/sk_app/mac/RasterWindowContext_mac.mm",
3215        ]
3216      } else if (is_ios) {
3217        sources += [
3218          "tools/sk_app/ios/GLWindowContext_ios.mm",
3219          "tools/sk_app/ios/RasterWindowContext_ios.mm",
3220        ]
3221      }
3222    }
3223
3224    if (skia_use_vulkan) {
3225      sources += [ "tools/sk_app/VulkanWindowContext.cpp" ]
3226      sources += [ "tools/sk_app/VulkanWindowContext.h" ]
3227      if (is_android) {
3228        sources += [ "tools/sk_app/android/VulkanWindowContext_android.cpp" ]
3229      } else if (is_linux) {
3230        sources += [ "tools/sk_app/unix/VulkanWindowContext_unix.cpp" ]
3231        libs += [ "X11-xcb" ]
3232      } else if (is_win) {
3233        sources += [ "tools/sk_app/win/VulkanWindowContext_win.cpp" ]
3234      }
3235    }
3236
3237    if (skia_use_metal) {
3238      sources += [ "tools/sk_app/MetalWindowContext.mm" ]
3239      sources += [ "tools/sk_app/MetalWindowContext.h" ]
3240      if (skia_enable_graphite) {
3241        sources += [ "tools/sk_app/GraphiteMetalWindowContext.mm" ]
3242        sources += [ "tools/sk_app/GraphiteMetalWindowContext.h" ]
3243      }
3244      if (is_mac) {
3245        sources += [ "tools/sk_app/mac/MetalWindowContext_mac.mm" ]
3246        if (skia_enable_graphite) {
3247          sources += [ "tools/sk_app/mac/GraphiteMetalWindowContext_mac.mm" ]
3248        }
3249      } else if (is_ios) {
3250        sources += [ "tools/sk_app/ios/MetalWindowContext_ios.mm" ]
3251      }
3252    }
3253
3254    if (skia_use_direct3d) {
3255      sources += [ "tools/sk_app/win/D3D12WindowContext_win.cpp" ]
3256    }
3257
3258    if (skia_use_dawn) {
3259      sources += [ "tools/sk_app/DawnWindowContext.cpp" ]
3260      sources += [ "tools/sk_app/DawnWindowContext.h" ]
3261      if (is_linux) {
3262        if (dawn_enable_vulkan) {
3263          sources += [ "tools/sk_app/unix/DawnVulkanWindowContext_unix.cpp" ]
3264          defines = [ "VK_USE_PLATFORM_XCB_KHR" ]
3265          libs += [ "X11-xcb" ]
3266        }
3267      } else if (is_win) {
3268        if (dawn_enable_d3d12) {
3269          sources += [ "tools/sk_app/win/DawnD3D12WindowContext_win.cpp" ]
3270        }
3271      } else if (is_mac) {
3272        if (dawn_enable_metal) {
3273          sources += [ "tools/sk_app/mac/DawnMTLWindowContext_mac.mm" ]
3274        }
3275      }
3276    }
3277
3278    deps = [ ":tool_utils" ]
3279    if (is_android) {
3280      deps += [ "${skia_third_party_dir}/native_app_glue" ]
3281    }
3282    if (skia_use_gl && skia_use_angle) {
3283      deps += [ "${skia_third_party_dir}/angle2" ]
3284    }
3285  }
3286
3287  if (!skia_use_vulkan && (is_mac || is_linux || is_win)) {
3288    test_app("fiddle_examples") {
3289      sources = [
3290        "tools/fiddle/all_examples.cpp",
3291        "tools/fiddle/examples.cpp",
3292        "tools/fiddle/examples.h",
3293      ]
3294      if (is_win && !is_mingw) {
3295        cflags = [
3296          "/wd4756",  # Overflow in constant arithmetic
3297          "/wd4305",  # truncation from 'double' to 'float'
3298        ]
3299      }
3300      deps = [
3301        ":skia",
3302        ":skia.h",
3303        "modules/particles",
3304        "modules/skottie",
3305        "modules/skparagraph",
3306        "modules/skshaper",
3307        "modules/svg",
3308      ]
3309    }
3310  }
3311
3312  # sk_app can work without GL but viewer always runs raster through a GL window context.
3313  if (skia_use_gl) {
3314    test_app("viewer") {
3315      is_shared_library = is_android
3316      sources = [
3317        "tools/viewer/AnimTimer.h",
3318        "tools/viewer/BisectSlide.cpp",
3319        "tools/viewer/BisectSlide.h",
3320        "tools/viewer/GMSlide.cpp",
3321        "tools/viewer/GMSlide.h",
3322        "tools/viewer/ImGuiLayer.cpp",
3323        "tools/viewer/ImGuiLayer.h",
3324        "tools/viewer/ImageSlide.cpp",
3325        "tools/viewer/ImageSlide.h",
3326        "tools/viewer/MSKPSlide.cpp",
3327        "tools/viewer/MSKPSlide.h",
3328        "tools/viewer/ParticlesSlide.cpp",
3329        "tools/viewer/ParticlesSlide.h",
3330        "tools/viewer/SKPSlide.cpp",
3331        "tools/viewer/SKPSlide.h",
3332        "tools/viewer/SampleSlide.cpp",
3333        "tools/viewer/SampleSlide.h",
3334        "tools/viewer/SkRiveSlide.cpp",
3335        "tools/viewer/SkRiveSlide.h",
3336        "tools/viewer/SkSLSlide.cpp",
3337        "tools/viewer/SkSLSlide.h",
3338        "tools/viewer/SkottieSlide.cpp",
3339        "tools/viewer/SkottieSlide.h",
3340        "tools/viewer/Slide.h",
3341        "tools/viewer/SlideDir.cpp",
3342        "tools/viewer/SlideDir.h",
3343        "tools/viewer/StatsLayer.cpp",
3344        "tools/viewer/StatsLayer.h",
3345        "tools/viewer/SvgSlide.cpp",
3346        "tools/viewer/SvgSlide.h",
3347        "tools/viewer/TouchGesture.cpp",
3348        "tools/viewer/TouchGesture.h",
3349        "tools/viewer/Viewer.cpp",
3350        "tools/viewer/Viewer.h",
3351      ]
3352      libs = []
3353
3354      deps = [
3355        ":common_flags_fontmgr",
3356        ":common_flags_gpu",
3357        ":flags",
3358        ":gm",
3359        ":gpu_tool_utils",
3360        ":samples",
3361        ":sk_app",
3362        ":skia",
3363        ":tool_utils",
3364        ":trace",
3365        "${skia_third_party_dir}/imgui",
3366        "experimental/skrive",
3367        "experimental/sktext",
3368        "modules/audioplayer",
3369        "modules/particles",
3370        "modules/skottie",
3371        "modules/skottie:utils",
3372        "modules/sksg:samples",
3373        "modules/svg",
3374      ]
3375      if (skia_use_experimental_xform) {
3376        deps += [ ":experimental_xform" ]
3377        sources += [ "gm/xform.cpp" ]
3378      }
3379      if (skia_use_vulkan) {
3380        deps += [
3381          "${skia_third_party_dir}/externals/spirv-tools:spvtools",
3382
3383          #spvtools depends on this but doesn't deps it in.
3384          "${skia_third_party_dir}/externals/spirv-tools:spvtools_val",
3385        ]
3386      }
3387    }
3388  }
3389
3390  if (skia_use_gl && !skia_use_angle && (is_linux || is_win || is_mac)) {
3391    test_app("HelloWorld") {
3392      sources = [ "example/HelloWorld.cpp" ]
3393      libs = []
3394
3395      deps = [
3396        ":flags",
3397        ":gpu_tool_utils",
3398        ":sk_app",
3399        ":skia",
3400        ":tool_utils",
3401      ]
3402    }
3403  }
3404
3405  if (skia_qt_path != "" && (is_win || is_linux || is_mac)) {
3406    action_foreach("generate_mocs") {
3407      script = "gn/call.py"
3408      sources = [ "tools/mdbviz/MainWindow.h" ]
3409      outputs = [ "$target_gen_dir/mdbviz/{{source_name_part}}_moc.cpp" ]
3410      args = [
3411        "$skia_qt_path" + "/bin/moc",
3412        "{{source}}",
3413        "-o",
3414        "gen/mdbviz/{{source_name_part}}_moc.cpp",
3415      ]
3416    }
3417    action_foreach("generate_resources") {
3418      script = "gn/call.py"
3419      sources = [ "tools/mdbviz/resources.qrc" ]
3420      outputs = [ "$target_gen_dir/mdbviz/{{source_name_part}}_res.cpp" ]
3421      args = [
3422        "$skia_qt_path" + "/bin/rcc",
3423        "{{source}}",
3424        "-o",
3425        "gen/mdbviz/{{source_name_part}}_res.cpp",
3426      ]
3427    }
3428    test_app("mdbviz") {
3429      if (is_win && !is_mingw) {
3430        # on Windows we need to disable some exception handling warnings due to the Qt headers
3431        cflags = [ "/Wv:18" ]  # 18 -> VS2013, 19 -> VS2015, 1910 -> VS2017
3432      }
3433      sources = [
3434        "tools/UrlDataManager.cpp",
3435        "tools/debugger/DebugCanvas.cpp",
3436        "tools/debugger/DebugLayerManager.cpp",
3437        "tools/debugger/DrawCommand.cpp",
3438        "tools/debugger/JsonWriteBuffer.cpp",
3439        "tools/mdbviz/MainWindow.cpp",
3440        "tools/mdbviz/Model.cpp",
3441        "tools/mdbviz/main.cpp",
3442
3443        # generated files
3444        "$target_gen_dir/mdbviz/MainWindow_moc.cpp",
3445        "$target_gen_dir/mdbviz/resources_res.cpp",
3446      ]
3447      lib_dirs = [ "$skia_qt_path/lib" ]
3448      libs = [
3449        "Qt5Core.lib",
3450        "Qt5Gui.lib",
3451        "Qt5Widgets.lib",
3452      ]
3453      include_dirs = [
3454        "$skia_qt_path/include",
3455        "$skia_qt_path/include/QtCore",
3456        "$skia_qt_path/include/QtWidgets",
3457      ]
3458      deps = [
3459        ":generate_mocs",
3460        ":generate_resources",
3461        ":skia",
3462      ]
3463    }
3464  }
3465
3466  if (is_android && defined(ndk) && ndk != "") {
3467    copy("gdbserver") {
3468      sources = [ "$ndk/$ndk_gdbserver" ]
3469      outputs = [ "$root_out_dir/gdbserver" ]
3470    }
3471  }
3472
3473  skia_executable("cpu_modules") {
3474    sources = [ "tools/cpu_modules.cpp" ]
3475    deps = [
3476      ":skia",
3477      "modules/particles",
3478    ]
3479  }
3480
3481  if (skia_use_icu && skia_use_harfbuzz) {
3482    test_app("editor") {
3483      is_shared_library = is_android
3484      deps = [ "modules/skplaintexteditor:editor_app" ]
3485    }
3486    test_app("text_editor") {
3487      is_shared_library = is_android
3488      deps = [ "experimental/sktext:text_editor" ]
3489    }
3490  }
3491
3492  skia_executable("image_diff_metric") {
3493    sources = [ "tools/image_diff_metric.cpp" ]
3494    deps = [ ":skia" ]
3495  }
3496
3497  group("modules_testonly") {
3498    testonly = true
3499    deps = []
3500    if (target_cpu == "wasm") {
3501      deps += [ "modules/canvaskit:viewer_wasm" ]
3502    }
3503  }
3504
3505  if (skia_build_fuzzers) {
3506    template("libfuzzer_app") {
3507      skia_executable(target_name) {
3508        output_dir = root_build_dir
3509        check_includes = false
3510        forward_variables_from(invoker, "*", [ "is_shared_library" ])
3511        if (!defined(configs)) {
3512          configs = []
3513        }
3514        configs += [ ":skia_private" ]
3515        sources += [
3516          "fuzz/Fuzz.cpp",
3517          "fuzz/FuzzCommon.cpp",
3518        ]
3519        deps += [
3520          ":flags",
3521          ":gpu_tool_utils",
3522          ":skia",
3523        ]
3524        defines = [ "SK_BUILD_FOR_LIBFUZZER" ]
3525        if (skia_use_libfuzzer_defaults) {
3526          cflags = [ "-fsanitize=fuzzer" ]
3527          ldflags = [ "-fsanitize=fuzzer" ]
3528        }
3529        testonly = true
3530      }
3531    }
3532
3533    libfuzzer_app("region_deserialize") {
3534      sources = [ "fuzz/oss_fuzz/FuzzRegionDeserialize.cpp" ]
3535      deps = []
3536    }
3537
3538    libfuzzer_app("image_filter_deserialize") {
3539      include_dirs = [
3540        "tools",
3541        "tools/fonts",
3542      ]
3543      sources = [
3544        "fuzz/oss_fuzz/FuzzImageFilterDeserialize.cpp",
3545        "tools/Resources.cpp",
3546        "tools/fonts/TestFontMgr.cpp",
3547        "tools/fonts/TestSVGTypeface.cpp",
3548        "tools/fonts/TestTypeface.cpp",
3549      ]
3550      deps = [ "modules/svg" ]
3551    }
3552
3553    libfuzzer_app("region_set_path") {
3554      sources = [ "fuzz/oss_fuzz/FuzzRegionSetPath.cpp" ]
3555      deps = []
3556    }
3557
3558    libfuzzer_app("textblob_deserialize") {
3559      include_dirs = [
3560        "tools",
3561        "tools/fonts",
3562      ]
3563      sources = [
3564        "fuzz/oss_fuzz/FuzzTextBlobDeserialize.cpp",
3565        "tools/Resources.cpp",
3566        "tools/fonts/TestFontMgr.cpp",
3567        "tools/fonts/TestSVGTypeface.cpp",
3568        "tools/fonts/TestTypeface.cpp",
3569      ]
3570      deps = [ "modules/svg" ]
3571    }
3572
3573    libfuzzer_app("path_deserialize") {
3574      sources = [ "fuzz/oss_fuzz/FuzzPathDeserialize.cpp" ]
3575      deps = []
3576    }
3577
3578    libfuzzer_app("image_decode") {
3579      sources = [ "fuzz/oss_fuzz/FuzzImage.cpp" ]
3580      deps = []
3581    }
3582
3583    libfuzzer_app("animated_image_decode") {
3584      sources = [ "fuzz/oss_fuzz/FuzzAnimatedImage.cpp" ]
3585      deps = []
3586    }
3587
3588    libfuzzer_app("api_create_ddl") {
3589      include_dirs = [
3590        "include",
3591        "include/gpu",
3592      ]
3593      sources = [
3594        "fuzz/FuzzCreateDDL.cpp",
3595        "fuzz/oss_fuzz/FuzzAPICreateDDL.cpp",
3596        "tools/Resources.cpp",
3597        "tools/UrlDataManager.cpp",
3598        "tools/debugger/DebugCanvas.cpp",
3599        "tools/debugger/DebugLayerManager.cpp",
3600        "tools/debugger/DrawCommand.cpp",
3601        "tools/debugger/JsonWriteBuffer.cpp",
3602        "tools/fonts/TestFontMgr.cpp",
3603        "tools/fonts/TestSVGTypeface.cpp",
3604        "tools/fonts/TestTypeface.cpp",
3605      ]
3606      deps = [
3607        "${skia_third_party_dir}/libpng",
3608        "modules/svg",
3609      ]
3610    }
3611
3612    libfuzzer_app("api_draw_functions") {
3613      sources = [
3614        "fuzz/FuzzDrawFunctions.cpp",
3615        "fuzz/oss_fuzz/FuzzDrawFunctions.cpp",
3616      ]
3617      deps = []
3618    }
3619
3620    libfuzzer_app("api_ddl_threading") {
3621      sources = [
3622        "fuzz/FuzzDDLThreading.cpp",
3623        "fuzz/oss_fuzz/FuzzDDLThreading.cpp",
3624      ]
3625      deps = []
3626    }
3627
3628    libfuzzer_app("api_gradients") {
3629      sources = [
3630        "fuzz/FuzzGradients.cpp",
3631        "fuzz/oss_fuzz/FuzzGradients.cpp",
3632      ]
3633      deps = []
3634    }
3635
3636    libfuzzer_app("api_image_filter") {
3637      include_dirs = [
3638        "tools",
3639        "tools/debugger",
3640      ]
3641      sources = [
3642        "fuzz/FuzzCanvas.cpp",
3643        "fuzz/oss_fuzz/FuzzAPIImageFilter.cpp",
3644        "tools/UrlDataManager.cpp",
3645        "tools/debugger/DebugCanvas.cpp",
3646        "tools/debugger/DebugLayerManager.cpp",
3647        "tools/debugger/DrawCommand.cpp",
3648        "tools/debugger/JsonWriteBuffer.cpp",
3649      ]
3650      deps = [ "${skia_third_party_dir}/libpng" ]
3651    }
3652
3653    libfuzzer_app("api_path_measure") {
3654      sources = [
3655        "fuzz/FuzzPathMeasure.cpp",
3656        "fuzz/oss_fuzz/FuzzPathMeasure.cpp",
3657      ]
3658      deps = []
3659    }
3660
3661    libfuzzer_app("api_pathop") {
3662      sources = [
3663        "fuzz/FuzzPathop.cpp",
3664        "fuzz/oss_fuzz/FuzzPathop.cpp",
3665      ]
3666      deps = []
3667    }
3668
3669    libfuzzer_app("api_triangulation") {
3670      sources = [
3671        "fuzz/FuzzTriangulation.cpp",
3672        "fuzz/oss_fuzz/FuzzTriangulation.cpp",
3673      ]
3674      deps = []
3675    }
3676
3677    libfuzzer_app("api_raster_n32_canvas") {
3678      include_dirs = [
3679        "tools",
3680        "tools/debugger",
3681        "tools/fonts",
3682      ]
3683      sources = [
3684        "fuzz/FuzzCanvas.cpp",
3685        "fuzz/oss_fuzz/FuzzRasterN32Canvas.cpp",
3686        "tools/Resources.cpp",
3687        "tools/UrlDataManager.cpp",
3688        "tools/debugger/DebugCanvas.cpp",
3689        "tools/debugger/DebugLayerManager.cpp",
3690        "tools/debugger/DrawCommand.cpp",
3691        "tools/debugger/JsonWriteBuffer.cpp",
3692        "tools/fonts/TestFontMgr.cpp",
3693        "tools/fonts/TestSVGTypeface.cpp",
3694        "tools/fonts/TestTypeface.cpp",
3695      ]
3696      deps = [
3697        "${skia_third_party_dir}/libpng",
3698        "modules/svg",
3699      ]
3700    }
3701
3702    libfuzzer_app("api_regionop") {
3703      sources = [
3704        "fuzz/FuzzRegionOp.cpp",
3705        "fuzz/oss_fuzz/FuzzRegionOp.cpp",
3706      ]
3707      deps = []
3708    }
3709
3710    if (skia_use_gl) {
3711      libfuzzer_app("api_mock_gpu_canvas") {
3712        include_dirs = [
3713          "tools",
3714          "tools/debugger",
3715          "tools/fonts",
3716        ]
3717        sources = [
3718          "fuzz/FuzzCanvas.cpp",
3719          "fuzz/oss_fuzz/FuzzMockGPUCanvas.cpp",
3720          "tools/LsanSuppressions.cpp",
3721          "tools/Resources.cpp",
3722          "tools/UrlDataManager.cpp",
3723          "tools/debugger/DebugCanvas.cpp",
3724          "tools/debugger/DebugLayerManager.cpp",
3725          "tools/debugger/DrawCommand.cpp",
3726          "tools/debugger/JsonWriteBuffer.cpp",
3727          "tools/fonts/TestFontMgr.cpp",
3728          "tools/fonts/TestSVGTypeface.cpp",
3729          "tools/fonts/TestTypeface.cpp",
3730        ]
3731        deps = [
3732          "${skia_third_party_dir}/libpng",
3733          "modules/svg",
3734        ]
3735      }
3736    }
3737
3738    libfuzzer_app("api_null_canvas") {
3739      include_dirs = [
3740        "tools",
3741        "tools/debugger",
3742        "tools/fonts",
3743      ]
3744      sources = [
3745        "fuzz/FuzzCanvas.cpp",
3746        "fuzz/oss_fuzz/FuzzNullCanvas.cpp",
3747        "tools/Resources.cpp",
3748        "tools/UrlDataManager.cpp",
3749        "tools/debugger/DebugCanvas.cpp",
3750        "tools/debugger/DebugLayerManager.cpp",
3751        "tools/debugger/DrawCommand.cpp",
3752        "tools/debugger/JsonWriteBuffer.cpp",
3753        "tools/fonts/TestFontMgr.cpp",
3754        "tools/fonts/TestSVGTypeface.cpp",
3755        "tools/fonts/TestTypeface.cpp",
3756      ]
3757      deps = [
3758        "${skia_third_party_dir}/libpng",
3759        "modules/svg",
3760      ]
3761    }
3762
3763    libfuzzer_app("api_skparagraph") {
3764      sources = [
3765        "fuzz/FuzzSkParagraph.cpp",
3766        "fuzz/oss_fuzz/FuzzSkParagraph.cpp",
3767        "tools/Resources.cpp",
3768      ]
3769      deps = [ "modules/skparagraph" ]
3770    }
3771
3772    libfuzzer_app("api_svg_canvas") {
3773      include_dirs = [
3774        "include",
3775        "include/svg",
3776      ]
3777      sources = [
3778        "fuzz/FuzzCanvas.cpp",
3779        "fuzz/oss_fuzz/FuzzAPISVGCanvas.cpp",
3780        "tools/Resources.cpp",
3781        "tools/UrlDataManager.cpp",
3782        "tools/debugger/DebugCanvas.cpp",
3783        "tools/debugger/DebugLayerManager.cpp",
3784        "tools/debugger/DrawCommand.cpp",
3785        "tools/debugger/JsonWriteBuffer.cpp",
3786        "tools/fonts/TestFontMgr.cpp",
3787        "tools/fonts/TestSVGTypeface.cpp",
3788        "tools/fonts/TestTypeface.cpp",
3789      ]
3790      deps = [
3791        "${skia_third_party_dir}/libpng",
3792        "modules/svg",
3793      ]
3794    }
3795
3796    libfuzzer_app("png_encoder") {
3797      sources = [
3798        "fuzz/FuzzEncoders.cpp",
3799        "fuzz/oss_fuzz/FuzzPNGEncoder.cpp",
3800      ]
3801      deps = []
3802    }
3803
3804    libfuzzer_app("jpeg_encoder") {
3805      sources = [
3806        "fuzz/FuzzEncoders.cpp",
3807        "fuzz/oss_fuzz/FuzzJPEGEncoder.cpp",
3808      ]
3809      deps = []
3810    }
3811
3812    libfuzzer_app("webp_encoder") {
3813      sources = [
3814        "fuzz/FuzzEncoders.cpp",
3815        "fuzz/oss_fuzz/FuzzWEBPEncoder.cpp",
3816      ]
3817      deps = []
3818    }
3819
3820    libfuzzer_app("skottie_json") {
3821      sources = [
3822        "modules/skottie/fuzz/FuzzSkottieJSON.cpp",
3823        "tools/Resources.cpp",
3824        "tools/fonts/TestFontMgr.cpp",
3825        "tools/fonts/TestSVGTypeface.cpp",
3826        "tools/fonts/TestTypeface.cpp",
3827      ]
3828      deps = [
3829        "modules/skottie:skottie",
3830        "modules/svg",
3831      ]
3832    }
3833
3834    libfuzzer_app("skjson") {
3835      sources = [ "fuzz/oss_fuzz/FuzzJSON.cpp" ]
3836      deps = []
3837    }
3838
3839    libfuzzer_app("api_polyutils") {
3840      sources = [
3841        "fuzz/FuzzPolyUtils.cpp",
3842        "fuzz/oss_fuzz/FuzzPolyUtils.cpp",
3843      ]
3844      deps = [ ":skia" ]
3845    }
3846
3847    libfuzzer_app("android_codec") {
3848      sources = [ "fuzz/oss_fuzz/FuzzAndroidCodec.cpp" ]
3849      deps = []
3850    }
3851
3852    libfuzzer_app("image_decode_incremental") {
3853      sources = [ "fuzz/oss_fuzz/FuzzIncrementalImage.cpp" ]
3854      deps = []
3855    }
3856
3857    libfuzzer_app("sksl2glsl") {
3858      sources = [ "fuzz/oss_fuzz/FuzzSKSL2GLSL.cpp" ]
3859      deps = []
3860    }
3861
3862    libfuzzer_app("sksl2spirv") {
3863      sources = [ "fuzz/oss_fuzz/FuzzSKSL2SPIRV.cpp" ]
3864      deps = []
3865    }
3866
3867    libfuzzer_app("sksl2metal") {
3868      sources = [ "fuzz/oss_fuzz/FuzzSKSL2Metal.cpp" ]
3869      deps = []
3870    }
3871
3872    libfuzzer_app("sksl2pipeline") {
3873      sources = [ "fuzz/oss_fuzz/FuzzSKSL2Pipeline.cpp" ]
3874      deps = []
3875    }
3876
3877    libfuzzer_app("skdescriptor_deserialize") {
3878      sources = [ "fuzz/oss_fuzz/FuzzSkDescriptorDeserialize.cpp" ]
3879      deps = []
3880    }
3881
3882    libfuzzer_app("svg_dom") {
3883      sources = [ "fuzz/oss_fuzz/FuzzSVG.cpp" ]
3884      deps = [ "modules/svg" ]
3885    }
3886
3887    libfuzzer_app("skruntimeeffect") {
3888      sources = [ "fuzz/oss_fuzz/FuzzSkRuntimeEffect.cpp" ]
3889      deps = []
3890    }
3891
3892    libfuzzer_app("skp") {
3893      sources = [ "fuzz/oss_fuzz/FuzzSKP.cpp" ]
3894      deps = []
3895    }
3896  }
3897}
3898
3899if (is_ios && skia_use_metal && skia_enable_gpu &&
3900    !skia_enable_flutter_defines) {
3901  group("minimal_ios_mtl_skia_app") {
3902    deps = [ "experimental/minimal_ios_mtl_skia_app" ]
3903  }
3904}
3905
3906if (is_ios && skia_enable_skottie && !skia_enable_flutter_defines) {
3907  group("skottie_ios") {
3908    deps = [ "tools/skottie_ios_app" ]
3909  }
3910}
3911
3912skia_executable("skia_c_api_example") {
3913  sources = [ "experimental/c-api-example/skia-c-example.c" ]
3914  include_dirs = [ "." ]
3915  deps = [ ":skia" ]
3916}
3917