# Copyright 2013 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/buildflag_header.gni")
import("//build/config/compiler/compiler.gni")
import("//build/config/features.gni")
import("//build/config/freetype/freetype.gni")
import("//build/config/rust.gni")
import("//build/config/sanitizers/sanitizers.gni")
import("//build/rust/rust_static_library.gni")
import("//gpu/vulkan/features.gni")
import("//skia/skia.gni")
import("//testing/libfuzzer/fuzzer_test.gni")
import("//testing/test.gni")
import("//third_party/skia/gn/shared_sources.gni")
import("//third_party/skia/modules/skcms/skcms.gni")
import("features.gni")

if (current_cpu == "arm") {
  import("//build/config/arm.gni")
}
if (current_cpu == "mipsel" || current_cpu == "mips64el") {
  import("//build/config/mips.gni")
}
if (enable_rust_png) {
  import("//build/rust/rust_static_library.gni")
}

buildflag_header("buildflags") {
  header = "buildflags.h"
  flags = [
    "SKIA_BUILD_RUST_PNG=$enable_rust_png",
    "SKIA_SUPPORT_SKOTTIE=$skia_support_skottie",
    "SKIA_USE_DAWN=$skia_use_dawn",
    "SKIA_USE_METAL=$skia_use_metal",
  ]
}

source_set("path_bridge") {
  sources = skia_fontations_path_bridge_sources
}

rust_static_library("bridge_rust_side") {
  allow_unsafe = true
  crate_root = skia_fontations_bridge_root
  sources = skia_ports_fontations_bridge_rust_side_sources
  cxx_bindings = [ skia_fontations_bridge_root ]
  deps = [
    ":path_bridge",
    "//third_party/rust/font_types/v0_8:lib",
    "//third_party/rust/read_fonts/v0_27:lib",
    "//third_party/rust/skrifa/v0_29:lib",
  ]
  configs -= [ "//build/config/compiler:chromium_code" ]
  configs += [
    ":skia_config",
    "//build/config/compiler:no_chromium_code",
  ]
}

# External-facing config for dependent code.
config("skia_config") {
  defines = [
    "SK_ENABLE_SKSL",
    "SK_UNTIL_CRBUG_1187654_IS_FIXED",
    "SK_USER_CONFIG_HEADER=\"../../skia/config/SkUserConfig.h\"",
    "SK_WIN_FONTMGR_NO_SIMULATIONS",
    "SK_DISABLE_LEGACY_INIT_DECODERS",
  ]

  include_dirs = [
    "//third_party/skia",
    "$root_gen_dir/third_party/skia",
  ]

  if (use_blink) {
    # TODO(kjlubick) make these not necessary
    defines += [
      "SK_CODEC_DECODES_JPEG",
      "SK_CODEC_ENCODES_JPEG",
    ]
    include_dirs += [ "//third_party/wuffs/src/release/c" ]
  }

  if (is_component_build) {
    defines += [ "SKIA_DLL" ]
    if (is_win) {
      defines += [ "SKCMS_API=__declspec(dllexport)" ]
    } else {
      defines += [ "SKCMS_API=__attribute__((visibility(\"default\")))" ]
    }
  }

  # `SK_GAMMA_EXPONENT` and `SK_GAMMA_CONTRAST` are settings for text
  # blitting, chosen to approximate the system browser.
  if (is_linux || is_chromeos) {
    defines += [
      "SK_GAMMA_EXPONENT=1.2",
      "SK_GAMMA_CONTRAST=0.2",
    ]
  } else if (is_android) {
    defines += [
      "SK_BUILD_FOR_ANDROID",
      "USE_CHROMIUM_SKIA",
      "SK_GAMMA_APPLY_TO_A8",
      "SK_GAMMA_EXPONENT=1.4",
      "SK_GAMMA_CONTRAST=0.0",
    ]
  } else if (is_mac) {
    defines += [
      "SK_BUILD_FOR_MAC",
      "SK_GAMMA_SRGB",
      "SK_GAMMA_CONTRAST=0.0",
    ]
  } else if (is_ios) {
    defines += [ "SK_BUILD_FOR_IOS" ]
    if (ios_is_app_extension) {
      defines += [ "SK_BUILD_FOR_IOS_APP_EXTENSION" ]
    }
  } else if (is_win) {
    defines += [
      "GR_GL_FUNCTION_TYPE=__stdcall",
      "SK_GAMMA_SRGB",
      "SK_GAMMA_CONTRAST=1.0",
    ]
  }

  if (skia_support_gpu) {
    workaround_header = "gpu/config/gpu_driver_bug_workaround_autogen.h"
    configs = []
    defines += [
      "SK_GANESH",
      "SK_GPU_WORKAROUNDS_HEADER=\"$workaround_header\"",
    ]
    if (skia_use_gl) {
      defines += [ "SK_GL" ]
    }
    if (enable_vulkan) {
      defines += [ "SK_VULKAN=1" ]
      configs += [ "//third_party/vulkan-headers/src:vulkan_headers_config" ]
    }

    # Graphite
    defines += [ "SK_GRAPHITE" ]
    if (skia_use_dawn) {
      defines += [ "SK_DAWN" ]
      configs += [ "//third_party/dawn/include/dawn:public" ]
    }
    if (skia_use_metal) {
      defines += [ "SK_METAL" ]
    }
  }
  if (current_cpu == "loong64") {
    cflags = [
      "-mlsx",
      "-flax-vector-conversions=all",
    ]
  }
}

