BUILD.gn

# Copyright 2014 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("//build/config/features.gni")

assert(!is_android || enable_plugins,
       "//ppapi should not be referenced when is_android && !enable_plugins")

if (is_mac) {
  import("//build/config/mac/rules.gni")
}

copy("copy_test_files") {
  visibility = [ ":*" ]
  sources = [
    # Keep "test_case.html.mock-http-headers" with "test_case.html".
    "tests/ppapi_nacl_tests_newlib.nmf",
    "tests/test_case.html",
    "tests/test_case.html.mock-http-headers",
    "tests/test_page.css",
    "tests/test_page.css.mock-http-headers",
  ]
  outputs = [
    "$root_out_dir/{{source_file_part}}",
  ]
}

copy("copy_test_files2") {
  visibility = [ ":*" ]
  sources = [
    "tests/test_url_loader_data/hello.txt",
  ]
  outputs = [
    "$root_out_dir/test_url_loader_data/{{source_file_part}}",
  ]
}

import("//build/config/features.gni")
import("//build/config/nacl/config.gni")
import("//build/config/nacl/rules.gni")
import("//ppapi/ppapi_sources.gni")
import("//testing/test.gni")

source_set("ppapi_tests_sources") {
  sources = ppapi_sources.test_common_source_files +
            ppapi_sources.test_trusted_source_files

  configs += [
    "//build/config:precompiled_headers",
    "//v8:external_startup_data",
  ]

  defines = [ "GL_GLEXT_PROTOTYPES" ]
  include_dirs = [ "lib/gl/include" ]

  deps = [
    ":copy_test_files",
    ":copy_test_files2",
    "//build/config/sanitizers:deps",
    "//ppapi/cpp",
    "//ppapi/shared_impl",
  ]
}

if (!is_mac) {
  shared_library("ppapi_tests") {
    deps = [
      ":ppapi_tests_sources",
    ]
  }
} else {
  mac_plugin_bundle("ppapi_tests") {
    deps = [
      ":ppapi_tests_sources",
    ]
  }
}

source_set("power_saver_test_plugin_sources") {
  sources = [
    "tests/power_saver_test_plugin.cc",
    "tests/test_utils.cc",
  ]

  deps = [
    "//build/config/sanitizers:deps",
    "//ppapi/cpp",
    "//ppapi/shared_impl",
  ]
}

if (!is_mac) {
  shared_library("power_saver_test_plugin") {
    deps = [
      ":power_saver_test_plugin_sources",
    ]
  }
} else {
  mac_plugin_bundle("power_saver_test_plugin") {
    deps = [
      ":power_saver_test_plugin_sources",
    ]
  }
}

source_set("blink_deprecated_test_plugin_sources") {
  sources = [
    "tests/blink_deprecated_test_plugin.cc",
  ]

  deps = [
    "//base",
    "//build/config/sanitizers:deps",
    "//ppapi/cpp",
    "//ppapi/shared_impl",
  ]
}

if (!is_mac) {
  loadable_module("blink_deprecated_test_plugin") {
    deps = [
      ":blink_deprecated_test_plugin_sources",
    ]
  }
} else {
  mac_plugin_bundle("blink_deprecated_test_plugin") {
    deps = [
      ":blink_deprecated_test_plugin_sources",
    ]
  }
}

source_set("blink_test_plugin_sources") {
  sources = [
    "tests/blink_test_plugin.cc",
  ]

  deps = [
    "//base",
    "//build/config/sanitizers:deps",
    "//ppapi/cpp",
    "//ppapi/shared_impl",
  ]
}

if (!is_mac) {
  loadable_module("blink_test_plugin") {
    deps = [
      ":blink_test_plugin_sources",
    ]
  }
} else {
  mac_plugin_bundle("blink_test_plugin") {
    deps = [
      ":blink_test_plugin_sources",
    ]
  }
}

