angle/BUILD.gn

# Copyright 2019 The ANGLE Project Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# import the use_x11 variable
import("//build/config/dcheck_always_on.gni")
import("//build/config/linux/pkg_config.gni")
import("//build/config/ui.gni")
import("//testing/libfuzzer/fuzzer_test.gni")
import("gni/angle.gni")
if (is_android) {
  # android/rules.gni can only be imported for Android targets
  import("//build/config/android/config.gni")
  import("//build/config/android/rules.gni")
  import("android/angle_apk.gni")
}

declare_args() {
  # Use the PCI lib to collect GPU information on Linux.
  use_libpci = is_linux && (!is_chromecast || is_cast_desktop_build) &&
               (use_x11 || use_ozone)

  # Link in system libGL, to work with apitrace.  See doc/DebuggingTips.md.
  angle_link_glx = false
}

if (!build_with_chromium) {
  group("all") {
    testonly = true
    deps = [
      ":angle_shader_translator",
      ":translator_fuzzer",
      ":xxhash_fuzzer",
      "//samples:all",
      "//src/tests:all",
    ]
  }
}

if (ozone_platform_gbm) {
  pkg_config("libdrm") {
    packages = [ "libdrm" ]
  }
}

angle_git_is_present = exec_script("src/commit_id.py",
                                   [
                                     "check",
                                     rebase_path(".", root_build_dir),
                                   ],
                                   "value")

angle_use_commit_id = angle_git_is_present == 1

import("src/compiler.gni")
import("src/libGLESv2.gni")

# This config is exported to dependent targets (and also applied to internal
# ones).
config("external_config") {
  include_dirs = [ "include" ]
}

# Prevent the GL headers from redeclaring ANGLE entry points.
config("no_gl_prototypes") {
  defines = [
    "GL_GLES_PROTOTYPES=0",
    "EGL_EGL_PROTOTYPES=0",
  ]
}

config("gl_prototypes") {
  defines = [
    "GL_GLES_PROTOTYPES=1",
    "EGL_EGL_PROTOTYPES=1",
    "GL_GLEXT_PROTOTYPES",
    "EGL_EGLEXT_PROTOTYPES",
  ]
}

# This config is applied to internal Angle targets (not pushed to dependents).
config("internal_config") {
  include_dirs = [
    "include",
    "src",
  ]

  defines = []

  if (angle_64bit_current_cpu) {
    defines += [ "ANGLE_IS_64_BIT_CPU" ]
  } else {
    defines += [ "ANGLE_IS_32_BIT_CPU" ]
  }

  if (angle_force_thread_safety) {
    defines += [ "ANGLE_FORCE_THREAD_SAFETY=1" ]
  }

  if (angle_enable_vulkan) {
    if (angle_enable_vulkan_gpu_trace_events) {
      defines += [ "ANGLE_ENABLE_VULKAN_GPU_TRACE_EVENTS=1" ]
    }
    if (angle_vulkan_conformant_configs_only) {
      defines += [ "ANGLE_VULKAN_CONFORMANT_CONFIGS_ONLY=1" ]
    }
  }

  if (angle_enable_trace) {
    defines += [ "ANGLE_ENABLE_DEBUG_TRACE=1" ]
  }
}

config("extra_warnings") {
  cflags = []

  # Enable more default warnings on Windows.
  if (is_win) {
    cflags += [
      "/we4244",  # Conversion: possible loss of data.
      "/we4456",  # Variable shadowing.
      "/we4458",  # declaration hides class member.
      "/we4715",  # not all control paths return a value
      "/we4800",  # forcing value to bool.
      "/we4838",  # narrowing conversion.
    ]
  }
  if (is_clang) {
    cflags += [
      # Enable after anglebug.com/3128 is fixed.
      # "-Wextra-semi-stmt",

      "-Wnon-virtual-dtor",
      "-Wunneeded-internal-declaration",
    ]
  }
}

# This config adds build-ids to the associated library.
# -Wl is a special option that indicates that clang should pass the associated
# option --build-id to the linker. This will cause a build-id section to be added
# to the associated library. The build-id makes it possible for a debugger to
# find the right symbol file to use.
config("build_id_config") {
  ldflags = [ "-Wl,--build-id" ]
}