# Internal-facing config for Skia library code.
config("skia_library_config") {
  # Turn on SK_API to export Skia's public API
  defines = [
    "IS_SKIA_IMPL=1",
    "SKIA_IMPLEMENTATION=1",
  ]

  # Let Skia know whether to use `libpng`-based or Rust-based PNG decoder and
  # encoder in internal Skia code (e.g. in implementation of Fontations).
  #
  # This currently mimics what is done in `third_party/skia/BUILD.gn`'s
  # `png_decode_libpng` and `png_encode` targets.
  #
  # TODO(https://crbug.com/381900683): When Rust PNG ships, then switch to
  # using `SK_CODEC_DECODES_PNG_WITH_RUST` and `SK_CODEC_ENCODES_PNG_WITH_RUST`
  # defines from Skia's `png_encode_rust` and `png_decode_rust` targets.
  defines += [
    "SK_CODEC_DECODES_ICO",
    "SK_CODEC_DECODES_PNG",
    "SK_CODEC_DECODES_PNG_WITH_LIBPNG",
    "SK_CODEC_ENCODES_PNG",
    "SK_CODEC_ENCODES_PNG_WITH_LIBPNG",
  ]

  if (use_blink && !use_system_freetype) {
    defines += [ "SK_FREETYPE_MINIMUM_RUNTIME_VERSION_IS_BUILD_VERSION" ]
  }
  if (use_blink && enable_freetype) {
    defines += [
      "SK_TYPEFACE_FACTORY_FREETYPE",
      "SK_TYPEFACE_FACTORY_FONTATIONS",
      "SK_FONTMGR_FREETYPE_EMPTY_AVAILABLE",
    ]
  }
  if (is_win) {
    defines += [ "SK_TYPEFACE_FACTORY_DIRECTWRITE" ]
  }
  if (is_apple) {
    defines += [ "SK_TYPEFACE_FACTORY_CORETEXT" ]
  }

  if (current_cpu == "arm") {
    if (arm_use_neon) {
      defines += [ "SK_ARM_HAS_NEON" ]
    } else if (arm_optionally_use_neon) {
      defines += [ "SK_ARM_HAS_OPTIONAL_NEON" ]
    }
  }

  if (is_android) {
    defines += [
      # Android devices are typically more memory constrained, so default to a
      # smaller glyph cache (it may be overriden at runtime when the renderer
      # starts up, depending on the actual device memory).
      "SK_DEFAULT_FONT_CACHE_LIMIT=1048576",  # 1024 * 1024
    ]
  } else {
    defines += [ "SK_DEFAULT_FONT_CACHE_LIMIT=20971520" ]  # 20 * 1024 * 1024
  }

  if (is_win) {
    defines += [
      # On windows, GDI handles are a scarse system-wide resource so we have to
      # keep the glyph cache, which holds up to 4 GDI handles per entry, to a
      # fairly small size. http://crbug.com/314387
      "SK_DEFAULT_FONT_CACHE_COUNT_LIMIT=256",
    ]
  }
}

# Split out into separate target so that path_bridge can depend on the public
# headers only and we can avoid a cyclic dependency when building the C++ native
# code for the Fontations rust backend.
source_set("skia_core_public_headers") {
  public = skia_core_public
}