test("ppapi_unittests") {
  sources = [
    "host/resource_message_filter_unittest.cc",
    "proxy/device_enumeration_resource_helper_unittest.cc",
    "proxy/file_chooser_resource_unittest.cc",
    "proxy/file_system_resource_unittest.cc",
    "proxy/flash_resource_unittest.cc",
    "proxy/interface_list_unittest.cc",
    "proxy/mock_resource.cc",
    "proxy/mock_resource.h",
    "proxy/nacl_message_scanner_unittest.cc",
    "proxy/pdf_resource_unittest.cc",
    "proxy/plugin_dispatcher_unittest.cc",
    "proxy/plugin_resource_tracker_unittest.cc",
    "proxy/plugin_var_tracker_unittest.cc",
    "proxy/ppb_var_unittest.cc",
    "proxy/ppp_instance_private_proxy_unittest.cc",
    "proxy/ppp_instance_proxy_unittest.cc",
    "proxy/ppp_messaging_proxy_unittest.cc",
    "proxy/printing_resource_unittest.cc",
    "proxy/raw_var_data_unittest.cc",
    "proxy/serialized_var_unittest.cc",
    "proxy/tracked_callback_unittest.cc",
    "proxy/video_decoder_resource_unittest.cc",
    "proxy/video_encoder_resource_unittest.cc",
    "proxy/websocket_resource_unittest.cc",
    "shared_impl/media_stream_audio_track_shared_unittest.cc",
    "shared_impl/media_stream_buffer_manager_unittest.cc",
    "shared_impl/media_stream_video_track_shared_unittest.cc",
    "shared_impl/proxy_lock_unittest.cc",
    "shared_impl/resource_tracker_unittest.cc",
    "shared_impl/thread_aware_callback_unittest.cc",
    "shared_impl/time_conversion_unittest.cc",
    "shared_impl/var_tracker_unittest.cc",
  ]

  deps = [
    "//base/test:run_all_unittests",
    "//base/test:test_support",
    "//gpu/ipc/common:command_buffer_traits",
    "//ipc",
    "//ipc:test_support",
    "//media:shared_memory_support",
    "//ppapi/host",
    "//ppapi/proxy",
    "//ppapi/proxy:test_support",
    "//ppapi/shared_impl",
    "//ppapi/shared_impl:test_support",
    "//skia",
    "//testing/gmock",
    "//testing/gtest",
    "//ui/surface",
  ]
}

test("ppapi_perftests") {
  sources = [
    "proxy/ppapi_perftests.cc",
    "proxy/ppp_messaging_proxy_perftest.cc",
  ]

  deps = [
    "//base/test:test_support",
    "//ppapi/proxy",
    "//ppapi/proxy:test_support",
    "//ppapi/shared_impl",
    "//ppapi/shared_impl:test_support",
    "//testing/gtest",
  ]
}

