# 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/chrome_build.gni")
import("//build/config/features.gni")
import("//build/toolchain/toolchain.gni")
import("//components/policy/resources/policy_templates.gni")
import("//third_party/protobuf/proto_library.gni")
import("//tools/grit/grit_rule.gni")

assert(!is_ios, "Policy should not be referenced on iOS")

# To test policy generation for platforms different than your OS, override and
# enable these flags (but don't check that in!).
gen_policy_templates_common = true
gen_policy_templates_win = is_win
gen_policy_templates_linux = is_linux
gen_policy_templates_android = is_android
gen_policy_templates_mac = is_mac

if (is_mac) {
  import("//build/util/branding.gni")
} else if (gen_policy_templates_mac) {
  chrome_mac_bundle_id = "DUMMY_MAC_BUNDLE_ID"
}

if (is_component_build) {
  # External code should depend on either //components/policy/core/browser or
  # .../common depending on what code it needs.
  component("policy") {
    output_name = "policy_component"
    visibility = [
      "//components/policy/core/browser",
      "//components/policy/core/common",
    ]
    public_deps = [
      "//components/policy/core/browser:internal",
      "//components/policy/core/common:internal",
    ]
  }
}

# Used by targets that compile into the implementation.
config("component_implementation") {
  defines = [ "POLICY_COMPONENT_IMPLEMENTATION" ]
}

# This protobuf is equivalent to chrome_settings.proto but shares messages
# for policies of the same type, so that less classes have to be generated
# and compiled.
cloud_policy_proto_path = "$target_gen_dir/proto/cloud_policy.proto"
cloud_policy_full_runtime_proto_path =
    "$target_gen_dir/proto/cloud_policy_full_runtime.proto"

# This is the "full" protobuf, which defines one protobuf message per
# policy. It is also the format currently used by the server.
chrome_settings_proto_path = "$target_gen_dir/proto/chrome_settings.proto"

constants_header_path = "$target_gen_dir/policy_constants.h"
constants_source_path = "$target_gen_dir/policy_constants.cc"
protobuf_decoder_path = "$target_gen_dir/cloud_policy_generated.cc"
app_restrictions_path = "$target_gen_dir/app_restrictions.xml"
risk_tag_header_path = "$target_gen_dir/risk_tag.h"

action("cloud_policy_code_generate") {
  script = "tools/generate_policy_source.py"
  chrome_version_abspath = "//chrome/VERSION"
  chrome_version_path = rebase_path(chrome_version_abspath, root_build_dir)

  if (is_chromeos) {
    chromeos_flag = "1"
  } else {
    chromeos_flag = "0"
  }

  inputs = [
    chrome_version_abspath,
    "resources/policy_templates.json",
  ]
  outputs = [
    constants_header_path,
    constants_source_path,
    protobuf_decoder_path,
    chrome_settings_proto_path,
    cloud_policy_proto_path,
    cloud_policy_full_runtime_proto_path,
    app_restrictions_path,
    risk_tag_header_path,
  ]

  if (target_os != "android") {
    outputs -= [ app_restrictions_path ]
  }

  args = [
    "--policy-constants-header=" +
        rebase_path(constants_header_path, root_build_dir),
    "--policy-constants-source=" +
        rebase_path(constants_source_path, root_build_dir),
    "--chrome-settings-protobuf=" +
        rebase_path(chrome_settings_proto_path, root_build_dir),
    "--cloud-policy-protobuf=" +
        rebase_path(cloud_policy_proto_path, root_build_dir),
    "--cloud-policy-full-runtime-protobuf=" +
        rebase_path(cloud_policy_full_runtime_proto_path, root_build_dir),
    "--cloud-policy-decoder=" +
        rebase_path(protobuf_decoder_path, root_build_dir),
    "--app-restrictions-definition=" +
        rebase_path(app_restrictions_path, root_build_dir),
    "--risk-tag-header=" + rebase_path(risk_tag_header_path, root_build_dir),
    chrome_version_path,
    target_os,
    chromeos_flag,
    rebase_path("resources/policy_templates.json", root_build_dir),
  ]
}

