Add upstream support for 64_32 version codes

Android arm64 builds of monochrome need to build multiple apks with
various combinations of 32-vs-64-bit chrome & webview. Each apk will
need a unique version code, distinguished by the second-to-last digit
(the architecture digit).

This CL modifies the version code logic to support this.

Bug: 946281
Test: Check chrome_versions.txt, add automated tests.
Change-Id: I78b8d6fedb4c18db2442f50a027f988616e180c8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1540683
Commit-Queue: Drew Stonebraker <stonebraker@chromium.org>
Reviewed-by: Andrew Grieve <agrieve@chromium.org>
Reviewed-by: Christopher Grant <cjgrant@chromium.org>
Cr-Commit-Position: refs/heads/master@{#646640}

build/util/android_chrome_version.py

@@ -67,6 +67,7 @@ ARCH_VERSION_CODE_DIFF = {
 ARCH_CHOICES = ARCH_VERSION_CODE_DIFF.keys()
 
 """ "Next" builds get +5 last version code digit.
+
 We choose 5 because it won't conflict with values in
 ANDROID_CHROME_APK_VERSION_CODE_DIFFS
 
@@ -78,6 +79,29 @@ the chrome build (the "next" build) that uses the new android sdk.
 """
 NEXT_BUILD_VERSION_CODE_DIFF = 100005
 
+"""For 64-bit architectures, some packages have multiple targets with version
+codes that differ by the second-to-last digit (the architecture digit). This is
+for various combinations of 32-bit vs 64-bit chrome and webview. The
+default/traditional configuration is 32-bit chrome with 64-bit webview, but we
+are adding:
++ 64-bit chrome with 32-bit webview
++ 64-bit combined Chrome and Webview (only one library)
++ (maybe someday 32-bit chrome with 32-bit webview)
+
+The naming scheme followed here is <chrome>_<webview>,
+e.g. 64_32 is 64-bit chrome with 32-bit webview.
+"""
+ARCH64_APK_VARIANTS = {
+    '64_32': {
+        'PACKAGES': frozenset(['MONOCHROME']),
+        'MODIFIER': 10
+    },
+    '64': {
+        'PACKAGES': frozenset(['MONOCHROME']),
+        'MODIFIER': 20
+    }
+}
+
 
 def GenerateVersionCodes(version_values, arch, is_next_build):
   """Get dict of version codes for chrome-for-android-related targets
@@ -114,6 +138,16 @@ def GenerateVersionCodes(version_values, arch, is_next_build):
 
   version_codes = {}
   for apk, diff in ANDROID_CHROME_APK_VERSION_CODE_DIFFS.iteritems():
-    version_codes[apk + '_VERSION_CODE'] = str(new_version_code + diff)
+    version_code_name = apk + '_VERSION_CODE'
+    version_code_val = new_version_code + diff
+    version_codes[version_code_name] = str(version_code_val)
+
+    if arch == 'arm64' or arch == 'x64':
+      for variant, config in ARCH64_APK_VARIANTS.iteritems():
+        if apk in config['PACKAGES']:
+          variant_name = apk + '_' + variant + '_VERSION_CODE'
+          variant_val = version_code_val + config['MODIFIER']
+          version_codes[variant_name] = str(variant_val)
+
 
   return version_codes

build/util/android_chrome_version_test.py

@@ -144,6 +144,20 @@ class _VersionTest(unittest.TestCase):
 
     self.assertEqual(arch_chrome_version_code, '372000030')
 
+  def testGenerateVersionCodesAndroidArchArm64Variants(self):
+    """Assert it handles 64-bit-specific additional version codes correctly.
+
+    Some additional version codes are generated for 64-bit architectures.
+    See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info.
+    """
+    output = GenerateVersionCodes(
+        self.EXAMPLE_VERSION_VALUES, arch='arm64', is_next_build=False)
+    arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE']
+    arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE']
+
+    self.assertEqual(arch_monochrome_64_32_version_code, '372000042')
+    self.assertEqual(arch_monochrome_64_version_code, '372000052')
+
   def testGenerateVersionCodesAndroidArchX64(self):
     """Assert it handles different architectures correctly.
 
@@ -158,6 +172,20 @@ class _VersionTest(unittest.TestCase):
 
     self.assertEqual(arch_chrome_version_code, '372000060')
 
+  def testGenerateVersionCodesAndroidArchX64Variants(self):
+    """Assert it handles 64-bit-specific additional version codes correctly.
+
+    Some additional version codes are generated for 64-bit architectures.
+    See docstring on android_chrome_version.ARCH64_APK_VARIANTS for more info.
+    """
+    output = GenerateVersionCodes(
+        self.EXAMPLE_VERSION_VALUES, arch='x64', is_next_build=False)
+    arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE']
+    arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE']
+
+    self.assertEqual(arch_monochrome_64_32_version_code, '372000072')
+    self.assertEqual(arch_monochrome_64_version_code, '372000082')
+
   def testGenerateVersionCodesAndroidArchOrderArm(self):
     """Assert it handles different architectures correctly.
 

build/util/version.gni

@@ -46,6 +46,12 @@ if (target_os == "mac") {
       "notouch_chrome_version_code = \"@NOTOUCH_CHROME_VERSION_CODE@\" " +
       "webview_version_code = \"@WEBVIEW_VERSION_CODE@\" "
 
+  if (target_cpu == "arm64" || target_cpu == "x64") {
+    _version_dictionary_template +=
+        "monochrome_64_32_version_code = \"@MONOCHROME_64_32_VERSION_CODE@\" " +
+        "monochrome_64_version_code = \"@MONOCHROME_64_VERSION_CODE@\" "
+  }
+
   _script_arguments += [
     "-a",
     target_cpu,
@@ -94,18 +100,28 @@ if (target_os == "mac") {
                            "trichrome_version_code",
                            "notouch_chrome_version_code",
                            "webview_version_code",
+                           "monochrome_64_32_version_code",
+                           "monochrome_64_version_code",
                          ])
 
   chrome_version_name = chrome_version_full
 
-  write_file("$root_out_dir/chrome_versions.txt",
-             [
-               "VersionName=$chrome_version_name",
-               "Chrome=$chrome_version_code",
-               "ChromeModern=$chrome_modern_version_code",
-               "Monochrome=$monochrome_version_code",
-               "TrichromeChrome=$trichrome_version_code",
-               "NoTouchChrome=$notouch_chrome_version_code",
-               "Webview=$webview_version_code",
-             ])
+  lines_to_write = [
+    "VersionName=$chrome_version_name",
+    "Chrome=$chrome_version_code",
+    "ChromeModern=$chrome_modern_version_code",
+    "Monochrome=$monochrome_version_code",
+    "TrichromeChrome=$trichrome_version_code",
+    "NoTouchChrome=$notouch_chrome_version_code",
+    "Webview=$webview_version_code",
+  ]
+
+  if (target_cpu == "arm64" || target_cpu == "x64") {
+    lines_to_write += [
+      "Monochrome_64_32=$monochrome_64_32_version_code",
+      "Monochrome_64=$monochrome_64_version_code",
+    ]
+  }
+
+  write_file("$root_out_dir/chrome_versions.txt", lines_to_write)
 }

build/util/version_test.py

@@ -110,6 +110,40 @@ class _VersionTest(unittest.TestCase):
     self.assertRegexpMatches(contents, r'\btrichrome_version_code = "\d+"\s')
     self.assertRegexpMatches(contents, r'\bwebview_version_code = "\d+"\s')
 
+  def testBuildOutputAndroidArchVariantsArm64(self):
+    """Assert 64-bit-specific version codes"""
+    new_template = (
+        self._EXAMPLE_ANDROID_TEMPLATE +
+        "monochrome_64_32_version_code = \"@MONOCHROME_64_32_VERSION_CODE@\" "
+        "monochrome_64_version_code = \"@MONOCHROME_64_VERSION_CODE@\" ")
+    args_with_template = _ReplaceArgs(self._EXAMPLE_ANDROID_ARGS,
+                                      ['-t', new_template])
+    new_args = _ReplaceArgs(args_with_template, ['-a', 'arm64'])
+    output = self._RunBuildOutput(get_new_args=lambda args: new_args)
+    contents = output['contents']
+
+    self.assertRegexpMatches(contents,
+                             r'\bmonochrome_64_32_version_code = "\d+"\s')
+    self.assertRegexpMatches(contents,
+                             r'\bmonochrome_64_version_code = "\d+"\s')
+
+  def testBuildOutputAndroidArchVariantsX64(self):
+    """Assert 64-bit-specific version codes"""
+    new_template = (
+        self._EXAMPLE_ANDROID_TEMPLATE +
+        "monochrome_64_32_version_code = \"@MONOCHROME_64_32_VERSION_CODE@\" "
+        "monochrome_64_version_code = \"@MONOCHROME_64_VERSION_CODE@\" ")
+    args_with_template = _ReplaceArgs(self._EXAMPLE_ANDROID_ARGS,
+                                      ['-t', new_template])
+    new_args = _ReplaceArgs(args_with_template, ['-a', 'x64'])
+    output = self._RunBuildOutput(get_new_args=lambda args: new_args)
+    contents = output['contents']
+
+    self.assertRegexpMatches(contents,
+                             r'\bmonochrome_64_32_version_code = "\d+"\s')
+    self.assertRegexpMatches(contents,
+                             r'\bmonochrome_64_version_code = "\d+"\s')
+
   def testBuildOutputAndroidChromeArchInput(self):
     """Assert it raises an exception when using an invalid architecture input"""
     new_args = _ReplaceArgs(self._EXAMPLE_ANDROID_ARGS, ['-a', 'foobar'])

chrome/android/BUILD.gn

@@ -1732,6 +1732,8 @@ template("monochrome_public_apk_or_module_tmpl") {
                              "resource_ids_provider_dep",
                              "target_type",
                              "use_trichrome_library",
+                             "version_code",
+                             "version_name",
                            ])
     android_manifest = _android_manifest
     android_manifest_dep = ":${target_name}__android_manifest"
@@ -1761,12 +1763,12 @@ template("monochrome_public_apk_or_module_tmpl") {
     add_unwind_tables_in_apk =
         _add_unwind_tables_in_chrome_32bit_apk && _needs_arm32_lib &&
         (!defined(use_trichrome_library) || !use_trichrome_library)
-
-    version_name = chrome_version_name
   }
 }
 
 monochrome_public_apk_or_module_tmpl("monochrome_public_apk") {
+  version_code = monochrome_version_code
+  version_name = chrome_version_name
   apk_name = "MonochromePublic"
   target_type = "android_apk"
 
@@ -1799,6 +1801,8 @@ android_resources("trichrome_dummy_resources") {
 }
 
 monochrome_public_apk_or_module_tmpl("trichrome_chrome_apk") {
+  version_code = trichrome_version_code
+  version_name = chrome_version_name
   apk_name = "TrichromeChrome"
   target_type = "android_apk"
   use_trichrome_library = true
@@ -2071,6 +2075,19 @@ template("monochrome_public_bundle_tmpl") {
     _min_sdk_version = 24
   }
 
+  if (_is_trichrome) {
+    _version_code = trichrome_version_code
+  } else if (defined(invoker.is_64_bit_browser) && invoker.is_64_bit_browser) {
+    if (invoker.build_apk_secondary_abi && invoker.include_32_bit_webview) {
+      _version_code = monochrome_64_32_version_code
+    } else {
+      _version_code = monochrome_64_version_code
+    }
+  } else {
+    _version_code = monochrome_version_code
+  }
+  _version_name = chrome_version_name
+
   monochrome_public_apk_or_module_tmpl(_base_module_target_name) {
     forward_variables_from(invoker,
                            [
@@ -2081,6 +2098,8 @@ template("monochrome_public_bundle_tmpl") {
     module_name = _bundle_name + "Base"
     target_type = "android_app_bundle_module"
     is_base_module = true
+    version_code = _version_code
+    version_name = _version_name
   }
 
   if (modularize_ar) {
@@ -2098,12 +2117,8 @@ template("monochrome_public_bundle_tmpl") {
       module_name = "Ar" + _bundle_name
       base_module_target = ":$_base_module_target_name"
       native_switches = _native_switches
-      if (_is_trichrome) {
-        version_code = trichrome_version_code
-      } else {
-        version_code = monochrome_version_code
-      }
-      version_name = chrome_version_name
+      version_code = _version_code
+      version_name = _version_name
     }
   }
 
@@ -2112,13 +2127,9 @@ template("monochrome_public_bundle_tmpl") {
       manifest_package = manifest_package
       module_name = "Vr" + _bundle_name
       base_module_target = ":$_base_module_target_name"
-      if (_is_trichrome) {
-        version_code = trichrome_version_code
-      } else {
-        version_code = monochrome_version_code
-      }
-      version_name = chrome_version_name
       uncompress_shared_libraries = true
+      version_code = _version_code
+      version_name = _version_name
     }
   }
 
@@ -2126,13 +2137,9 @@ template("monochrome_public_bundle_tmpl") {
     manifest_package = manifest_package
     module_name = "TabUiMonochromePublic"
     base_module_target = ":$_base_module_target_name"
-    if (_is_trichrome) {
-      version_code = trichrome_version_code
-    } else {
-      version_code = monochrome_version_code
-    }
-    version_name = chrome_version_name
     uncompress_shared_libraries = true
+    version_code = _version_code
+    version_name = _version_name
   }
 
   android_app_bundle(target_name) {

chrome/android/chrome_public_apk_tmpl.gni

@@ -291,6 +291,7 @@ template("monochrome_public_common_apk_or_module_tmpl") {
     _enable_multidex = is_java_debug || multidex_in_release
   }
   chrome_public_common_apk_or_module_tmpl(target_name) {
+    forward_variables_from(invoker, [ "version_code" ])
     is_trichrome =
         defined(invoker.use_trichrome_library) && invoker.use_trichrome_library
     is_monochrome = !is_trichrome

chrome/android/features/ar/ar_module_tmpl.gni

@@ -11,6 +11,8 @@ assert(enable_arcore)
 assert(modularize_ar)
 
 template("ar_module_tmpl") {
+  assert(defined(invoker.version_code))
+  assert(defined(invoker.version_name))
   assert(defined(invoker.manifest_package))
   assert(defined(invoker.module_name))
   assert(defined(invoker.base_module_target))

chrome/android/features/tab_ui/tab_ui_module_tmpl.gni

@@ -7,6 +7,9 @@ import("//build/config/locales.gni")
 import("//chrome/android/features/module_names_to_package_ids.gni")
 
 template("tab_ui_module_tmpl") {
+  assert(defined(invoker.version_code))
+  assert(defined(invoker.version_name))
+
   _manifest = "$target_gen_dir/$target_name/AndroidManifest.xml"
   _manifest_target = "${target_name}__manifest"
   jinja_template(_manifest_target) {

chrome/android/features/vr/vr_module_tmpl.gni

@@ -12,6 +12,8 @@ assert(enable_vr)
 assert(modularize_vr)
 
 template("vr_module_tmpl") {
+  assert(defined(invoker.version_code))
+  assert(defined(invoker.version_name))
   assert(defined(invoker.manifest_package))
   assert(defined(invoker.module_name))
   assert(defined(invoker.base_module_target))