arcvm: Identify binary translation type on ARCVM

This constitutes a part of change to enable NDK translation on ARCVM.
We identify the binary translation type (None/Houdini/NDK translation)
by seeing USE flags passed from Chrome OS. This information on the
binary translation type is passed to Android via the property
androidboot.native_bridge, which can be accessed as
ro.boot.native_bridge.

BUG=b:139480143
TEST=components_unittests
TEST=Edit /etc/ui_use_flags.txt, and run getprop after restarting ui

Change-Id: Id5810369f3c4e82fda54ed9d2b32be3ad168723e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2071675Reviewed-by: Satoshi Niwa <niwa@chromium.org>
Reviewed-by: Yusuke Sato <yusukes@chromium.org>
Commit-Queue: Youkichi Hosoi <youkichihosoi@chromium.org>
Auto-Submit: Youkichi Hosoi <youkichihosoi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#747219}

chromeos/constants/chromeos_switches.cc

@@ -264,9 +264,18 @@ const char kEnableEncryptionMigration[] = "enable-encryption-migration";
 // Enables sharing assets for installed default apps.
 const char kEnableExtensionAssetsSharing[] = "enable-extension-assets-sharing";
 
+// Enables the use of Houdini library for ARM binary translation.
+const char kEnableHoudini[] = "enable-houdini";
+
+// Enables the use of Houdini 64-bit library for ARM binary translation.
+const char kEnableHoudini64[] = "enable-houdini64";
+
 // Enables the marketing opt-in screen in OOBE.
 const char kEnableMarketingOptInScreen[] = "enable-market-opt-in";
 
+// Enables the use of NDK translation library for ARM binary translation.
+const char kEnableNdkTranslation[] = "enable-ndk-translation";
+
 // Enables request of tablet site (via user agent override).
 const char kEnableRequestTabletSite[] = "enable-request-tablet-site";
 

chromeos/constants/chromeos_switches.h

@@ -111,8 +111,11 @@ COMPONENT_EXPORT(CHROMEOS_CONSTANTS)
 extern const char kEnableEncryptionMigration[];
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS)
 extern const char kEnableExtensionAssetsSharing[];
+COMPONENT_EXPORT(CHROMEOS_CONSTANTS) extern const char kEnableHoudini[];
+COMPONENT_EXPORT(CHROMEOS_CONSTANTS) extern const char kEnableHoudini64[];
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS)
 extern const char kEnableMarketingOptInScreen[];
+COMPONENT_EXPORT(CHROMEOS_CONSTANTS) extern const char kEnableNdkTranslation[];
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS)
 extern const char kEnableRequestTabletSite[];
 COMPONENT_EXPORT(CHROMEOS_CONSTANTS)

components/arc/session/arc_vm_client_adapter.cc

@@ -30,6 +30,7 @@
 #include "base/task/task_traits.h"
 #include "base/task/thread_pool.h"
 #include "base/time/time.h"
+#include "chromeos/constants/chromeos_switches.h"
 #include "chromeos/dbus/concierge_client.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ -87,6 +88,27 @@ std::string MonotonicTimestamp() {
   return base::NumberToString(time);
 }
 