# Windows ARM64 is available since 10.0.16299 so no need to copy
# d3dcompiler_47.dll because this file is available as inbox.
if (is_win && target_cpu != "arm64") {
  # We also ship an older DLL for compatiblity with Windows 7 machines without
  # the UCRT. This DLL isn't available in the standard SDK distribution.
  _old_compiler = "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_old.dll"
  _has_old_compiler =
      exec_script("scripts/file_exists.py", [ _old_compiler ], "value")

  copy("copy_compiler_dll") {
    sources = [
      "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_47.dll",
    ]

    if (_has_old_compiler) {
      sources += [ _old_compiler ]
    }

    outputs = [
      "$root_out_dir/{{source_file_part}}",
    ]
  }
}

# Holds the shared includes so we only need to list them once.
config("includes_config") {
  include_dirs = [ "include" ]
}

angle_source_set("includes") {
  sources = libangle_includes
  public_configs = [ ":includes_config" ]
}

angle_static_library("preprocessor") {
  sources = angle_preprocessor_sources

  public_deps = [
    ":angle_common",
  ]
}

config("angle_disable_pool_alloc") {
  defines = [ "ANGLE_DISABLE_POOL_ALLOC" ]
}

config("debug_annotations_config") {
  if (is_debug) {
    defines = [ "ANGLE_ENABLE_DEBUG_ANNOTATIONS" ]
  }
}

config("angle_release_asserts_config") {
  if (dcheck_always_on) {
    defines = [ "ANGLE_ENABLE_RELEASE_ASSERTS" ]
  }
}

config("angle_common_config") {
  include_dirs = [ "src/common/third_party/base" ]
  if (is_android) {
    libs = [ "log" ]
  }
}

angle_source_set("angle_system_utils") {
  sources = angle_system_utils_sources
}

angle_source_set("xxhash") {
  sources = xxhash_sources
  configs -= [ "${angle_root}:extra_warnings" ]
}

fuzzer_test("xxhash_fuzzer") {
  sources = [
    "src/common/third_party/xxhash/xxhash_fuzzer.cpp",
  ]
  deps = [
    ":xxhash",
  ]
}

angle_static_library("angle_common") {
  sources = libangle_common_sources

  configs += [
    ":angle_common_config",
    ":debug_annotations_config",
  ]

  deps = [
    ":xxhash",
  ]

  public_deps = [
    ":angle_system_utils",
    ":angle_version",
    ":includes",
  ]
  public_configs += [ ":angle_common_config" ]
  all_dependent_configs = [ ":angle_release_asserts_config" ]
  if (use_fuzzing_engine) {
    all_dependent_configs += [ ":angle_disable_pool_alloc" ]
  }
}

config("angle_image_util_config") {
  include_dirs = [
    "include",
    "src",
  ]
}

angle_static_library("angle_image_util") {
  sources = libangle_image_util_sources
  public_configs += [ ":angle_image_util_config" ]
  public_deps = [
    ":angle_common",
  ]
}

config("angle_gl_visibility_config") {
  if (is_win) {
    defines = [
      "GL_APICALL=",
      "GL_API=",
    ]
  } else {
    defines = [
      "GL_APICALL=__attribute__((visibility(\"default\")))",
      "GL_API=__attribute__((visibility(\"default\")))",
    ]
  }
}

config("angle_gpu_info_util_config") {
  include_dirs = [
    "include",
    "src",
  ]
}

angle_static_library("angle_gpu_info_util") {
  public_configs += [ ":angle_gpu_info_util_config" ]
  public_deps = [
    ":angle_common",
  ]
  sources = libangle_gpu_info_util_sources
  deps = []
  libs = []
  defines = []

  if (is_android) {
    sources += [ "src/gpu_info_util/SystemInfo_android.cpp" ]
  }

  if (is_win) {
    sources += libangle_gpu_info_util_win_sources
    libs += [ "setupapi.lib" ]
    defines += [ "GPU_INFO_USE_SETUPAPI" ]
  }

  if (is_linux || is_fuchsia) {
    sources += libangle_gpu_info_util_linux_sources

    if (use_x11) {
      sources += libangle_gpu_info_util_x11_sources
      deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
      defines += [ "GPU_INFO_USE_X11" ]
      libs += [
        "X11",
        "Xi",
        "Xext",
      ]
    }
  }

  if (use_libpci) {
    sources += libangle_gpu_info_util_libpci_sources
    defines += [ "GPU_INFO_USE_LIBPCI" ]
    libs += [ "pci" ]
  }

  if (is_mac) {
    sources += libangle_gpu_info_util_mac_sources
    libs += [
      "IOKit.framework",
      "CoreFoundation.framework",
      "CoreGraphics.framework",
    ]
  }
}