component("skia") {
  deps = []
  public = [
    "ext/benchmarking_canvas.h",
    "ext/cicp.h",
    "ext/codec_utils.h",
    "ext/convolver.h",
    "ext/draw_gainmap_image.h",
    "ext/event_tracer_impl.h",
    "ext/font_utils.h",
    "ext/geometry.h",
    "ext/image_operations.h",
    "ext/legacy_display_globals.h",
    "ext/opacity_filter_canvas.h",
    "ext/pmcolor_utils.h",
    "ext/recursive_gaussian_convolution.h",
    "ext/rgba_to_yuva.h",
    "ext/skcolorspace_primaries.h",
    "ext/skcolorspace_trfn.h",
    "ext/skia_memory_dump_provider.h",
    "ext/skia_trace_memory_dump_impl.h",
    "ext/skia_utils_base.h",
    "fontations_feature.h",
    "rusty_png_feature.h",
  ]
  sources = [
    # Chrome sources.
    "config/SkUserConfig.h",
    "config/sk_ref_cnt_ext_debug.h",
    "config/sk_ref_cnt_ext_release.h",
    "ext/SkDiscardableMemory_chrome.cc",
    "ext/SkDiscardableMemory_chrome.h",
    "ext/SkMemory_new_handler.cpp",
    "ext/benchmarking_canvas.cc",
    "ext/cicp.cc",
    "ext/codec_utils.cc",
    "ext/convolver.cc",
    "ext/draw_gainmap_image.cc",
    "ext/event_tracer_impl.cc",
    "ext/font_utils.cc",
    "ext/geometry.cc",
    "ext/google_logging.cc",
    "ext/image_operations.cc",
    "ext/legacy_display_globals.cc",
    "ext/opacity_filter_canvas.cc",
    "ext/recursive_gaussian_convolution.cc",
    "ext/rgba_to_yuva.cc",
    "ext/skcolorspace_primaries.cc",
    "ext/skcolorspace_trfn.cc",
    "ext/skia_histogram.cc",
    "ext/skia_histogram.h",
    "ext/skia_memory_dump_provider.cc",
    "ext/skia_trace_memory_dump_impl.cc",
    "ext/skia_utils_base.cc",
    "fontations_feature.cc",
    "rusty_png_feature.cc",
  ]
  if (is_ios) {
    public += [ "ext/skia_utils_ios.h" ]
    sources += [ "ext/skia_utils_ios.mm" ]
  }
  if (is_mac) {
    public += [ "ext/skia_utils_mac.h" ]
    sources += [ "ext/skia_utils_mac.mm" ]
  }
  if (is_win) {
    public += [ "ext/skia_utils_win.h" ]
    sources += [ "ext/skia_utils_win.cc" ]
  }

  if (use_blink) {
    public += [ "ext/platform_canvas.h" ]
    sources += [ "ext/platform_canvas.cc" ]
  }
  if (!is_ios && (current_cpu == "x86" || current_cpu == "x64")) {
    sources += [
      "ext/convolver_SSE2.cc",
      "ext/convolver_SSE2.h",
    ]
  } else if (current_cpu == "mipsel" && mips_dsp_rev >= 2) {
    sources += [
      "ext/convolver_mips_dspr2.cc",
      "ext/convolver_mips_dspr2.h",
    ]
  } else if (current_cpu == "arm" || current_cpu == "arm64") {
    if (arm_use_neon) {
      sources += [
        "ext/convolver_neon.cc",
        "ext/convolver_neon.h",
      ]
    }
  } else if (current_cpu == "loong64") {
    sources += [
      "ext/convolver_LSX.cc",
      "ext/convolver_LSX.h",
    ]
  }

  if (is_win) {
    sources += [
      # Select the right BitmapPlatformDevice.
      "ext/raster_handle_allocator_win.cc",
    ]
  }

  # skia_core_public is included via public_deps instead as the path_bridge
  # target needs it as well.
  public += skia_utils_public
  public += skia_effects_public
  public += skia_effects_imagefilter_public
  public += skia_utils_chromium
  public += skia_discardable_memory_chromium
  public += skia_codec_public
  public += skia_encode_public
  public += skia_encode_png_public
  public += skia_encode_webp_public

  # The imported Skia gni source paths are made absolute by gn.
  defines = []
  sources += skia_ports_sources
  sources += skia_sksl_core_sources
  sources += skia_sksl_core_module_sources
  sources += skia_codec_shared
  sources += skia_codec_png_base
  sources += skia_codec_libpng_srcs
  sources += skia_utils_private
  sources += skia_xps_sources
  sources += skia_encode_srcs
  sources += skia_encode_png_base
  sources += skia_encode_libpng_srcs
  sources += skia_encode_webp_srcs
  sources += [
    "//third_party/skia/src/sfnt/SkOTTable_name.cpp",
    "//third_party/skia/src/sfnt/SkOTUtils.cpp",
  ]
  if (use_blink) {
    sources += skia_codec_decode_bmp
    sources += skia_encode_jpeg_srcs
    public += skia_encode_jpeg_public
    sources += [
      "//third_party/skia/src/codec/SkIcoCodec.cpp",
      "//third_party/skia/src/codec/SkJpegCodec.cpp",
      "//third_party/skia/src/codec/SkJpegDecoderMgr.cpp",
      "//third_party/skia/src/codec/SkJpegMetadataDecoderImpl.cpp",
      "//third_party/skia/src/codec/SkJpegMultiPicture.cpp",
      "//third_party/skia/src/codec/SkJpegSegmentScan.cpp",
      "//third_party/skia/src/codec/SkJpegSourceMgr.cpp",
      "//third_party/skia/src/codec/SkJpegUtility.cpp",
      "//third_party/skia/src/codec/SkWebpCodec.cpp",
      "//third_party/skia/src/codec/SkWuffsCodec.cpp",
    ]
    deps += [ "//third_party/wuffs" ]
  } else {
    sources += skia_no_encode_jpeg_srcs
  }

  if (skia_support_xmp) {
    sources += skia_xml_sources
    sources += skia_codec_xmp
    sources += skia_codec_jpeg_xmp
    sources += [
      "//third_party/skia/src/svg/SkSVGCanvas.cpp",
      "//third_party/skia/src/svg/SkSVGDevice.cpp",
    ]
    deps += [ "//third_party/expat" ]
    defines += [ "SK_CODEC_DECODES_JPEG_GAINMAPS" ]
  } else {
    # Remove unused util sources.
    sources -= [ "//third_party/skia/src/utils/SkParsePath.cpp" ]
  }

  if (is_win) {
    libs = [ "fontsub.lib" ]
  }

  # Select Skia ports.

  # FreeType is needed everywhere where blink is used, on Linux and Android as main
  # font backend, on Windows and Mac as fallback backend for Variations. Pdfium
  # also uses this when decoding data out of the device cache.
  # Fontations is the backend we are migrating to. In preparation for rollout
  # default compile-in Fontations as well.
  if (use_blink) {
    # See SK_TYPEFACE_FACTORY_FREETYPE and SK_TYPEFACE_FACTORY_FONTATIONS
    if (enable_freetype) {
      sources += skia_ports_freetype_sources
      sources += skia_ports_fontmgr_custom_sources
      sources += skia_ports_fontmgr_empty_sources
      public += skia_ports_fontmgr_empty_public
    }
    sources += skia_ports_typeface_proxy_sources
    sources += skia_ports_typeface_fontations_sources
    sources += skia_ports_fontmgr_fontations_sources

    # Fontations Rust/C++ bridge interfaces.
    deps += [
      ":bridge_rust_side",
      ":path_bridge",
    ]
  }

  if (is_win) {
    # See SK_TYPEFACE_FACTORY_DIRECTWRITE
    sources += skia_ports_windows_fonts_sources
    sources += skia_ports_windows_sources
  } else {
    sources += [ "//third_party/skia/src/ports/SkOSFile_posix.cpp" ]
  }

  if (is_apple) {
    # See SK_TYPEFACE_FACTORY_CORETEXT
    public += skia_ports_fontmgr_coretext_public
    sources += skia_ports_fontmgr_coretext_sources
  }

  if (is_linux || is_chromeos) {
    public += skia_ports_fci_public
    sources += skia_ports_fci_sources
  }

  if (is_linux || is_chromeos || is_android) {
    # Retain the files for the SkFontMgr_Android on linux to emulate android
    # fonts. See content/zygote/zygote_main_linux.cc
    # Note that this requires expat.
    sources += skia_ports_fontmgr_android_sources
  }

  if (is_fuchsia) {
    public += skia_ports_fontmgr_fuchsia_public
    sources += skia_ports_fontmgr_fuchsia_sources

    # This is already here if use_blink is set
    if (!use_blink) {
      sources += skia_ports_fontmgr_custom_sources
    }
    deps += [
      "//third_party/fuchsia-sdk/sdk/fidl/fuchsia.fonts:fuchsia.fonts_hlcpp",
      "//third_party/fuchsia-sdk/sdk/fidl/fuchsia.io:fuchsia.io_hlcpp",
      "//third_party/fuchsia-sdk/sdk/pkg/sys_cpp",
      "//third_party/fuchsia-sdk/sdk/pkg/zx",
      "//third_party/icu:icuuc",
    ]
  }

  configs -= [ "//build/config/compiler:chromium_code" ]
  configs += [
    ":skia_config",
    ":skia_library_config",
    "//build/config/compiler:no_chromium_code",
  ]
  all_dependent_configs = [ ":skia_config" ]

  deps += [
    ":skcms",
    ":skia_opts",
    ":skia_switches",
    "//base",
    "//third_party/libpng",
    "//third_party/libwebp",
    "//third_party/libwebp:libwebp_webp",
    "//ui/base:features",
  ]
  public_deps = [
    ":buildflags",
    ":skia_core_and_effects",
    ":skia_core_public_headers",
  ]

  if (use_blink) {
    deps += [
      "//build/config/freetype",
      "//third_party:jpeg",
    ]
  }

  if (is_linux || is_chromeos) {
    deps += [
      "//third_party/expat",
      "//third_party/fontconfig",
      "//third_party/icu:icuuc",
    ]
  }

  if (is_android) {
    deps += [
      "//third_party/cpu_features:ndk_compat",
      "//third_party/expat",
    ]
  }

  if (!is_debug) {
    configs -= [ "//build/config/compiler:default_optimization" ]
    configs += [ "//build/config/compiler:optimize_max" ]
  }

  frameworks = []
  if (is_ios) {
    frameworks += [ "ImageIO.framework" ]
  }
  if (is_apple && skia_support_gpu) {
    frameworks += [
      "CoreFoundation.framework",
      "CoreGraphics.framework",
      "CoreText.framework",
      "Foundation.framework",
    ]
    if (is_mac) {
      frameworks += [ "AppKit.framework" ]
    }
    if (is_ios) {
      frameworks += [ "IOSurface.framework" ]
    }
  }

  if (is_fuchsia) {
    deps += [ "//third_party/expat" ]
  }

  if (skia_support_gpu) {
    public += skia_gpu_public
    public += skia_gpu_chromium_public
    sources += skia_ganesh_private
    sources += skia_null_gpu_sources
    sources += skia_sksl_pipeline_sources
    sources += skia_sksl_codegen_sources
    sources += skia_shared_gpu_sources
    if (skia_use_gl) {
      public += skia_gpu_gl_public
      sources += skia_gpu_gl_private
    }
    if (enable_vulkan) {
      public += skia_gpu_vk_public
      public += skia_gpu_vk_chromium_public
      sources += skia_gpu_vk_private
      sources += skia_shared_vk_sources
      sources += skia_gpu_vk_chromium_private
    }

    public_deps += [ ":skia_graphite_public" ]
    deps += [ ":skia_graphite_private" ]

    if (skia_use_metal) {
      deps += [ ":skia_ganesh_metal" ]
    }
    deps += [ "//gpu/config:workaround_list" ]
  } else {
    sources += skia_no_slug_srcs
  }

  if (skia_support_pdf) {
    # Blink includes Skia's JPEG encoder and decoder which pdf uses.
    assert(use_blink)
    deps += [
      "//third_party:freetype_harfbuzz",
      "//third_party/zlib",
    ]
    public += skia_pdf_public
    sources += skia_pdf_sources
  } else {
    sources += [ "//third_party/skia/src/pdf/SkDocument_PDF_None.cpp" ]
  }

  if (skia_support_skottie) {
    import("//third_party/skia/modules/jsonreader/jsonreader.gni")
    import("//third_party/skia/modules/skottie/skottie.gni")
    import("//third_party/skia/modules/skresources/skresources.gni")
    import("//third_party/skia/modules/sksg/sksg.gni")
    import("//third_party/skia/modules/skshaper/skshaper.gni")
    public += skia_skottie_public
    sources += skia_jsonreader_sources
    sources += skia_shaper_primitive_sources
    sources += skia_skottie_sources
    sources += skia_skresources_sources
    sources += skia_sksg_sources
    defines += [
      "SK_SHAPER_PRIMITIVE_AVAILABLE",
      "SKOTTIE_TRIVIAL_FONTRUN_ITER",
    ]
  }

  if (enable_rust_png) {
    deps += [ ":rust_png_ffi" ]
    public += skia_codec_rust_png_public
    sources += skia_codec_rust_png
    public += skia_encode_rust_png_public
    sources += skia_encode_rust_png_srcs
  }
}

