Revert "Android: Support pure-32-bit version codes on 64-bit build configs"

This reverts commit 0c8f0867.

Reason for revert: https://ci.chromium.org/p/chrome/builders/ci/arm-unpublished-builder-rel/15653

TBR=agrieve
Bug: 1027573

Original change's description:
> Android: Support pure-32-bit version codes on 64-bit build configs
> 
> See the associated bug for reasons why this work is happening.
> 
> Refactor the version number generator script to be more explicit, and do
> away with the hack that was in place to support multiple version numbers
> in 64-bit config.
> 
> Also, add the new pure 32-bit Mono and Trichrome numbers, as well as an
> alias 32_64 version number, which is equivalent to the ambiguous
> "Monochrome" version.
> 
> Bug: 1027573
> Change-Id: Iae270f84ad3cf3c28e9001460a016aa7f75237e8
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1931100
> Commit-Queue: Christopher Grant <cjgrant@chromium.org>
> Reviewed-by: Andrew Grieve <agrieve@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#718671}

TBR=cjgrant@chromium.org,agrieve@chromium.org

Change-Id: Ic5874955be3e1c723635accb5f9381540f3d6b34
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1027573
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1934428Reviewed-by: Christopher Grant <cjgrant@chromium.org>
Commit-Queue: Christopher Grant <cjgrant@chromium.org>
Cr-Commit-Position: refs/heads/master@{#718684}

build/util/android_chrome_version.py

 # Copyright 2019 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.
-"""Different build variants of Chrome for Android have different version codes.
+"""Different build variants of chrome for android have different version codes.
+Reason: for targets that have the same package name (e.g. chrome, chome
+modern, monochrome, trichrome), Play Store considers them the same app
+and will push the supported app with the highest version code to devices.
+(note Play Store does not support hosting two different apps with same
+version code and package name)
 
-For targets that have the same package name (e.g. Chrome, Chrome Modern,
-Monochrome, Trichrome), Play Store considers them the same app and will push the
-supported app with the highest version code to devices. Note that Play Store
-does not support hosting two different apps with same version code and package
-name.
-
-Each version code generated by this script will be used by one or more APKs.
+Each key in this dict represents a unique version code that will be used for
+one or more android chrome apks.
 
 Webview channels must have unique version codes for a couple reasons:
 a) Play Store does not support having the same version code for different
@@ -21,78 +21,23 @@ b) Firebase project support (used by official builders) requires unique
    packages are whitelisted by Android as webview providers.
 
 WEBVIEW_STABLE, WEBVIEW_BETA, WEBVIEW_DEV are all used for standalone webview,
-whereas the others are used for various chrome APKs.
+whereas the others are used for various chrome apks.
 
-Note that a final digit of '3' for Webview is reserved for Trichrome Webview.
+Note that a final digit of '3' for webview is reserved for Trichrome Webview.
 The same versionCode is used for both Trichrome Chrome and Trichrome Webview.
 """
-
-# Package name version bits.
-_PACKAGE_NAMES = {
+ANDROID_CHROME_APK_VERSION_CODE_DIFFS = {
     'CHROME': 0,
     'CHROME_MODERN': 1,
     'MONOCHROME': 2,
     'TRICHROME': 3,
+    'NOTOUCH_CHROME': 4,
     'WEBVIEW_STABLE': 0,
     'WEBVIEW_BETA': 1,
     'WEBVIEW_DEV': 2,
 }
-"""List of version numbers to be created for each build configuration.
-Tuple format:
-
-  (version code name), (package name), (supported ABIs)
-
-Here, (supported ABIs) is referring to the combination of browser ABI and
-webview library ABI present in a particular APK. For example, 64_32 implies a
-64-bit browser with an extra 32-bit Webview library. See also
-_ABIS_TO_BIT_MASK.
-"""
-_APKS = {
-    '32': [
-        ('CHROME', 'CHROME', '32'),
-        ('CHROME_MODERN', 'CHROME_MODERN', '32'),
-        ('MONOCHROME', 'MONOCHROME', '32'),
-        ('TRICHROME', 'TRICHROME', '32'),
-        ('WEBVIEW_STABLE', 'WEBVIEW_STABLE', '32'),
-        ('WEBVIEW_BETA', 'WEBVIEW_BETA', '32'),
-        ('WEBVIEW_DEV', 'WEBVIEW_DEV', '32'),
-    ],
-    '64': [
-        # Pure 64-bit Chrome variants have traditionally used the first
-        # available 64-bit architecture digit, which is now used for
-        # Monochrome/Trichrome's "32+64" variant. It could be changed to "64",
-        # but there's no reason to.
-        ('CHROME', 'CHROME', '32_64'),
-        ('CHROME_MODERN', 'CHROME_MODERN', '32_64'),
-        ('MONOCHROME', 'MONOCHROME', '32_64'),
-        ('MONOCHROME_32', 'MONOCHROME', '32'),
-        ('MONOCHROME_32_64', 'MONOCHROME', '32_64'),
-        ('MONOCHROME_64_32', 'MONOCHROME', '64_32'),
-        ('MONOCHROME_64', 'MONOCHROME', '64'),
-        ('TRICHROME', 'TRICHROME', '32_64'),
-        ('TRICHROME_32', 'TRICHROME', '32'),
-        ('TRICHROME_32_64', 'TRICHROME', '32_64'),
-        ('TRICHROME_64_32', 'TRICHROME', '64_32'),
-        ('TRICHROME_64', 'TRICHROME', '64'),
-        ('WEBVIEW_STABLE', 'WEBVIEW_STABLE', '32_64'),
-        ('WEBVIEW_BETA', 'WEBVIEW_BETA', '32_64'),
-        ('WEBVIEW_DEV', 'WEBVIEW_DEV', '32_64'),
-    ]
-}
 
-# Splits input build config architecture to manufacturer and bitness.
-_ARCH_TO_MFG_AND_BITNESS = {
-    'arm': ('arm', '32'),
-    'arm64': ('arm', '64'),
-    'x86': ('intel', '32'),
-    'x64': ('intel', '64'),
-    'mipsel': ('mipsel', '32'),
-}
-
-# Expose the available choices to other scripts.
-ARCH_CHOICES = _ARCH_TO_MFG_AND_BITNESS.keys()
-"""
-The architecture preference is encoded into the version_code for devices
+"""The architecture preference is encoded into the version_code for devices
 that support multiple architectures. (exploiting play store logic that pushes
 apk with highest version code)
 
@@ -132,34 +77,50 @@ things here:
 - The relative order of mips isn't important, but it needs to be a *distinct*
   value to the other architectures because all builds need unique version codes.
 """