angle_static_library("translator") {
  sources = angle_translator_sources
  defines = []

  if (angle_enable_essl || use_fuzzing_engine) {
    sources += angle_translator_essl_sources
    defines += [ "ANGLE_ENABLE_ESSL" ]
  }

  if (angle_enable_glsl || use_fuzzing_engine) {
    sources += angle_translator_glsl_sources
    defines += [ "ANGLE_ENABLE_GLSL" ]
  }

  if (angle_enable_hlsl || use_fuzzing_engine) {
    sources += angle_translator_hlsl_sources
    defines += [ "ANGLE_ENABLE_HLSL" ]
  }

  if (angle_enable_vulkan || use_fuzzing_engine) {
    sources += angle_translator_lib_vulkan_sources
    defines += [ "ANGLE_ENABLE_VULKAN" ]
  }

  public_configs += [ ":external_config" ]

  deps = [
    ":includes",
    ":preprocessor",
  ]

  public_deps = [
    ":angle_common",
  ]

  if (is_win) {
    # Necessary to suppress some system header xtree warnigns in Release.
    # For some reason this warning doesn't get triggered in Chromium
    cflags = [ "/wd4718" ]
  }
}

angle_source_set("translator_fuzzer") {
  sources = [
    "src/compiler/fuzz/translator_fuzzer.cpp",
  ]

  include_dirs = [
    "include",
    "src",
  ]

  deps = [
    ":translator",
  ]
}

config("commit_id_config") {
  include_dirs = [ "$root_gen_dir/angle" ]
  visibility = [ ":commit_id" ]
}

commit_id_output_file = "$root_gen_dir/angle/id/commit.h"
if (angle_use_commit_id) {
  action("commit_id") {
    script = "src/commit_id.py"
    outputs = [
      commit_id_output_file,
    ]

    # commit id should depend on angle's HEAD revision
    inputs = [
      ".git/HEAD",
    ]

    args = [
      "gen",
      rebase_path(".", root_build_dir),
      rebase_path(commit_id_output_file, root_build_dir),
    ]

    public_configs = [ ":commit_id_config" ]
  }
} else {
  copy("commit_id") {
    sources = [
      "src/commit.h",
    ]
    outputs = [
      commit_id_output_file,
    ]
    public_configs = [ ":commit_id_config" ]
  }
}

angle_source_set("angle_version") {
  sources = [
    "src/common/version.h",
  ]
  public_deps = [
    ":commit_id",
  ]
}

config("libANGLE_config") {
  cflags = []
  defines = []
  libs = []
  ldflags = []
  if (angle_enable_d3d9) {
    defines += [ "ANGLE_ENABLE_D3D9" ]
    ldflags += [ "/DELAYLOAD:d3d9.dll" ]
  }
  if (angle_enable_d3d11) {
    defines += [ "ANGLE_ENABLE_D3D11" ]
  }
  if (angle_enable_gl) {
    defines += [ "ANGLE_ENABLE_OPENGL" ]
    if (use_x11) {
      defines += [ "ANGLE_USE_X11" ]
    }
    if (angle_enable_gl_null) {
      defines += [ "ANGLE_ENABLE_OPENGL_NULL" ]
    }
  }
  if (angle_enable_vulkan) {
    defines += [ "ANGLE_ENABLE_VULKAN" ]
    if (angle_enable_custom_vulkan_cmd_buffers) {
      defines += [ "ANGLE_USE_CUSTOM_VULKAN_CMD_BUFFERS=1" ]
    }
  }
  if (angle_enable_null) {
    defines += [ "ANGLE_ENABLE_NULL" ]
  }
  defines += [ "LIBANGLE_IMPLEMENTATION" ]

  if (is_win) {
    cflags += [ "/wd4530" ]  # C++ exception handler used, but unwind semantics are not enabled.
  }

  if (is_android && (angle_enable_gl || angle_enable_vulkan)) {
    # In API level 26 ANativeWindow APIs were moved from libandroid.so
    # into a separate library, libnativewindow.so
    if (ndk_api_level_at_least_26) {
      libs += [ "nativewindow" ]
    } else {
      libs += [ "android" ]
    }
  }
}