component("skia_switches") {
  sources = [
    "ext/switches.cc",
    "ext/switches.h",
    "ext/switches_export.h",
  ]

  defines = [ "SKIA_SWITCHES_IMPLEMENTATION" ]

  deps = [ "//base" ]
}

if (enable_rust_png) {
  rust_static_library("rust_png_ffi") {
    visibility = [ ":*" ]
    allow_unsafe = true  # For FFI
    crate_root = skia_codec_rust_png_ffi_crate_root
    sources = skia_codec_rust_png_ffi_rs_srcs
    cxx_bindings = skia_codec_rust_png_ffi_cxx_bridge_srcs
    public_deps = [ ":rust_png_ffi_cpp" ]
    deps = [ "//third_party/rust/png/v0_18:lib" ]
    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [
      ":skia_config",
      "//build/config/compiler:no_chromium_code",
    ]
  }

  source_set("rust_png_ffi_cpp") {
    visibility = [ ":*" ]
    public = skia_codec_rust_png_ffi_cpp_hdrs
    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [
      ":skia_config",
      "//build/config/compiler:no_chromium_code",
    ]
  }
}

# Template for things that are logically part of :skia, but need to be split out
# so custom compile flags can be applied.
#
# These are all opted out of check_includes, due to (logically) being part of
# skia.
template("skia_source_set") {
  source_set(target_name) {
    forward_variables_from(invoker, "*")

    check_includes = false

    if (!is_debug) {
      configs -= [ "//build/config/compiler:default_optimization" ]
      configs += [ "//build/config/compiler:optimize_max" ]
    }

    configs -= [ "//build/config/compiler:chromium_code" ]
    configs += [
      ":skia_config",
      ":skia_library_config",
      "//build/config/compiler:no_chromium_code",
    ]
    public_configs = [ ":skia_config" ]

    if (is_apple) {
      # Do not compile with ARC because Skia code is not compatible with being
      # compiled with ARC.
      configs -= [ "//build/config/compiler:enable_arc" ]
    }

    # Android, the only user of mismatched sample files (for now), gets a small
    # binary size decrease by using AFDO to optimize for size in these
    # source_sets. However, that also comes at a relatively big performance
    # cost.
    if (using_mismatched_sample_profile) {
      configs -= [ "//build/config/compiler:afdo_optimize_size" ]
    }
    if (is_win) {
      cflags_cc = [
        "/wd5041",  # out-of-line definition for constexpr static data member is
                    # not needed and is deprecated in C++17
      ]
    }
  }
}

