# 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
gen_policy_templates_chromeos = is_chromeos

# The zip file is grabbed from the Windows build right now.
gen_policy_templates_zip = is_win

# Make sure all dependencies of the zip are built.
if (gen_policy_templates_zip) {
  gen_policy_templates_common = true
  gen_policy_templates_win = true
  gen_policy_templates_chromeos = true
}

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"

# This file is used by tools/traffic_annotation/traffic_annotation.proto as it
# needs a version without LITE_RUNTIME optimization.
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"

# This file is used by tools/traffic_annotation/traffic_annotation.proto as it
# needs a version without LITE_RUNTIME optimization.
chrome_settings_full_runtime_proto_path =
    "$target_gen_dir/proto/chrome_settings_full_runtime.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,
    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-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),
  ]
}

action("full_runtime_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 = [
    cloud_policy_full_runtime_proto_path,
    chrome_settings_full_runtime_proto_path,
  ]

  args = [
    "--cloud-policy-full-runtime-protobuf=" +
        rebase_path(cloud_policy_full_runtime_proto_path, root_build_dir),
    "--chrome-settings-full-runtime-protobuf=" +
        rebase_path(chrome_settings_full_runtime_proto_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"

# Translates policy_templates.json into various languages.
grit("translate_policy_templates") {
  source = policy_templates_grd_file
  inputs = [
    "resources/policy_templates.json",
  ]
  output_dir = "$root_gen_dir/chrome"
  outputs = policy_templates_translation_outputs
}

# Generate the various templates and docs (admx, doc, json, etc.)
action("policy_templates") {
  script = "tools/template_writers/template_formatter.py"
  chrome_version_abspath = "//chrome/VERSION"
  chrome_version_path = rebase_path(chrome_version_abspath, root_build_dir)
  deps = [
    ":translate_policy_templates",
  ]
  inputs = [ chrome_version_abspath ] + policy_templates_translation_outputs
  outputs = []
  args = [
           "--translations",
           rebase_path(policy_templates_translation_json_path, root_build_dir),
           "--languages",
           policy_templates_languages_str,
           "--version_path",
           chrome_version_path,
         ] + grit_defines

  if (gen_policy_templates_common) {
    outputs += policy_templates_common_outputs
    args += [
      "--doc",
      rebase_path(policy_templates_doc_path, root_build_dir),
    ]
  }
  if (gen_policy_templates_android) {
    outputs += policy_templates_android_outputs
    args += [
      "--android_policy",
      rebase_path(policy_templates_android_policy_path, root_build_dir),
    ]
  }
  if (gen_policy_templates_linux) {
    outputs += policy_templates_linux_outputs
    args += [
      "--json",
      rebase_path(policy_templates_json_path, root_build_dir),
    ]
  }
  if (gen_policy_templates_mac) {
    outputs += policy_templates_mac_outputs
    args += [
      "--plist",
      rebase_path(policy_templates_plist_path, root_build_dir),
      "--plist_strings",
      rebase_path(policy_templates_plist_strings_path, root_build_dir),
      "-D",
      "mac_bundle_id=$chrome_mac_bundle_id",
    ]
  }
  if (gen_policy_templates_win) {
    outputs += policy_templates_win_outputs
    args += [
      "--reg",
      rebase_path(policy_templates_win_reg_path, root_build_dir),
      "--adm",
      rebase_path(policy_templates_win_adm_path, root_build_dir),
      "--adml",
      rebase_path(policy_templates_win_adml_path, root_build_dir),
      "--admx",
      rebase_path(policy_templates_win_admx_path, root_build_dir),
    ]
    if (is_chrome_branded) {
      # Create 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.
      outputs += policy_templates_win_google_outputs
      args += [
        "--google_adml",
        rebase_path(policy_templates_win_google_adml_path, root_build_dir),
        "--google_admx",
        rebase_path(policy_templates_win_google_admx_path, root_build_dir),
      ]
    }
  }
  if (gen_policy_templates_chromeos) {
    outputs += policy_templates_chromeos_outputs
    args += [
      "--chromeos_adml",
      rebase_path(policy_templates_chromeos_adml_path, root_build_dir),
      "--chromeos_admx",
      rebase_path(policy_templates_chromeos_admx_path, root_build_dir),
    ]
    if (is_chrome_branded) {
      # Create 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.
      outputs += policy_templates_chromeos_google_outputs
      args += [
        "--google_adml",
        rebase_path(policy_templates_chromeos_google_adml_path, root_build_dir),
        "--google_admx",
        rebase_path(policy_templates_chromeos_google_admx_path, root_build_dir),
      ]
    }
  }
}

# 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",
    ":chrome_settings_proto_generated_compile",
    ":chrome_settings_proto_generated_compile_proto",
    ":chrome_settings_proto_generated_compile_proto_gen",
  ]
  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.
component("chrome_settings_proto_generated_compile") {
  testonly = true
  public_deps = [
    ":chrome_settings_proto_generated_compile_proto",
    ":cloud_policy_proto_generated_compile",
  ]
}
proto_library("chrome_settings_proto_generated_compile_proto") {
  testonly = true
  visibility = [ ":chrome_settings_proto_generated_compile" ]
  sources = [
    chrome_settings_proto_path,
  ]

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

  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",
      ":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"
    bundle_contents_dir = "$bundle_root_dir/Contents"
    bundle_resources_dir = "$bundle_contents_dir/Resources"

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

if (gen_policy_templates_zip) {
  version_path = "$policy_templates_base_dir/VERSION"

  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_win_outputs +
             policy_templates_chromeos_outputs + policy_templates_common_outputs
    outputs = [
      output_zip_file,
    ]
    args = [
      "--output",
      rebase_path(output_zip_file, root_build_dir),
      "--base_dir",
      rebase_path(policy_templates_base_dir, root_build_dir),
      "--languages",
      policy_templates_languages_str,
      "--add",
      rebase_path(version_path, root_build_dir),
      "--add",
      rebase_path(policy_templates_doc_path, root_build_dir),
      "--add",
      rebase_path(policy_templates_win_reg_path, root_build_dir),
      "--add",
      rebase_path(policy_templates_win_adm_path, root_build_dir),
      "--add",
      rebase_path(policy_templates_win_adml_path, root_build_dir),
      "--add",
      rebase_path(policy_templates_win_admx_path, root_build_dir),
      "--add",
      rebase_path(policy_templates_chromeos_adml_path, root_build_dir),
      "--add",
      rebase_path(policy_templates_chromeos_admx_path, root_build_dir),
    ]
    if (is_chrome_branded) {
      inputs += policy_templates_win_google_outputs
      inputs += policy_templates_chromeos_google_outputs
      args += [
        "--add",
        rebase_path(policy_templates_win_google_adml_path, root_build_dir),
        "--add",
        rebase_path(policy_templates_win_google_admx_path, root_build_dir),
        "--add",
        rebase_path(policy_templates_chromeos_google_adml_path, root_build_dir),
        "--add",
        rebase_path(policy_templates_chromeos_google_admx_path, root_build_dir),
      ]
    }
    deps = [
      ":add_version",
      ":policy_templates",
    ]
  }
}