kc3-lang/angle/BUILD.gn

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Tim Van Patten
  Date : 2018-11-01 17:47:10
  Hash : fdccaa3a
  Message : Enhance ANGLE for Android Developer Options Update ANGLE Developer Options Update ANGLE developer options to allow selecting the OpenGL driver (default, ANGLE, native) for each app as well as forcing ANGLE for all apps. Bug: angleproject:2962 Test: Verify the default/ANGLE/native values are saved and applied and used by the loader. Change-Id: I6737b11bc061318cf8438c8161593ca70239590f Reviewed-on: https://chromium-review.googlesource.com/c/1354101 Reviewed-by: Yuly Novikov <ynovikov@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org> Commit-Queue: Tim Van Patten <timvp@google.com>

• BUILD.gn

• # Copyright 2014-2015 The Chromium 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/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",
        "//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" ]
  }
  
  # This config is applied to internal Angle targets (not pushed to dependents).
  config("internal_config") {
    include_dirs = [
      "include",
      "src",
    ]
  
    # Prevent the GL headers from redeclaring ANGLE entry points.
    defines = [
      "GL_GLEXT_PROTOTYPES",
      "EGL_EGLEXT_PROTOTYPES",
    ]
  
    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_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.
        "/we4800",  # forcing value to bool.
        "/we4838",  # narrowing conversion.
      ]
    }
    if (is_clang) {
      cflags += [
        # Remove when crbug.com/428099 is resolved.
        "-Winconsistent-missing-override",
        "-Wunneeded-internal-declaration",
        "-Wnon-virtual-dtor",
      ]
    }
  }
  
  # 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") {
    copy("copy_compiler_dll") {
      sources = [
        "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_47.dll",
      ]
      outputs = [
        "$root_out_dir/d3dcompiler_47.dll",
      ]
    }
  }
  
  angle_undefine_configs = [ "//build/config/compiler:default_include_dirs" ]
  
  # Holds the shared includes so we only need to list them once.
  source_set("includes") {
    sources = libangle_includes
  }
  
  static_library("preprocessor") {
    sources = angle_preprocessor_sources
  
    configs -= angle_undefine_configs
    configs += [
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_deps = [
      ":angle_common",
    ]
  }
  
  config("translator_disable_pool_alloc") {
    defines = [ "ANGLE_TRANSLATOR_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" ]
    }
  }
  
  static_library("angle_common") {
    sources = libangle_common_sources
  
    if (is_linux || is_android || is_fuchsia) {
      sources += libangle_common_linux_sources
    }
  
    if (is_mac) {
      sources += libangle_common_mac_sources
    }
  
    if (is_win) {
      sources += libangle_common_win_sources
    }
  
    configs -= angle_undefine_configs
    configs += [
      ":angle_common_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_deps = [
      ":commit_id",
      ":includes",
    ]
    public_configs = [ ":angle_common_config" ]
    all_dependent_configs = [ ":angle_release_asserts_config" ]
  }
  
  config("angle_image_util_config") {
    include_dirs = [
      "include",
      "src",
    ]
  }
  
  static_library("angle_image_util") {
    sources = libangle_image_util_sources
  
    configs -= angle_undefine_configs
    configs += [
      ":internal_config",
      ":extra_warnings",
    ]
  
    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",
    ]
  }
  
  static_library("angle_gpu_info_util") {
    configs -= angle_undefine_configs
    configs += [
      ":internal_config",
      ":extra_warnings",
    ]
  
    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",
      ]
    }
  }
  
  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" ]
    }
  
    configs -= angle_undefine_configs
    configs += [
      ":internal_config",
      ":extra_warnings",
    ]
    public_configs = [ ":external_config" ]
    if (use_fuzzing_engine) {
      all_dependent_configs = [ ":translator_disable_pool_alloc" ]
    }
  
    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" ]
    }
  }
  
  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" ]
  }
  
  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" ]
    }
  }
  
  config("libANGLE_config") {
    cflags = []
    defines = []
    libs = []
    if (angle_enable_d3d9) {
      defines += [ "ANGLE_ENABLE_D3D9" ]
    }
    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_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)) {
      if (ndk_supports_nativewindow) {
        libs += [ "nativewindow" ]
      } else {
        libs += [ "android" ]
      }
    }
  }
  
  if (angle_enable_vulkan) {
    # Use this target to include everything ANGLE needs for Vulkan.
    group("angle_vulkan") {
      deps = [
        "$angle_root/third_party/glslang:glslang",
      ]
      public_deps = [
        "$angle_root/third_party/vulkan-headers:vulkan_headers",
      ]
      public_configs = [
        "$angle_root/third_party/glslang:glslang_config",
        "$angle_root/third_party/vulkan-validation-layers:vulkan_config",
      ]
      data_deps = []
      if (!is_android) {
        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 (angle_enable_vulkan_validation_layers) {
        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" ]
        }
      }
    }
  }
  
  static_library("libANGLE") {
    sources = libangle_sources
  
    include_dirs = []
    libs = []
    defines = []
    if (angle_link_glx) {
      libs += [ "GL" ]
      defines += [ "ANGLE_LINK_GLX" ]
    }
    public_deps = [
      ":angle_common",
    ]
    deps = [
      ":angle_gpu_info_util",
      ":angle_image_util",
      ":commit_id",
      ":includes",
      ":translator",
    ]
  
    # 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_android) {
        sources += libangle_vulkan_android_sources
        libs += [ "vulkan" ]
      }
      deps += [ ":angle_vulkan" ]
      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 -= angle_undefine_configs
  
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_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/",
      ]
    }
  }
  
  # This config controls export definitions on ANGLE API calls.
  config("angle_static") {
    defines = [
      "ANGLE_EXPORT=",
      "EGLAPI=",
      "GL_APICALL=",
      "GL_API=",
    ]
  }
  
  shared_library("libGLESv2${angle_libs_suffix}") {
    sources = libglesv2_sources
  
    if (is_android) {
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
      configs += [ ":build_id_config" ]
    }
  
    if (is_win) {
      ldflags = [ "/DEF:" + rebase_path("src/libGLESv2/libGLESv2_autogen.def",
                                        root_build_dir) ]
    }
  
    if (is_mac && !is_component_build) {
      ldflags = [
        "-install_name",
        "@rpath/${target_name}.dylib",
      ]
      public_configs = [ ":shared_library_public_config" ]
    }
  
    configs -= angle_undefine_configs
    configs += [
      ":angle_gl_visibility_config",
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    defines = [ "LIBGLESV2_IMPLEMENTATION" ]
  
    deps = [
      ":includes",
      ":libANGLE",
    ]
  }
  
  static_library("libGLESv2_static") {
    sources = libglesv2_sources
  
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_configs = [ ":angle_static" ]
  
    deps = [
      ":includes",
      ":libANGLE",
    ]
  }
  
  shared_library("libGLESv1_CM${angle_libs_suffix}") {
    sources = libglesv1_cm_sources
  
    if (is_android) {
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
      configs += [ ":build_id_config" ]
    }
  
    if (is_mac && !is_component_build) {
      ldflags = [
        "-install_name",
        "@rpath/${target_name}.dylib",
      ]
      public_configs = [ ":shared_library_public_config" ]
    }
  
    configs -= angle_undefine_configs
    configs += [
      ":angle_gl_visibility_config",
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    defines = []
  
    deps = [
      ":includes",
      ":libGLESv2${angle_libs_suffix}",
    ]
  }
  
  static_library("libGLESv1_CM_static") {
    sources = libglesv1_cm_sources
  
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_configs = [ ":angle_static" ]
  
    deps = [
      ":includes",
      ":libGLESv2_static",
    ]
  }
  
  shared_library("libEGL${angle_libs_suffix}") {
    sources = libegl_sources
  
    if (is_android) {
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
      configs += [ ":build_id_config" ]
    }
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    defines = [ "LIBEGL_IMPLEMENTATION" ]
    if (is_win) {
      defines += [ "EGLAPI=" ]
    } else {
      defines += [ "EGLAPI=__attribute__((visibility(\"default\")))" ]
    }
  
    if (is_win) {
      ldflags = [ "/DEF:" + rebase_path("src/libEGL/libEGL.def", root_build_dir) ]
    }
  
    if (is_mac && !is_component_build) {
      ldflags = [
        "-install_name",
        "@rpath/${target_name}.dylib",
      ]
      public_configs = [ ":shared_library_public_config" ]
    }
  
    deps = [
      ":includes",
      ":libGLESv2${angle_libs_suffix}",
    ]
  }
  
  static_library("libEGL_static") {
    sources = libegl_sources
  
    configs -= angle_undefine_configs
    configs += [
      ":commit_id_config",
      ":debug_annotations_config",
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_configs = [ ":angle_static" ]
  
    deps = [
      ":includes",
      ":libGLESv2_static",
    ]
  }
  
  import("util/util.gni")
  
  config("angle_util_config") {
    include_dirs = [ "util" ]
    if (is_linux && use_x11) {
      libs = [ "X11" ]
    }
  }
  
  foreach(is_shared_library,
          [
            true,
            false,
          ]) {
    if (is_shared_library) {
      library_type = "shared_library"
      library_name = "angle_util"
      dep_suffix = "${angle_libs_suffix}"
    } else {
      library_type = "static_library"
      library_name = "angle_util_static"
      dep_suffix = "_static"
    }
  
    target(library_type, library_name) {
      sources = util_sources
  
      if (is_win) {
        sources += util_win32_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) {
        if (is_shared_library) {
          configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
        }
  
        # To prevent linux sources filtering on android
        set_sources_assignment_filter([])
        sources += util_linux_sources
        sources += util_android_sources
        libs += [
          "android",
          "log",
        ]
      }
  
      if (use_ozone) {
        sources += util_ozone_sources
      }
  
      configs += [
        ":debug_annotations_config",
        ":extra_warnings",
      ]
  
      public_configs = [
        ":angle_util_config",
        ":internal_config",
      ]
  
      deps = [
        ":angle_common",
        ":libEGL${dep_suffix}",
        ":libGLESv2${dep_suffix}",
      ]
  
      if (is_shared_library) {
        defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]
  
        if (is_mac && !is_component_build) {
          ldflags = [
            "-install_name",
            "@rpath/lib${target_name}.dylib",
          ]
          public_configs += [ ":shared_library_public_config" ]
        }
      }
    }
  }
  
  # Convenience targets for some of the samples so they can be built
  # with Chromium's toolchain.
  
  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" ]
    }
  }
  
  shared_library("libfeature_support${angle_libs_suffix}") {
    if (is_android) {
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
      configs += [ ":build_id_config" ]
      libs = [ "log" ]
    }
    configs -= angle_undefine_configs
    configs += [
      ":extra_warnings",
      ":internal_config",
    ]
  
    public_configs = [
      ":angle_feature_support_config",
      "third_party/jsoncpp:jsoncpp_config",
    ]
  
    if (is_mac && !is_component_build) {
      ldflags = [
        "-install_name",
        "@rpath/${target_name}.dylib",
      ]
      public_configs += [ ":shared_library_public_config" ]
    }
  
    sources = [
      "src/feature_support_util/feature_support_util.cpp",
      "src/feature_support_util/feature_support_util.h",
    ]
    deps = [
      ":angle_gpu_info_util",
      "third_party/jsoncpp:jsoncpp",
    ]
  }
  
  if (is_android) {
    # Package ANGLE libraries for pre-installed system image
    angle_apk("aosp_apk") {
      package_name = "com.android.angle"
      apk_name = "AngleAosp"
    }
  
    angle_apk("google_apk") {
      package_name = "com.google.android.angle"
      apk_name = "ANGLEPrebuilt"
    }
  
    group("angle_apks") {
      deps = [
        ":aosp_apk",
        ":google_apk",
      ]
    }
  
    # Include a temporary target until we update builders to use angle_apks
    group("angle_apk") {
      deps = [
        ":angle_apks",
      ]
    }
  }