# Split out for targeted removal of the afdo_optimize_size config on Android.
skia_source_set("skia_core_and_effects") {
  defines = []
  sources = skia_core_sources
  sources += skia_colorfilters_sources
  sources += skia_effects_sources
  sources += skia_effects_imagefilter_sources
  if (skia_support_gpu) {
    deps = [ "//gpu/config:workaround_list" ]
  }
  if (skia_use_dawn) {
    # Note: This is needed as files in this target include GrDawnTypes.h, which
    # includes Dawn headers that are generated by the below target. Normally it
    # would be enough for the target that has GrDawnTypes.h in it to just have
    # cpp_headers in its public deps. However, that file is in
    # sk_gpu_dawn_public, which we add to the "skia" target, which depends on
    # skia_core_and_effects rather than the other way around.
    public_deps = [ "//third_party/dawn/include/dawn:cpp_headers" ]
  }
  if (use_blink) {
    # Fontations Rust/C++ bridge interfaces, needed by SkTypeface.
    deps += [
      ":bridge_rust_side",
      ":path_bridge",
    ]
  }
  visibility = [ ":skia" ]
}

# Bits that involve special vector-y hardware.
if (current_cpu == "x86" || current_cpu == "x64") {
  skia_source_set("skia_opts_hsw") {
    sources = skia_opts.hsw_sources
    if (!is_win) {
      cflags = [
        "-mavx2",
        "-mbmi",
        "-mbmi2",
        "-mf16c",
        "-mfma",
      ]
    } else {
      cflags = [ "/arch:AVX2" ]
    }
    visibility = [ ":skia_opts" ]
  }
}