if (angle_enable_vulkan) {
  config("vulkan_config") {
    if (is_android) {
      libs = [ "vulkan" ]
    }
  }

  # Use this target to include everything ANGLE needs for Vulkan.
  group("angle_vulkan") {
    public_deps = [
      "$angle_root/third_party/vulkan-headers:vulkan_headers",
    ]
    public_configs = [ ":vulkan_config" ]
    data_deps = []
    if (!is_android && !is_fuchsia) {
      deps = [
        "$angle_root/third_party/vulkan-loader:libvulkan",
      ]
      data_deps += [ "$angle_root/third_party/vulkan-tools:VkICD_mock_icd" ]
      public_configs +=
          [ "$angle_root/third_party/vulkan-loader:vulkan_loader_config" ]
    }
    if (is_fuchsia) {
      public_deps += [
        "$angle_root/src/common/fuchsia_egl",
        "//third_party/fuchsia-sdk:vulkan_base",
        "//third_party/fuchsia-sdk/sdk:vulkan",
      ]
    }

    if (angle_enable_vulkan_validation_layers) {
      if (is_fuchsia) {
        deps = [
          "//third_party/fuchsia-sdk:vulkan_validation",
        ]
      } else {
        data_deps += [ "$angle_root/third_party/vulkan-validation-layers:vulkan_validation_layers" ]
        if (!is_android) {
          data_deps += [ "$angle_root/third_party/vulkan-validation-layers:vulkan_gen_json_files" ]
        }
      }
    }
  }
}

angle_static_library("libANGLE") {
  sources = libangle_sources

  include_dirs = []
  libs = []
  defines = []
  if (angle_link_glx) {
    libs += [ "GL" ]
    defines += [ "ANGLE_LINK_GLX" ]
  }
  public_deps = [
    ":angle_common",
    ":angle_gpu_info_util",
    ":angle_version",
    ":translator",
  ]
  deps = [
    ":angle_image_util",
    ":includes",
  ]

  # Enable extra Chromium style warnings for libANGLE.
  if (is_clang) {
    suppressed_configs -= [ "//build/config/clang:find_bad_constructs" ]
  }

  # Shared D3D sources.
  if (angle_enable_d3d9 || angle_enable_d3d11) {
    sources += libangle_d3d_shared_sources

    defines += [ "ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES={ " + "\"d3dcompiler_47.dll\", \"d3dcompiler_46.dll\", \"d3dcompiler_43.dll\" }" ]
  }

  if (angle_enable_d3d9) {
    sources += libangle_d3d9_sources
    libs += [ "d3d9.lib" ]
  }

  if (angle_enable_d3d11) {
    sources += libangle_d3d11_sources
    sources += libangle_d3d11_win32_sources
    libs += [ "dxguid.lib" ]
    import("src/libANGLE/renderer/d3d/d3d11/d3d11_blit_shaders_autogen.gni")
    sources += libangle_d3d11_blit_shaders
  }

  if (angle_enable_gl) {
    sources += libangle_gl_sources
    include_dirs += [ "src/third_party/khronos" ]

    if (angle_enable_gl_null) {
      sources += libangle_gl_null_sources
    }
    if (is_win) {
      sources += libangle_gl_wgl_sources
    }
    if (use_x11) {
      sources += libangle_gl_glx_sources
      deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
      libs += [
        "X11",
        "Xi",
        "Xext",
      ]
    }
    if (is_mac) {
      sources += libangle_gl_cgl_sources
      libs += [
        "Cocoa.framework",
        "IOSurface.framework",
        "OpenGL.framework",
        "QuartzCore.framework",
      ]
    }
    if (is_android) {
      sources += libangle_gl_egl_sources
      sources += libangle_gl_egl_dl_sources
      sources += libangle_gl_egl_android_sources
    }
    if (ozone_platform_gbm) {
      configs += [ ":libdrm" ]
      defines += [ "ANGLE_USE_OZONE" ]
      deps += [ "//third_party/minigbm" ]
      sources += libangle_gl_egl_sources
      sources += libangle_gl_egl_dl_sources
      sources += libangle_gl_ozone_sources
    }
  }

  if (angle_enable_vulkan) {
    sources += libangle_vulkan_sources
    if (is_win) {
      sources += libangle_vulkan_win32_sources
    }
    if (is_linux) {
      sources += libangle_vulkan_xcb_sources
    }
    if (is_fuchsia) {
      sources += libangle_vulkan_fuchsia_sources
      deps += [
        "$angle_root/src/common/fuchsia_egl",
        "$angle_root/src/common/fuchsia_egl:backend",
      ]
    }
    if (is_android) {
      sources += libangle_vulkan_android_sources
      libs += [ "vulkan" ]
    }
    deps += [
      ":angle_vulkan",
      "${angle_glslang_dir}:glslang_default_resource_limits_sources",
      "${angle_glslang_dir}:glslang_sources",
      "${angle_spirv_tools_dir}:spvtools_val",
    ]
    public_deps += [ "$angle_root/third_party/vulkan-headers:vulkan_headers" ]

    # Include generated shaders.
    import("src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.gni")
    sources += angle_vulkan_internal_shaders
  }

  if (angle_enable_null) {
    sources += libangle_null_sources
  }

  if (is_debug) {
    defines += [ "ANGLE_GENERATE_SHADER_DEBUG_INFO" ]
  }

  configs += [ ":debug_annotations_config" ]
  public_configs += [ ":libANGLE_config" ]

  # Windows ARM64 is available since 10.0.16299 so no need to copy
  # d3dcompiler_47.dll because this file is available as inbox.
  if (is_win && target_cpu != "arm64") {
    data_deps = [
      ":copy_compiler_dll",
    ]
  }
}