-_ABIS_TO_BIT_MASK = {
-    'arm': {
-        '32': 0,
-        '32_64': 30,
-        '64_32': 40,
-        '64': 50,
-    },
-    'intel': {
-        '32': 10,
-        '32_64': 60,
-        '64_32': 70,
-        '64': 80,
-    },
-    'mipsel': {
-        '32': 20,
-    }
+ARCH_VERSION_CODE_DIFF = {
+    'arm': 0,
+    'x86': 10,
+    'mipsel': 20,
+    'arm64': 30,
+    'x64': 60
 }
+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
 """
-_NEXT_BUILD_VERSION_CODE_DIFF = 5
+NEXT_BUILD_VERSION_CODE_DIFF = 5
+
+"""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', 'TRICHROME']),
+        'MODIFIER': 10
+    },
+    '64': {
+        'PACKAGES': frozenset(['MONOCHROME', 'TRICHROME']),
+        'MODIFIER': 20
+    }
+}
 
 
 def GenerateVersionCodes(version_values, arch, is_next_build):
-  """Build dict of version codes for the specified build architecture. Eg:
+  """Get dict of version codes for chrome-for-android-related targets
 
+  e.g.
   {
     'CHROME_VERSION_CODE': '378100010',
     'MONOCHROME_VERSION_CODE': '378100013',
@@ -181,22 +142,25 @@ def GenerateVersionCodes(version_values, arch, is_next_build):
   Thus, this method is responsible for the final two digits of versionCode.
   """
 
-  base_version_code = int(
-      '%s%03d00' % (version_values['BUILD'], int(version_values['PATCH'])))
+  base_version_code = '%s%03d00' % (version_values['BUILD'],
+                                    int(version_values['PATCH']))
+  new_version_code = int(base_version_code)
 
+  new_version_code += ARCH_VERSION_CODE_DIFF[arch]
   if is_next_build:
-    base_version_code += _NEXT_BUILD_VERSION_CODE_DIFF
-
-  mfg, bitness = _ARCH_TO_MFG_AND_BITNESS[arch]
+    new_version_code += NEXT_BUILD_VERSION_CODE_DIFF
 
   version_codes = {}
-
-  for apk, package, abis in _APKS[bitness]:
-    abi_bits = _ABIS_TO_BIT_MASK[mfg][abis]
-    package_bits = _PACKAGE_NAMES[package]
-
+  for apk, diff in ANDROID_CHROME_APK_VERSION_CODE_DIFFS.iteritems():
     version_code_name = apk + '_VERSION_CODE'
-    version_code_val = base_version_code + abi_bits + package_bits
+    version_code_val = new_version_code + diff
     version_codes[version_code_name] = str(version_code_val)
 
+    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

@@ -54,6 +54,15 @@ class _VersionTest(unittest.TestCase):
 
     self.assertEqual(trichrome_version_code, '372000003')
 
+  def testGenerateVersionCodesAndroidNoTouch(self):
+    """Assert it gives correct values for standard/example inputs"""
+    output = GenerateVersionCodes(
+        self.EXAMPLE_VERSION_VALUES, arch='arm', is_next_build=False)
+
+    notouch_chrome_version_code = output['NOTOUCH_CHROME_VERSION_CODE']
+
+    self.assertEqual(notouch_chrome_version_code, '372000004')
+
   def testGenerateVersionCodesAndroidWebviewStable(self):
     """Assert it gives correct values for standard/example inputs"""
     output = GenerateVersionCodes(
@@ -161,25 +170,13 @@ class _VersionTest(unittest.TestCase):
     """
     output = GenerateVersionCodes(
         self.EXAMPLE_VERSION_VALUES, arch='arm64', is_next_build=False)
-    arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE']
-    arch_monochrome_32_version_code = output['MONOCHROME_32_VERSION_CODE']
-    arch_monochrome_32_64_version_code = output['MONOCHROME_32_64_VERSION_CODE']
     arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE']
     arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE']
-    arch_trichrome_version_code = output['TRICHROME_VERSION_CODE']
-    arch_trichrome_32_version_code = output['TRICHROME_32_VERSION_CODE']
-    arch_trichrome_32_64_version_code = output['TRICHROME_32_64_VERSION_CODE']
     arch_trichrome_64_32_version_code = output['TRICHROME_64_32_VERSION_CODE']
     arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE']
 
-    self.assertEqual(arch_monochrome_32_version_code, '372000002')
-    self.assertEqual(arch_monochrome_32_64_version_code, '372000032')
-    self.assertEqual(arch_monochrome_version_code, '372000032')
     self.assertEqual(arch_monochrome_64_32_version_code, '372000042')
     self.assertEqual(arch_monochrome_64_version_code, '372000052')
-    self.assertEqual(arch_trichrome_32_version_code, '372000003')
-    self.assertEqual(arch_trichrome_32_64_version_code, '372000033')
-    self.assertEqual(arch_trichrome_version_code, '372000033')
     self.assertEqual(arch_trichrome_64_32_version_code, '372000043')
     self.assertEqual(arch_trichrome_64_version_code, '372000053')
 
@@ -205,25 +202,13 @@ class _VersionTest(unittest.TestCase):
     """
     output = GenerateVersionCodes(
         self.EXAMPLE_VERSION_VALUES, arch='x64', is_next_build=False)
-    arch_monochrome_32_version_code = output['MONOCHROME_32_VERSION_CODE']
-    arch_monochrome_32_64_version_code = output['MONOCHROME_32_64_VERSION_CODE']
-    arch_monochrome_version_code = output['MONOCHROME_VERSION_CODE']
     arch_monochrome_64_32_version_code = output['MONOCHROME_64_32_VERSION_CODE']
     arch_monochrome_64_version_code = output['MONOCHROME_64_VERSION_CODE']
-    arch_trichrome_32_version_code = output['TRICHROME_32_VERSION_CODE']
-    arch_trichrome_32_64_version_code = output['TRICHROME_32_64_VERSION_CODE']
-    arch_trichrome_version_code = output['TRICHROME_VERSION_CODE']
     arch_trichrome_64_32_version_code = output['TRICHROME_64_32_VERSION_CODE']
     arch_trichrome_64_version_code = output['TRICHROME_64_VERSION_CODE']
 
-    self.assertEqual(arch_monochrome_32_version_code, '372000012')
-    self.assertEqual(arch_monochrome_32_64_version_code, '372000062')
-    self.assertEqual(arch_monochrome_version_code, '372000062')
     self.assertEqual(arch_monochrome_64_32_version_code, '372000072')
     self.assertEqual(arch_monochrome_64_version_code, '372000082')
-    self.assertEqual(arch_trichrome_32_version_code, '372000013')
-    self.assertEqual(arch_trichrome_32_64_version_code, '372000063')
-    self.assertEqual(arch_trichrome_version_code, '372000063')
     self.assertEqual(arch_trichrome_64_32_version_code, '372000073')
     self.assertEqual(arch_trichrome_64_version_code, '372000083')
 

build/util/version.gni

@@ -78,10 +78,7 @@ _script_arguments += [
 _result = exec_script("version.py",
                       _script_arguments,
                       "scope",
-                      [
-                        chrome_version_file,
-                        "android_chrome_version.py",
-                      ])
+                      [ chrome_version_file ])
 
 # Full version. For example "45.0.12321.0"
 chrome_version_full = _result.full