if (current_cpu == "loong64") {
  skia_source_set("skia_opts_lasx") {
    sources = skia_opts.lasx_sources
    cflags = [
      "-mlasx",
      "-flax-vector-conversions=all",
    ]
    visibility = [ ":skia_opts" ]
  }
}

skia_source_set("skia_opts") {
  cflags = []
  defines = []

  deps = [ "//base" ]

  if (current_cpu == "x86" || current_cpu == "x64") {
    deps += [ ":skia_opts_hsw" ]
  } else if (current_cpu == "arm") {
    # The assembly uses the frame pointer register (r7 in Thumb/r11 in
    # ARM), the compiler doesn't like that.
    if (!is_ios) {
      cflags += [ "-fomit-frame-pointer" ]
    }

    if (arm_version >= 7) {
      if (arm_use_neon || arm_optionally_use_neon) {
        # Root build config sets -mfpu=$arm_fpu, which we expect to be neon
        # when running this.
        if (!arm_use_neon) {
          configs -= [ "//build/config/compiler:compiler_arm_fpu" ]
          cflags += [ "-mfpu=neon" ]
        }
      }
    }
  } else if (current_cpu == "arm64") {
    # Conditional and empty body needed to avoid assert() below.
  } else if (current_cpu == "arm64e") {
    # Conditional and empty body needed to avoid assert() below.
  } else if (current_cpu == "mipsel") {
    cflags += [ "-fomit-frame-pointer" ]
  } else if (current_cpu == "mips64el") {
    cflags += [ "-fomit-frame-pointer" ]
  } else if (current_cpu == "ppc64") {
    # Conditional and empty body needed to avoid assert() below.
  } else if (current_cpu == "s390x") {
    # Conditional and empty body needed to avoid assert() below.
  } else if (current_cpu == "riscv64") {
    # Conditional and empty body needed to avoid assert() below.
  } else if (current_cpu == "loong64") {
    deps += [ ":skia_opts_lasx" ]
  } else {
    assert(false, "Unknown cpu target")
  }

  visibility = [ ":skia" ]
}