config("shared_library_public_config") {
  if (is_mac && !is_component_build) {
    # Executable targets that depend on the shared libraries below need to have
    # the rpath setup in non-component build configurations.
    ldflags = [
      "-rpath",
      "@executable_path/",
    ]
  }
}

config("library_name_config") {
  defines = [
    "ANGLE_EGL_LIBRARY_NAME=\"libEGL${angle_libs_suffix}\"",
    "ANGLE_GLESV2_LIBRARY_NAME=\"libGLESv2${angle_libs_suffix}\"",
  ]
}

# This config controls export definitions on ANGLE API calls.
config("angle_static") {
  defines = [
    "ANGLE_EXPORT=",
    "ANGLE_UTIL_EXPORT=",
    "EGLAPI=",
    "GL_APICALL=",
    "GL_API=",
  ]
}

angle_shared_library("libGLESv2${angle_libs_suffix}") {
  sources = libglesv2_sources

  if (is_win) {
    sources += [ "src/libGLESv2/libGLESv2_autogen.def" ]
  }

  configs += [
    ":angle_gl_visibility_config",
    ":debug_annotations_config",
    ":gl_prototypes",
  ]

  defines = [ "LIBGLESV2_IMPLEMENTATION" ]

  deps = [
    ":includes",
    ":libANGLE",
  ]

  public_deps = [
    ":angle_version",
  ]
}

angle_static_library("libGLESv2_static") {
  sources = libglesv2_sources
  configs += [ ":debug_annotations_config" ]
  public_configs += [ ":angle_static" ]
  deps = [
    ":includes",
  ]
  public_deps = [
    ":libANGLE",
  ]
}

angle_shared_library("libGLESv1_CM${angle_libs_suffix}") {
  sources = libglesv1_cm_sources

  configs += [
    ":angle_gl_visibility_config",
    ":debug_annotations_config",
    ":gl_prototypes",
  ]

  defines = []

  deps = [
    ":includes",
    ":libGLESv2${angle_libs_suffix}",
  ]
}