policy_templates_grd_file = "resources/policy_templates.grd"

grit("grit_policy_templates") {
  source = policy_templates_grd_file
  use_qualified_include = true
  output_dir = "$root_gen_dir/chrome"
  outputs = []
  defines = []

  if (gen_policy_templates_common) {
    outputs += policy_templates_doc_outputs
    defines += [ "gen_policy_templates_common" ]
  }
  if (gen_policy_templates_android) {
    outputs += policy_templates_android_outputs
    defines += [ "gen_policy_templates_android" ]
  }
  if (gen_policy_templates_linux) {
    outputs += policy_templates_linux_outputs
    defines += [ "gen_policy_templates_linux" ]
  }
  if (gen_policy_templates_mac) {
    outputs += policy_templates_mac_outputs
    defines += [
      "mac_bundle_id=$chrome_mac_bundle_id",
      "gen_policy_templates_mac",
    ]
  }
  if (gen_policy_templates_win) {
    outputs += policy_templates_windows_outputs
    defines += [ "gen_policy_templates_win" ]
  }
}

if (gen_policy_templates_win && is_chrome_branded) {
  # Creates google.admx and google.adml files that define a common 'Google'
  # category used for Chrome, Chrome OS and possibly external tools, see
  # crbug.com/665400.
  action("create_google_admx") {
    script = "tools/create_google_admx.py"
    inputs = [
               policy_templates_grd_file,
               grit_info_script,
             ] + policy_templates_windows_outputs
    outputs = policy_templates_windows_google_outputs
    deps = [
      ":grit_policy_templates",
    ]

    # Don't pass in outputs directly, it would exceed a limit on Windows!
    args = [
             "--basedir",
             rebase_path(policy_templates_base_dir, root_build_dir),
             "--grd_strip_path_prefix",
             "app/policy/",
             "--grd_input",
             rebase_path(policy_templates_grd_file, root_build_dir),
             "--grit_info",
             rebase_path(grit_info_script, root_build_dir),
             "-D",
             "gen_policy_templates_win",
           ] + grit_defines
  }
}

group("policy_templates") {
  public_deps = [
    ":grit_policy_templates",
  ]
  if (gen_policy_templates_win && is_chrome_branded) {
    public_deps += [ ":create_google_admx" ]
  }
}

# Run the proto compiler over the generated file and make it a component.
component("cloud_policy_proto_generated_compile") {
  public_deps = [
    ":cloud_policy_proto_generated_compile_proto",
  ]
}
proto_library("cloud_policy_proto_generated_compile_proto") {
  visibility = [ ":cloud_policy_proto_generated_compile" ]
  sources = [
    cloud_policy_proto_path,
  ]

  proto_out_dir = "components/policy/proto"
  cc_generator_options = "dllexport_decl=POLICY_PROTO_EXPORT:"
  cc_include = "components/policy/proto/policy_proto_export.h"
  component_build_force_source_set = true
  defines = [ "POLICY_PROTO_COMPILATION" ]

  deps = [
    ":cloud_policy_code_generate",
  ]
}

# This target builds the "full" protobuf, used for tests only.
proto_library("chrome_settings_proto") {
  testonly = true
  sources = [
    chrome_settings_proto_path,
  ]
  proto_out_dir = "components/policy/proto"

  deps = [
    ":cloud_policy_code_generate",
    ":cloud_policy_proto_generated_compile",
  ]
}

static_library("generated") {
  sources = [
    constants_header_path,
    constants_source_path,
    protobuf_decoder_path,
    risk_tag_header_path,
  ]

  defines = [ "POLICY_COMPONENT_IMPLEMENTATION" ]
  public_deps = [
    ":cloud_policy_code_generate",
    ":cloud_policy_proto_generated_compile",
    "//base",
    "//third_party/protobuf:protobuf_lite",
  ]
}