if (current_cpu == "x64") {
  skia_source_set("skcms_TransformHsw") {
    sources = skcms_TransformHsw
    if (!is_win) {
      cflags = [
        "-w",
        "-mavx2",
        "-mf16c",
        "-std=c11",
      ]
    } else {
      cflags = [ "/arch:AVX2" ]
    }
    visibility = [ ":skcms" ]
  }
  skia_source_set("skcms_TransformSkx") {
    sources = skcms_TransformSkx
    if (!is_win) {
      cflags = [
        "-w",
        "-mavx512f",
        "-mavx512dq",
        "-mavx512cd",
        "-mavx512bw",
        "-mavx512vl",
        "-std=c11",
      ]
    } else {
      cflags = [ "/arch:AVX512" ]
    }
    visibility = [ ":skcms" ]
  }
} else {
  skia_source_set("skcms_TransformHsw") {
    sources = []
    visibility = [ ":skcms" ]
  }
  skia_source_set("skcms_TransformSkx") {
    sources = []
    visibility = [ ":skcms" ]
  }
}

source_set("skcms_TransformBaseline_and_public") {
  if (!is_win || is_clang) {
    cflags = [
      "-w",
      "-std=c11",
    ]
  } else {
    cflags = []
  }

  # LLVM automatically sets the equivalent of GCC's -mfp16-format=ieee on ARM
  # builds by default, while GCC itself does not. We need it to enable support
  # for half-precision floating point data types used by SKCMS on ARM.
  if ((is_linux || is_chromeos) && !is_clang && current_cpu == "arm") {
    cflags += [ "-mfp16-format=ieee" ]
  }
  if (current_cpu == "loong64") {
    cflags += [ "-mlsx" ]
  }

  sources = rebase_path(skcms_TransformBaseline + skcms_public,
                        ".",
                        "//third_party/skia/modules/skcms")
}

source_set("skcms") {
  deps = [
    ":skcms_TransformBaseline_and_public",
    ":skcms_TransformHsw",
    ":skcms_TransformSkx",
  ]
  public =
      rebase_path(skcms_public_headers, ".", "//third_party/skia/modules/skcms")
  include_dirs = [ "//third_party/skia/modules/skcms" ]
}

# Split out Graphite sources because of conflicting file names with Ganesh.
# Split into separate private and public source sets because we want to allow
# shared GPU code in ":skia" to include private Graphite headers, but want to
# limit external code to only depend on public headers. Only define these source
# sets when skia_support_gpu is true so that on iOS non-Blink builds, headers in
# these source sets are considered unknown and skipped by gn check.
if (skia_support_gpu) {
  skia_source_set("skia_graphite_public") {
    public = skia_graphite_public + skia_graphite_precompile_public
    if (skia_use_dawn) {
      public += skia_graphite_dawn_public
      public_deps = [
        "//third_party/dawn/include/dawn:cpp_headers",
        "//third_party/dawn/src/dawn:proc",
      ]
    }
    if (skia_use_metal) {
      public += skia_graphite_mtl_public
      frameworks = [ "Metal.framework" ]
    }
    deps = [ "//gpu/config:workaround_list" ]
  }

  # If a source set contains only sources and no public files, then dependents can
  # include any file from sources.
  skia_source_set("skia_graphite_private") {
    sources = skia_graphite_sources + skia_graphite_precompile_sources +
              skia_sksl_graphite_modules_sources
    if (skia_use_dawn) {
      sources += skia_graphite_dawn_sources
    }
    if (skia_use_metal) {
      sources += skia_shared_mtl_sources
      sources += skia_graphite_mtl_sources
    }
    deps = [ "//gpu/config:workaround_list" ]
    if (skia_use_dawn) {
      deps += [ "//third_party/dawn/include/dawn:cpp_headers" ]
    }
    visibility = [ ":skia" ]
  }

  if (skia_use_metal) {
    # Split out Ganesh Metal sources, because they require ARC.
    skia_source_set("skia_ganesh_metal") {
      sources = skia_gpu_metal_public
      sources += skia_gpu_metal_private
      cflags_objcc = [
        "-Wno-unguarded-availability",
        "-fobjc-arc",
      ]
      deps = [ "//gpu/config:workaround_list" ]
      if (skia_use_dawn) {
        # Needed due to include chain containing webgpu_cpp.h via GrDawnTypes.h.
        public_deps = [ "//third_party/dawn/include/dawn:cpp_headers" ]
      }
      visibility = [ ":skia" ]
    }
  }
}

# Font copies.
if (is_fuchsia) {
  copy("copy_fuchsia_fonts_manifest") {
    sources = [ "ext/data/test_fonts/fuchsia_test_fonts_manifest.json" ]
    outputs = [ "$root_out_dir/test_fonts/all.font_manifest.json" ]
  }
}
if (is_apple) {
  bundle_data("test_fonts_bundle_data") {
    public_deps = [ "//third_party/test_fonts" ]

    sources = [
      "$root_out_dir/test_fonts/Ahem.ttf",
      "ext/data/test_fonts/ChromiumAATTest.ttf",
    ]

    outputs = [ "{{bundle_resources_dir}}/{{source_file_part}}" ]
  }
}