angle_static_library("libGLESv1_CM_static") {
  sources = libglesv1_cm_sources
  configs += [ ":debug_annotations_config" ]
  public_configs += [ ":angle_static" ]
  deps = [
    ":includes",
    ":libGLESv2_static",
  ]
}

config("libEGL_egl_loader_config") {
  defines = [ "ANGLE_USE_EGL_LOADER" ]
}

angle_source_set("libEGL_egl_loader") {
  sources = [
    "src/libEGL/egl_loader_autogen.cpp",
    "src/libEGL/egl_loader_autogen.h",
  ]

  public_configs += [
    ":libEGL_egl_loader_config",
    ":gl_prototypes",
  ]

  deps = [
    ":includes",
  ]
}

angle_shared_library("libEGL${angle_libs_suffix}") {
  sources = libegl_sources

  configs += [
    ":debug_annotations_config",
    ":library_name_config",
  ]

  defines = [ "LIBEGL_IMPLEMENTATION" ]
  if (is_win) {
    defines += [ "EGLAPI=" ]
  } else {
    defines += [ "EGLAPI=__attribute__((visibility(\"default\")))" ]
  }

  if (is_win) {
    sources += [ "src/libEGL/libEGL.def" ]
  }

  deps = [
    ":angle_system_utils",
    ":angle_version",
    ":libEGL_egl_loader",
  ]

  public_deps = [
    ":includes",
  ]

  data_deps = [
    ":libGLESv2${angle_libs_suffix}",
  ]
}

angle_static_library("libEGL_static") {
  sources = libegl_sources

  configs += [
    ":debug_annotations_config",
    ":library_name_config",
  ]

  public_configs += [ ":angle_static" ]

  deps = [
    ":includes",
    ":libGLESv2_static",
  ]
}

import("util/util.gni")

config("angle_util_loader_config") {
  defines = [ "ANGLE_USE_UTIL_LOADER" ]
}

angle_source_set("angle_util_loader_headers") {
  sources = [
    "util/egl_loader_autogen.h",
    "util/gles_loader_autogen.h",
    "util/util_export.h",
  ]

  if (is_win) {
    sources += [ "util/windows/wgl_loader_autogen.h" ]
  }

  public_deps = [
    ":includes",
  ]
}

angle_source_set("angle_util_loader") {
  defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]

  sources = [
    "util/egl_loader_autogen.cpp",
    "util/gles_loader_autogen.cpp",
  ]

  if (is_win) {
    sources += [ "util/windows/wgl_loader_autogen.cpp" ]
  }

  deps = [
    ":angle_util_loader_headers",
  ]

  public_configs += [
    ":angle_util_config",
    ":angle_util_loader_config",
    ":no_gl_prototypes",
  ]
}

config("angle_util_config") {
  include_dirs = [ "." ]
  if (is_linux && use_x11) {
    libs = [ "X11" ]
  }
}

foreach(is_shared_library,
        [
          true,
          false,
        ]) {
  if (is_shared_library) {
    library_type = "angle_shared_library"
    library_name = "angle_util"
    dep_suffix = "${angle_libs_suffix}"
  } else {
    library_type = "angle_static_library"
    library_name = "angle_util_static"
    dep_suffix = "_static"
  }

  target(library_type, library_name) {
    sources = util_sources

    if (is_win) {
      sources += util_win_sources
    }

    libs = []
    if (is_linux) {
      sources += util_linux_sources
      libs += [
        "rt",
        "dl",
      ]
    }

    if (is_mac) {
      sources += util_osx_sources
      libs += [
        "AppKit.framework",
        "QuartzCore.framework",
      ]
    }

    if (use_x11) {
      sources += util_x11_sources
    }

    if (is_android) {
      # To prevent linux sources filtering on android
      set_sources_assignment_filter([])
      sources += util_linux_sources
      sources += util_android_sources
      libs += [
        "android",
        "log",
      ]
    }

    configs += [ ":debug_annotations_config" ]

    public_configs += [ ":angle_util_config" ]

    deps = [
      ":angle_common",
      ":angle_util_loader_headers",
    ]

    public_deps = []
    if (is_fuchsia) {
      sources += util_fuchsia_sources
      public_deps += [
        "$angle_root/src/common/fuchsia_egl",
        "//third_party/fuchsia-sdk/sdk:async_loop_cpp",
        "//third_party/fuchsia-sdk/sdk:fdio",
        "//third_party/fuchsia-sdk/sdk:images",
        "//third_party/fuchsia-sdk/sdk:scenic_cpp",
        "//third_party/fuchsia-sdk/sdk:ui_policy",
        "//third_party/fuchsia-sdk/sdk:ui_scenic",
        "//third_party/fuchsia-sdk/sdk:ui_views",
      ]
    } else if (use_ozone) {
      sources += util_ozone_sources
    }

    if (is_shared_library) {
      defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]

      if (is_win) {
        sources += util_win_shared_sources
      }

      public_deps += [ ":angle_util_loader" ]

      if (is_mac && !is_component_build) {
        ldflags = [
          "-install_name",
          "@rpath/libangle_util.dylib",
        ]
      }
    } else {
      public_configs += [
        ":angle_static",
        ":gl_prototypes",
      ]
    }
  }
}