executable("pepper_hash_for_uma") {
  sources = [
    "tools/pepper_hash_for_uma.cc",
  ]

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

if (is_nacl_glibc) {
  shared_library("ppapi_cpp_lib") {
    # When using gcc, we hide all symbols by default, but that breaks at
    # link time as the test executable requires symbols defined in the
    # shared library.
    configs -= [ "//build/config/gcc:symbol_visibility_hidden" ]
    configs += [ "//build/config/gcc:symbol_visibility_default" ]

    sources = ppapi_sources.cpp_source_files
    sources += [
      "cpp/module_embedder.h",
      "cpp/ppp_entrypoints.cc",
    ]
    cflags = [ "-fPIC" ]
    deps = [
      "//build/config/nacl:nacl_base",
    ]
  }
} else {
  static_library("ppapi_cpp_lib") {
    # This library is distributed as a part of the SDK and as such has to
    # be a static library rather than a source set.
    sources = ppapi_sources.cpp_source_files
    sources += [
      "cpp/module_embedder.h",
      "cpp/ppp_entrypoints.cc",
    ]
    deps = [
      "//build/config/nacl:nacl_base",
    ]
  }
}

source_set("ppapi_gles2_lib") {
  include_dirs = [ "lib/gl/include" ]
  sources = [
    "lib/gl/gles2/gl2ext_ppapi.c",
    "lib/gl/gles2/gl2ext_ppapi.h",
    "lib/gl/gles2/gles2.c",
  ]
  deps = [
    "//ppapi/cpp",
  ]
}

if (enable_nacl) {
  if (is_nacl) {
    executable("ppapi_nacl_tests_nexe") {
      output_name = "ppapi_nacl_tests"
      include_dirs = [ "lib/gl/include" ]
      sources = ppapi_sources.test_common_source_files +
                ppapi_sources.test_nacl_source_files
      defines = [
        "GL_GLEXT_PROTOTYPES",
        "PPAPI_TEST_IMPLEMENTATION",
      ]
      ldflags = [ "-pthread" ]
      deps = [
        ":ppapi_cpp_lib",
        "//build/config/nacl:nacl_base",
        "//ppapi/native_client:ppapi_lib",
      ]
    }

    if (current_cpu == "pnacl") {
      action("translate_pexe_to_nexe") {
        # We specify the toolchain explicitly because in the Non-SFI case, we
        # still want to use the pexe built using the newlib_pnacl toolchain.
        tests = ":ppapi_nacl_tests_nexe(//build/toolchain/nacl:newlib_pnacl)"

        pexe = get_label_info(tests, "root_out_dir") + "/ppapi_nacl_tests.pexe"
        nexe = "${root_out_dir}/ppapi_nacl_tests.nexe"

        script = "${nacl_toolchain_bindir}/pydir/loader.py"
        sources = [
          pexe,
        ]
        outputs = [
          nexe,
        ]

        if (is_nacl_nonsfi) {
          if (target_cpu == "x86" || target_cpu == "x64") {
            arch = "x86-32-nonsfi"
          } else if (target_cpu == "arm") {
            arch = "arm-nonsfi"
          }
        } else {
          # TODO(phosek): remove the following once change 1360243003 is rolled
          # into Chrome and use $target_cpu directly.
          if (target_cpu == "x86") {
            arch = "i686"
          } else if (target_cpu == "x64") {
            arch = "x86-64"
          } else if (target_cpu == "arm") {
            arch = "armv7"
          }
        }

        # The pre-translated object file has to be linked with an IRT shim to
        # get a runnable nexe. This is handled by pnacl-translate, which passes
        # -l:libpnacl_irt_shim.a to native linker, and we need to ensure the
        # linker can find the correct library.
        if (is_nacl_nonsfi) {
          pnacl_irt_shim = "//ppapi/native_client/src/untrusted/pnacl_irt_shim:aot(//build/toolchain/nacl:newlib_pnacl_nonsfi)"
        } else {
          pnacl_irt_shim = "//ppapi/native_client/src/untrusted/pnacl_irt_shim:aot(//build/toolchain/nacl:clang_newlib_${target_cpu})"
        }

        args = [
          "pnacl-translate",
          rebase_path(pexe, root_build_dir),
          "-o",
          rebase_path(nexe, root_build_dir),
          "-arch",
          arch,
          "-Wl,-L" +
              rebase_path(get_label_info(pnacl_irt_shim, "target_out_dir")),
        ]
        deps = [
          tests,
        ]
        data_deps = [
          pnacl_irt_shim,
        ]
      }
    }

    copy("ppapi_nacl_tests_copy") {
      sources = [
        "${root_out_dir}/ppapi_nacl_tests.nexe",
      ]

      # The CPU names used in tests/ppapi_nacl_tests_newlib.nmf
      # are the ones used in GYP (x32 for x86).
      if (target_cpu == "x86" ||
          (is_nacl_nonsfi && (target_cpu == "x86" || target_cpu == "x64"))) {
        nmf_cpu = "x32"
      } else {
        nmf_cpu = target_cpu
      }
      if (current_cpu == "pnacl") {
        if (is_nacl_nonsfi) {
          suffix = "pnacl_newlib_${nmf_cpu}_nonsfi"
        } else {
          suffix = "pnacl_newlib_${nmf_cpu}"
        }
      } else if (is_nacl_glibc) {
        suffix = "glibc_${nmf_cpu}"
      } else {
        suffix = "newlib_${nmf_cpu}"
      }
      outputs = [
        "${root_build_dir}/{{source_name_part}}_${suffix}.nexe",
      ]
      if (current_cpu == "pnacl") {
        deps = [
          ":translate_pexe_to_nexe",
        ]
      } else {
        deps = [
          ":ppapi_nacl_tests_nexe",
        ]
      }
    }

    if (is_nacl_nonsfi) {
      generate_nonsfi_test_nmf("ppapi_nacl_tests_nmf") {
        nmf = "${root_build_dir}/ppapi_nacl_tests_pnacl_nonsfi.nmf"
        files = get_target_outputs(":ppapi_nacl_tests_copy")
        executable = files[0]
        deps = [
          ":ppapi_nacl_tests_copy",
        ]
      }
    } else {
      generate_nmf("ppapi_nacl_tests_nmf") {
        if (is_nacl_glibc) {
          nmf = "${root_build_dir}/ppapi_nacl_tests_glibc.nmf"
          stage_dependencies = root_build_dir
        } else if (current_cpu == "pnacl") {
          nmf = "${root_build_dir}/ppapi_nacl_tests_pnacl.nmf"
        } else {
          nmf = "${root_build_dir}/ppapi_nacl_tests_newlib.nmf"
        }
        executables = get_target_outputs(":ppapi_nacl_tests_copy")
        deps = [
          ":ppapi_nacl_tests_copy",
        ]
      }
    }

    group("ppapi_nacl_tests") {
      data_deps = [
        ":ppapi_nacl_tests_copy",
        ":ppapi_nacl_tests_nmf",
      ]
    }
  }

  group("ppapi_nacl_tests_all") {
    data_deps = [
      ":copy_test_files",
      ":ppapi_nacl_tests_copy(//build/toolchain/nacl:clang_newlib_${target_cpu})",
      ":ppapi_nacl_tests(//build/toolchain/nacl:glibc_${target_cpu})",
      ":ppapi_nacl_tests(//build/toolchain/nacl:newlib_pnacl)",
      ":ppapi_nacl_tests(//build/toolchain/nacl:newlib_pnacl_nonsfi)",
    ]
  }
}