+ArcBinaryTranslationType IdentifyBinaryTranslationType(
+    const StartParams& start_params) {
+  const auto* command_line = base::CommandLine::ForCurrentProcess();
+  bool is_houdini_available =
+      command_line->HasSwitch(chromeos::switches::kEnableHoudini) ||
+      command_line->HasSwitch(chromeos::switches::kEnableHoudini64);
+  bool is_ndk_translation_available =
+      command_line->HasSwitch(chromeos::switches::kEnableNdkTranslation);
+
+  if (!is_houdini_available && !is_ndk_translation_available)
+    return ArcBinaryTranslationType::NONE;
+
+  const bool prefer_ndk_translation =
+      !is_houdini_available || start_params.native_bridge_experiment;
+
+  if (is_ndk_translation_available && prefer_ndk_translation)
+    return ArcBinaryTranslationType::NDK_TRANSLATION;
+
+  return ArcBinaryTranslationType::HOUDINI;
+}
+
 std::vector<std::string> GenerateKernelCmdline(
     const StartParams& start_params,
     const UpgradeParams& upgrade_params,
@@ -96,12 +118,24 @@ std::vector<std::string> GenerateKernelCmdline(
     const std::string& channel,
     const std::string& serial_number) {
   DCHECK(!serial_number.empty());
+
+  std::string native_bridge;
+  switch (IdentifyBinaryTranslationType(start_params)) {
+    case ArcBinaryTranslationType::NONE:
+      native_bridge = "0";
+      break;
+    case ArcBinaryTranslationType::HOUDINI:
+      native_bridge = "libhoudini.so";
+      break;
+    case ArcBinaryTranslationType::NDK_TRANSLATION:
+      native_bridge = "libndk_translation.so";
+      break;
+  }
+
   std::vector<std::string> result = {
       "androidboot.hardware=bertha",
       "androidboot.container=1",
-      // TODO(b/139480143): when |start_params.native_bridge_experiment| is
-      // enabled, switch to ndk_translation.
-      "androidboot.native_bridge=libhoudini.so",
+      base::StringPrintf("androidboot.native_bridge=%s", native_bridge.c_str()),
       base::StringPrintf("androidboot.dev_mode=%d", is_dev_mode),
       base::StringPrintf("androidboot.disable_runas=%d", !is_dev_mode),
       base::StringPrintf("androidboot.vm=%d", is_host_on_vm),

components/arc/session/arc_vm_client_adapter.h

@@ -14,6 +14,14 @@
 
 namespace arc {
 
+// Enum that describes which native bridge mode is used to run arm binaries on
+// x86.
+enum class ArcBinaryTranslationType {
+  NONE,
+  HOUDINI,
+  NDK_TRANSLATION,
+};
+
 // Returns an adapter for arcvm.
 std::unique_ptr<ArcClientAdapter> CreateArcVmClientAdapter(
     version_info::Channel channel);

components/arc/session/arc_vm_client_adapter_unittest.cc

@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
@@ -819,5 +820,91 @@ TEST_F(ArcVmClientAdapterTest, TestCreateArcVmClientAdapter) {
   CreateArcVmClientAdapter(version_info::Channel::DEV);
 }
 
+// Tests that the binary translation type is set to None when no library is
+// enabled by USE flags.
+TEST_F(ArcVmClientAdapterTest, BintaryTranslationTypeNone) {
+  base::CommandLine::ForCurrentProcess()->InitFromArgv({""});
+  StartParams start_params(GetPopulatedStartParams());
+  SetValidUserInfo();
+  StartMiniArcWithParams(true, std::move(start_params));
+  UpgradeArc(true);
+  EXPECT_TRUE(
+      base::Contains(GetTestConciergeClient()->start_arc_vm_request().params(),
+                     "androidboot.native_bridge=0"));
+}
+
+// Tests that the binary translation type is set to Houdini when only Houdini
+// library is enabled by USE flags.
+TEST_F(ArcVmClientAdapterTest, BintaryTranslationTypeHoudini) {
+  base::CommandLine::ForCurrentProcess()->InitFromArgv(
+      {"", "--enable-houdini"});
+  StartParams start_params(GetPopulatedStartParams());
+  SetValidUserInfo();
+  StartMiniArcWithParams(true, std::move(start_params));
+  UpgradeArc(true);
+  EXPECT_TRUE(
+      base::Contains(GetTestConciergeClient()->start_arc_vm_request().params(),
+                     "androidboot.native_bridge=libhoudini.so"));
+}
+
+// Tests that the binary translation type is set to Houdini when only Houdini
+// 64-bit library is enabled by USE flags.
+TEST_F(ArcVmClientAdapterTest, BintaryTranslationTypeHoudini64) {
+  base::CommandLine::ForCurrentProcess()->InitFromArgv(
+      {"", "--enable-houdini64"});
+  StartParams start_params(GetPopulatedStartParams());
+  SetValidUserInfo();
+  StartMiniArcWithParams(true, std::move(start_params));
+  UpgradeArc(true);
+  EXPECT_TRUE(
+      base::Contains(GetTestConciergeClient()->start_arc_vm_request().params(),
+                     "androidboot.native_bridge=libhoudini.so"));
+}
+
+// Tests that the binary translation type is set to NDK translation when only
+// NDK translation library is enabled by USE flags.
+TEST_F(ArcVmClientAdapterTest, BintaryTranslationTypeNdkTranslation) {
+  base::CommandLine::ForCurrentProcess()->InitFromArgv(
+      {"", "--enable-ndk-translation"});
+  StartParams start_params(GetPopulatedStartParams());
+  SetValidUserInfo();
+  StartMiniArcWithParams(true, std::move(start_params));
+  UpgradeArc(true);
+  EXPECT_TRUE(
+      base::Contains(GetTestConciergeClient()->start_arc_vm_request().params(),
+                     "androidboot.native_bridge=libndk_translation.so"));
+}
+
+// Tests that the binary translation type is set to NDK translation when both
+// Houdini and NDK translation libraries are enabled by USE flags, and the
+// parameter start_params.native_bridge_experiment is set.
+TEST_F(ArcVmClientAdapterTest, BintaryTranslationTypeNativeBridgeExperiment) {
+  base::CommandLine::ForCurrentProcess()->InitFromArgv(
+      {"", "--enable-houdini", "--enable-ndk-translation"});
+  StartParams start_params(GetPopulatedStartParams());
+  SetValidUserInfo();
+  StartMiniArcWithParams(true, std::move(start_params));
+  UpgradeArc(true);
+  EXPECT_TRUE(
+      base::Contains(GetTestConciergeClient()->start_arc_vm_request().params(),
+                     "androidboot.native_bridge=libndk_translation.so"));
+}
+
+// Tests that the binary translation type is set to Houdini when both Houdini
+// and NDK translation libraries are enabled by USE flags, and the parameter
+// start_params.native_bridge_experiment is not set.
+TEST_F(ArcVmClientAdapterTest, BintaryTranslationTypeNoNativeBridgeExperiment) {
+  base::CommandLine::ForCurrentProcess()->InitFromArgv(
+      {"", "--enable-houdini", "--enable-ndk-translation"});
+  StartParams start_params(GetPopulatedStartParams());
+  start_params.native_bridge_experiment = false;
+  SetValidUserInfo();
+  StartMiniArcWithParams(true, std::move(start_params));
+  UpgradeArc(true);
+  EXPECT_TRUE(
+      base::Contains(GetTestConciergeClient()->start_arc_vm_request().params(),
+                     "androidboot.native_bridge=libhoudini.so"));
+}
+
 }  // namespace
 }  // namespace arc