# Convenience targets for some of the samples so they can be built
# with Chromium's toolchain.

angle_executable("angle_shader_translator") {
  testonly = true

  sources = [
    "samples/shader_translator/shader_translator.cpp",
  ]

  deps = [
    ":translator",
  ]
}

config("angle_feature_support_config") {
  include_dirs = [
    "include",
    "src",
  ]
  defines = [ "LIBFEATURE_SUPPORT_IMPLEMENTATION" ]
  if (is_debug) {
    defines += [ "ANGLE_FEATURE_UTIL_LOG_VERBOSE" ]
  }
}

angle_shared_library("libfeature_support${angle_libs_suffix}") {
  if (is_android) {
    libs = [ "log" ]
  }

  public_configs += [
    ":angle_feature_support_config",
    "${angle_jsoncpp_dir}:jsoncpp_config",
  ]

  if (is_mac && !is_component_build) {
    ldflags = [
      "-install_name",
      "@rpath/${target_name}.dylib",
    ]
  }

  sources = [
    "src/feature_support_util/feature_support_util.cpp",
    "src/feature_support_util/feature_support_util.h",
  ]

  deps = [
    ":angle_gpu_info_util",
    "${angle_jsoncpp_dir}:jsoncpp",
  ]
}

if (!is_component_build && is_android && symbol_level != 0) {
  action_foreach("compressed_symbols") {
    sources = []
    foreach(_library, angle_libraries) {
      sources += [ "${root_out_dir}/lib${_library}${angle_libs_suffix}.so" ]
    }
    if (angle_enable_vulkan_validation_layers) {
      foreach(_layer, vulkan_validation_layers) {
        sources += [ "${root_out_dir}/lib${_layer}.so" ]
      }
    }

    script = rebase_path("${root_build_dir}/android/compress_symbols.py",
                         root_build_dir)

    deps = []
    foreach(_library, angle_libraries) {
      deps += [ "${angle_root}:lib${_library}${angle_libs_suffix}" ]
    }

    if (angle_enable_vulkan_validation_layers) {
      foreach(_layer, vulkan_validation_layers) {
        deps +=
            [ "${angle_root}/third_party/vulkan-validation-layers:${_layer}" ]
      }
    }

    outputs = [
      "$root_out_dir/lib.compressed/{{source_file_part}}",
    ]

    android_nm = "${android_tool_prefix}nm"

    args = [
      "--objcopy",
      rebase_path(android_objcopy, root_build_dir),
      "--nm",
      rebase_path(android_nm, root_build_dir),
      "--sofile",
      "{{source}}",
      "--unstrippedsofile",
      "{{source_dir}}/lib.unstripped/{{source_file_part}}",
      "--output",
      "{{source_dir}}/lib.compressed/{{source_file_part}}",
    ]
  }
}

if (!is_component_build && is_android &&
    current_toolchain == default_toolchain) {
  # Package ANGLE libraries for pre-installed system image
  angle_apk("aosp_apk") {
    package_name = "com.android.angle"
    apk_name = "AngleLibraries"
  }

  group("angle_apks") {
    deps = [
      ":aosp_apk",
    ]
  }

  # Include a temporary target until we update builders to use angle_apks
  group("angle_apk") {
    deps = [
      ":angle_apks",
    ]
  }
}