if (gen_policy_templates_android && is_android) {
  import("//build/config/android/rules.gni")

  _generated_resources_dir = "$root_gen_dir/chrome/app/policy/android"

  copy("app_restrictions_resources_copy") {
    sources = [
      app_restrictions_path,
    ]
    outputs = [
      "$_generated_resources_dir/xml-v21/app_restrictions.xml",
    ]
    deps = [
      ":cloud_policy_code_generate",
      ":policy_templates",
    ]
  }

  android_resources("app_restrictions_resources") {
    resource_dirs = []
    generated_resource_dirs = [
      "$policy_templates_base_dir/android",
      _generated_resources_dir,
    ]
    generated_resource_files =
        policy_templates_android_outputs +
        [ "$_generated_resources_dir/xml-v21/app_restrictions.xml" ]
    deps = [
      ":app_restrictions_resources_copy",
      ":grit_policy_templates",
    ]
  }
} else if (gen_policy_templates_mac && is_mac) {
  action("convert_mcx_plist") {
    script = "//build/config/mac/xcrun.py"
    sources = [
      "$policy_templates_base_dir/mac/app-Manifest.plist",
    ]
    inputs = [
      script,
    ]
    outputs = [
      "$target_gen_dir/$chrome_mac_bundle_id.manifest",
    ]

    if (use_system_xcode) {
      args = []
    } else {
      args = [
        "--developer_dir",
        hermetic_xcode_path,
      ]
    }
    args += [
              "plutil",
              "-convert",
              "xml1",
            ] + rebase_path(sources, root_out_dir) + [ "-o" ] +
            rebase_path(outputs, root_out_dir)

    deps = [
      ":policy_templates",
    ]
  }

  bundle_data("manifest_bundle_data") {
    sources = get_target_outputs(":convert_mcx_plist")
    outputs = [
      "{{bundle_resources_dir}}/{{source_file_part}}",
    ]
    public_deps = [
      ":convert_mcx_plist",
    ]
  }

  # The reason we are not enumerating all the locales is that
  # the translations would eat up 3.5MB disk space in the
  # application bundle.
  bundle_data("manifest_strings_bundle_data") {
    sources = [
      "$policy_templates_base_dir/mac/strings/en.lproj/Localizable.strings",
    ]
    outputs = [
      "{{bundle_resources_dir}}/en.lproj/{{source_file_part}}",
    ]
    public_deps = [
      ":policy_templates",
    ]
  }

  create_bundle("chrome_manifest_bundle") {
    bundle_root_dir = "$root_out_dir/$chrome_mac_bundle_id.manifest/Contents"
    bundle_resources_dir = "$bundle_root_dir/Resources"

    deps = [
      ":manifest_bundle_data",
      ":manifest_strings_bundle_data",
    ]
  }
}

if (gen_policy_templates_common && gen_policy_templates_win) {
  version_file = "VERSION"
  version_path = "$policy_templates_base_dir/$version_file"

  copy("add_version") {
    sources = [
      "//chrome/VERSION",
    ]
    outputs = [
      version_path,
    ]
  }

  action("pack_policy_templates") {
    output_zip_file = "$root_out_dir/policy_templates.zip"
    script = "tools/make_policy_zip.py"
    inputs = [
               version_path,
               policy_templates_grd_file,
               grit_info_script,
             ] + policy_templates_windows_outputs + policy_templates_doc_outputs
    outputs = [
      output_zip_file,
    ]
    args = [
             "--output",
             rebase_path(output_zip_file, root_build_dir),
             "--basedir",
             rebase_path(policy_templates_base_dir, root_build_dir),
             "--grd_input",
             rebase_path(policy_templates_grd_file, root_build_dir),
             "--grd_strip_path_prefix",
             "app/policy",
             "--extra_input",
             version_file,
             "--grit_info",
             rebase_path(grit_info_script, root_build_dir),
             "-D",
             "gen_policy_templates_common",
             "-D",
             "gen_policy_templates_win",
           ] + grit_defines
    if (is_chrome_branded) {
      args += [ "--include_google_admx" ]
    }
    deps = [
      ":add_version",
      ":policy_templates",
    ]
  }
}