kc3-lang/angle/BUILD.gn

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Shahbaz Youssefi
  Date : 2018-10-25 12:48:49
  Hash : 749589f8
  Message : Vulkan: Remaining disjoint timer query functions The following features where missing in c2b576d9e: - glGetIntegerv with GL_GPU_DISJOINT_EXT: this is currently impossible to query in Vulkan, so 0 is always returned. - glGetIntegerv with GL_TIMESTAMP_EXT: this is a way to query GPU timestamp without performing flushes or waiting for the GPU to finish. There is no direct correspondance in Vulkan; it's implemented by making a small submission, with no dependency to other submissions, in which there is only a timestamp query. Bug: angleproject:2885 Change-Id: I2341bd610db9084c26b6421c6f8949950ffa4de8 Reviewed-on: https://chromium-review.googlesource.com/c/1299873 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org>

• 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")
  }
  
  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/libGLESv2.gni")
  import("src/compiler.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" ]
      }
    }
  }
  
  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" ]
  }
  
  if (is_win) {
    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) {
      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 = []
    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 (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" ]
    }
  
    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 (ndk_supports_nativewindow) {
          libs += [ "nativewindow" ]
        } else {
          libs += [ "android" ]
        }
        libs += [ "log" ]
      }
      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" ]
  
    if (is_win) {
      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",
    ]
  }
  
  if (is_android) {
    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}") {
      configs -= [ "//build/config/android:hide_all_but_jni_onload" ]
      configs += [ ":build_id_config" ]
      configs -= angle_undefine_configs
      configs += [
        ":internal_config",
        ":extra_warnings",
      ]
  
      public_configs = [
        ":angle_feature_support_config",
        "third_party/jsoncpp:jsoncpp_config",
      ]
  
      libs = [ "log" ]
  
      sources = [
        "src/feature_support_util/angle_feature_support_util.h",
        "src/feature_support_util/feature_support_util.cpp",
        "src/feature_support_util/feature_support_util.h",
      ]
      deps = [
        "third_party/jsoncpp:jsoncpp",
      ]
    }
  
    # Package ANGLE libraries for pre-installed system image
    android_assets("angle_apk_assets") {
      disable_compression = true
      sources = [
        "src/feature_support_util/a4a_rules.json",
      ]
    }
    android_apk("angle_apk") {
      deps = [
        ":angle_apk_assets",
      ]
      if (build_apk_secondary_abi && android_64bit_target_cpu) {
        secondary_abi_shared_libraries = [
          "//third_party/angle:libEGL${angle_libs_suffix}($android_secondary_abi_toolchain)",
          "//third_party/angle:libGLESv1_CM${angle_libs_suffix}($android_secondary_abi_toolchain)",
          "//third_party/angle:libGLESv2${angle_libs_suffix}($android_secondary_abi_toolchain)",
          "//third_party/angle:libfeature_support${angle_libs_suffix}($android_secondary_abi_toolchain)",
        ]
      }
  
      android_manifest = "AndroidManifest.xml"
  
      apk_name = "ANGLEPrebuilt"
      uncompress_shared_libraries = true
      shared_libraries = [
        "//third_party/angle:libEGL${angle_libs_suffix}",
        "//third_party/angle:libGLESv1_CM${angle_libs_suffix}",
        "//third_party/angle:libGLESv2${angle_libs_suffix}",
        "//third_party/angle:libfeature_support${angle_libs_suffix}",
      ]
    }
  }