group("test_fonts_resources") {
  testonly = true
  deps = []
  data_deps = []

  if (is_apple) {
    deps += [ ":test_fonts_bundle_data" ]
    data_deps += [ ":test_fonts_bundle_data" ]
  } else if (false) {
    deps += [ "//third_party/test_fonts" ]
    data_deps += [ "//third_party/test_fonts" ]
  }

  if (is_fuchsia) {
    deps += [ ":copy_fuchsia_fonts_manifest" ]
    data_deps += [ ":copy_fuchsia_fonts_manifest" ]
  }
}

# Fuchsia components that use the test fonts must include
# "//build/config/fuchsia/test/test_fonts.shard.test-cml" in their
# `additional_manifest_fragments`.
source_set("test_fonts") {
  testonly = true

  deps = [ ":test_fonts_resources" ]

  if (is_fuchsia) {
    public = [
      "ext/test_fonts.h",
      "ext/test_fonts_fuchsia.h",
    ]
    sources = [
      "ext/test_fonts_fuchsia.cc",
      "ext/test_fonts_fuchsia_cfv2.cc",
    ]
    public_deps = [
      "//third_party/fuchsia-sdk/sdk/fidl/fuchsia.fonts:fuchsia.fonts_hlcpp",
    ]
    deps += [
      "//base",
      "//skia",
      "//third_party/fuchsia-sdk/sdk/pkg/sys_cpp",
    ]
  }
  if (is_apple) {
    public = [ "ext/test_fonts.h" ]
    sources = [ "ext/test_fonts_mac.mm" ]
    deps += [ "//base" ]
  }
}

test("skia_unittests") {
  sources = [
    "ext/codec_utils_unittest.cc",
    "ext/convolver_unittest.cc",
    "ext/geometry_unittest.cc",
    "ext/image_operations_unittest.cc",
    "ext/platform_canvas_unittest.cc",
    "ext/recursive_gaussian_convolution_unittest.cc",
    "ext/skcolorspace_primaries_unittest.cc",
    "ext/skcolorspace_trfn_unittest.cc",
    "ext/skia_memory_dump_provider_unittest.cc",
    "ext/skia_utils_base_unittest.cc",
  ]
  if (is_ios) {
    sources += [ "ext/skia_utils_ios_unittest.mm" ]
  }
  if (is_mac) {
    sources += [ "ext/skia_utils_mac_unittest.mm" ]
  }

  if (!is_win) {
    sources -= [ "ext/platform_canvas_unittest.cc" ]
  }

  deps = [
    ":skcms",
    ":skia",
    ":test_fonts",
    "//base",
    "//base/test:test_support",
    "//mojo/core/test:run_all_unittests",
    "//testing/gtest",
    "//ui/gfx",
    "//ui/gfx/geometry",
  ]

  data_deps = [ "//testing/buildbot/filters:skia_unittests_filters" ]

  if (!is_ios) {
    sources += [ "public/mojom/test/mojom_traits_unittest.cc" ]
    deps += [
      "//mojo/public/cpp/bindings",
      "//mojo/public/cpp/test_support:test_utils",
      "//skia/public/mojom",
    ]
  }

  if (is_fuchsia) {
    sources += [ "ext/fontmgr_fuchsia_unittest.cc" ]
    deps += [
      "//third_party/fuchsia-sdk/sdk/fidl/fuchsia.fonts:fuchsia.fonts_hlcpp",
    ]
    additional_manifest_fragments =
        [ "//build/config/fuchsia/test/test_fonts.shard.test-cml" ]
  }

  if (skia_support_skottie) {
    sources += [ "ext/skottie_unittest.cc" ]
  }
}

if (!is_ios) {
  executable("image_operations_bench") {
    sources = [ "ext/image_operations_bench.cc" ]

    deps = [
      ":skia",
      "//base",
      "//build/win:default_exe_manifest",
    ]
  }

  executable("filter_fuzz_stub") {
    testonly = true
    sources = [ "tools/filter_fuzz_stub/filter_fuzz_stub.cc" ]

    deps = [
      ":skia",
      "//base",
      "//base/test:test_support",
      "//build/win:default_exe_manifest",
    ]
  }
}

fuzzer_test("image_operations_resize_fuzzer") {
  sources = [ "ext/image_operations_resize_fuzzer.cc" ]

  deps = [
    ":skia",
    "//base",
  ]

  libfuzzer_options = [ "max_len=48" ]
}

group("fuzzers") {
  deps = [ "//skia/tools/fuzzers" ]
}