arc: Use platform-neutral types in arc_client_adapter.h

Previously, the ARC start and upgrade functions in the adapter
interface had two issues:

* They used structs in arc.proto that were in the login_manager::
  namespace although the interface is both for ARC container and
  VM.
* Parameters for upgrade were converted from the platform-neutral
  one (UpdateParams in arc_session.h) into the platform specific
  one (arc.proto) too early in arc_session_impl.cc.

This CL fixes both issues by removing arc.proto usage from
everywhere but arc_container_client_adapter.cc.

BUG=b:142144019
TEST=ran the unit tests + arc.Boot

Change-Id: I6b14631af8a3f24f879a037df0b0c289845edf95
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1854465
Commit-Queue: Yusuke Sato <yusukes@chromium.org>
Auto-Submit: Yusuke Sato <yusukes@chromium.org>
Reviewed-by: Hidehiko Abe <hidehiko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#707127}

chrome/browser/chromeos/arc/session/arc_session_manager.cc

@@ -49,10 +49,12 @@
 #include "components/arc/metrics/stability_metrics_manager.h"
 #include "components/arc/session/arc_data_remover.h"
 #include "components/arc/session/arc_instance_mode.h"
+#include "components/arc/session/arc_session.h"
 #include "components/arc/session/arc_session_runner.h"
 #include "components/arc/session/arc_supervision_transition.h"
 #include "components/prefs/pref_service.h"
 #include "components/session_manager/core/session_manager.h"
+#include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/display/types/display_constants.h"
 
@@ -1022,7 +1024,7 @@ void ArcSessionManager::StartArc() {
     GetLocaleAndPreferredLanguages(profile_, &locale, &preferred_languages);
   }
 
-  ArcSession::UpgradeParams params;
+  UpgradeParams params;
 
   const chromeos::DemoSession* demo_session = chromeos::DemoSession::Get();
   params.is_demo_session = demo_session && demo_session->started();
@@ -1038,6 +1040,12 @@ void ArcSessionManager::StartArc() {
   params.preferred_languages = base::SplitString(
       preferred_languages, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
+  DCHECK(user_manager->GetPrimaryUser());
+  params.account_id =
+      cryptohome::Identification(user_manager->GetPrimaryUser()->GetAccountId())
+          .id();
+
   arc_session_runner_->RequestUpgrade(std::move(params));
 }
 

components/arc/BUILD.gn

@@ -213,6 +213,10 @@ static_library("arc_base") {
     "session/arc_session_impl.h",
     "session/arc_session_runner.cc",
     "session/arc_session_runner.h",
+    "session/arc_start_params.cc",
+    "session/arc_start_params.h",
+    "session/arc_upgrade_params.cc",
+    "session/arc_upgrade_params.h",
     "session/arc_vm_client_adapter.cc",
     "session/arc_vm_client_adapter.h",
   ]

components/arc/session/arc_client_adapter.h

@@ -10,14 +10,12 @@
 
 #include "base/macros.h"
 #include "base/observer_list.h"
-#include "chromeos/dbus/session_manager/session_manager_client.h"
+#include "chromeos/dbus/dbus_method_call_status.h"
+#include "components/arc/session/arc_start_params.h"
+#include "components/arc/session/arc_upgrade_params.h"
 
 namespace arc {
 
-using StartArcMiniContainerRequest =
-    login_manager::StartArcMiniContainerRequest;
-using UpgradeArcContainerRequest = login_manager::UpgradeArcContainerRequest;
-
 // An adapter to talk to a Chrome OS daemon to manage lifetime of ARC instance.
 class ArcClientAdapter {
  public:
@@ -33,11 +31,11 @@ class ArcClientAdapter {
 
   // StartMiniArc starts ARC with only a handful of ARC processes for Chrome OS
   // login screen.
-  virtual void StartMiniArc(const StartArcMiniContainerRequest& request,
+  virtual void StartMiniArc(StartParams params,
                             chromeos::VoidDBusMethodCallback callback) = 0;
 
   // UpgradeArc upgrades a mini ARC instance to a full ARC instance.
-  virtual void UpgradeArc(const UpgradeArcContainerRequest& request,
+  virtual void UpgradeArc(UpgradeParams params,
                           chromeos::VoidDBusMethodCallback callback) = 0;
 
   // Asynchronously stops the ARC instance.

components/arc/session/arc_container_client_adapter.cc

@@ -13,8 +13,59 @@
 #include "chromeos/dbus/login_manager/arc.pb.h"
 #include "chromeos/dbus/session_manager/session_manager_client.h"
 #include "chromeos/dbus/upstart/upstart_client.h"
+#include "components/arc/session/arc_session.h"
 
 namespace arc {
+namespace {
+
+// Converts PackageCacheMode into login_manager's.
+login_manager::UpgradeArcContainerRequest_PackageCacheMode
+ToLoginManagerPackageCacheMode(UpgradeParams::PackageCacheMode mode) {
+  switch (mode) {
+    case UpgradeParams::PackageCacheMode::DEFAULT:
+      return login_manager::UpgradeArcContainerRequest_PackageCacheMode_DEFAULT;
+    case UpgradeParams::PackageCacheMode::COPY_ON_INIT:
+      return login_manager::
+          UpgradeArcContainerRequest_PackageCacheMode_COPY_ON_INIT;
+    case UpgradeParams::PackageCacheMode::SKIP_SETUP_COPY_ON_INIT:
+      return login_manager::
+          UpgradeArcContainerRequest_PackageCacheMode_SKIP_SETUP_COPY_ON_INIT;
+  }
+}
+
+// Converts ArcSupervisionTransition into login_manager's.
+login_manager::UpgradeArcContainerRequest_SupervisionTransition
+ToLoginManagerSupervisionTransition(ArcSupervisionTransition transition) {
+  switch (transition) {
+    case ArcSupervisionTransition::NO_TRANSITION:
+      return login_manager::
+          UpgradeArcContainerRequest_SupervisionTransition_NONE;
+    case ArcSupervisionTransition::CHILD_TO_REGULAR:
+      return login_manager::
+          UpgradeArcContainerRequest_SupervisionTransition_CHILD_TO_REGULAR;
+    case ArcSupervisionTransition::REGULAR_TO_CHILD:
+      return login_manager::
+          UpgradeArcContainerRequest_SupervisionTransition_REGULAR_TO_CHILD;
+  }
+}
+
+// Converts PlayStoreAutoUpdate into login_manager's.
+login_manager::StartArcMiniContainerRequest_PlayStoreAutoUpdate
+ToLoginManagerPlayStoreAutoUpdate(StartParams::PlayStoreAutoUpdate update) {
+  switch (update) {
+    case StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_DEFAULT:
+      return login_manager::
+          StartArcMiniContainerRequest_PlayStoreAutoUpdate_AUTO_UPDATE_DEFAULT;
+    case StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_ON:
+      return login_manager::
+          StartArcMiniContainerRequest_PlayStoreAutoUpdate_AUTO_UPDATE_ON;
+    case StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_OFF:
+      return login_manager::
+          StartArcMiniContainerRequest_PlayStoreAutoUpdate_AUTO_UPDATE_OFF;
+  }
+}
+
+}  // namespace
 
 class ArcContainerClientAdapter
     : public ArcClientAdapter,
@@ -36,14 +87,40 @@ class ArcContainerClientAdapter
   }
 
   // ArcClientAdapter overrides:
-  void StartMiniArc(const StartArcMiniContainerRequest& request,
+  void StartMiniArc(StartParams params,
                     chromeos::VoidDBusMethodCallback callback) override {
+    login_manager::StartArcMiniContainerRequest request;
+    request.set_native_bridge_experiment(params.native_bridge_experiment);
+    request.set_lcd_density(params.lcd_density);
+    request.set_arc_file_picker_experiment(params.arc_file_picker_experiment);
+    request.set_play_store_auto_update(
+        ToLoginManagerPlayStoreAutoUpdate(params.play_store_auto_update));
+    request.set_arc_custom_tabs_experiment(params.arc_custom_tabs_experiment);
+    request.set_arc_print_spooler_experiment(
+        params.arc_print_spooler_experiment);
+    request.set_num_cores_disabled(params.num_cores_disabled);
+
     chromeos::SessionManagerClient::Get()->StartArcMiniContainer(
         request, std::move(callback));
   }
 
-  void UpgradeArc(const UpgradeArcContainerRequest& request,
+  void UpgradeArc(UpgradeParams params,
                   chromeos::VoidDBusMethodCallback callback) override {
+    login_manager::UpgradeArcContainerRequest request;
+    request.set_account_id(params.account_id);
+    request.set_skip_boot_completed_broadcast(
+        params.skip_boot_completed_broadcast);
+    request.set_packages_cache_mode(
+        ToLoginManagerPackageCacheMode(params.packages_cache_mode));
+    request.set_skip_gms_core_cache(params.skip_gms_core_cache);
+    request.set_is_demo_session(params.is_demo_session);
+    request.set_demo_session_apps_path(params.demo_session_apps_path.value());
+    request.set_locale(params.locale);
+    for (const auto& language : params.preferred_languages)
+      request.add_preferred_languages(language);
+    request.set_supervision_transition(
+        ToLoginManagerSupervisionTransition(params.supervision_transition));
+
     chromeos::SessionManagerClient::Get()->UpgradeArcContainer(
         request, std::move(callback));
   }

components/arc/session/arc_session.cc

@@ -8,13 +8,6 @@
 
 namespace arc {
 
-ArcSession::UpgradeParams::UpgradeParams() = default;
-ArcSession::UpgradeParams::UpgradeParams(ArcSession::UpgradeParams&& other) =
-    default;
-ArcSession::UpgradeParams& ArcSession::UpgradeParams::operator=(
-    ArcSession::UpgradeParams&& other) = default;
-ArcSession::UpgradeParams::~UpgradeParams() = default;
-
 ArcSession::ArcSession() = default;
 ArcSession::~ArcSession() = default;
 

components/arc/session/arc_session.h

@@ -7,22 +7,16 @@
 
 #include <memory>
 #include <string>
-#include <vector>
 
-#include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "components/arc/session/arc_stop_reason.h"
-#include "components/arc/session/arc_supervision_transition.h"
+#include "components/arc/session/arc_upgrade_params.h"
 
 namespace ash {
 class DefaultScaleFactorRetriever;
 }
 
-namespace base {
-class FilePath;
-}
-
 namespace chromeos {
 class SchedulerConfigurationManagerBase;
 }
@@ -39,16 +33,16 @@ class ArcBridgeService;
 // Clients should implement the Delegate to be notified upon communications
 // being available.
 // The instance can be safely removed before StartMiniInstance() is called, or
-// after OnSessionStopped() is called.  The number of instances must be at most
-// one. Otherwise, ARC instances will conflict.
+// after OnSessionStopped() is called.  The number of instances must be at
+// most one. Otherwise, ARC instances will conflict.
 class ArcSession {
  public:
   // Observer to notify events corresponding to one ARC session run.
   class Observer {
    public:
     // Called when ARC instance is stopped. This is called exactly once per
-    // instance.  |was_running| is true if the stopped instance was fully set up
-    // and running. |full_requested| is true if the full container was
+    // instance.  |was_running| is true if the stopped instance was fully set
+    // up and running. |full_requested| is true if the full container was
     // requested.
     virtual void OnSessionStopped(ArcStopReason reason,
                                   bool was_running,
@@ -58,40 +52,6 @@ class ArcSession {
     virtual ~Observer() = default;
   };
 
-  // Parameters to upgrade request.
-  struct UpgradeParams {
-    // Explicit ctor/dtor declaration is necessary for complex struct. See
-    // https://cs.chromium.org/chromium/src/tools/clang/plugins/FindBadConstructsConsumer.cpp
-    UpgradeParams();
-    ~UpgradeParams();
-    UpgradeParams(UpgradeParams&& other);
-    UpgradeParams& operator=(UpgradeParams&& other);
-
-    // The supervision transition state for this account. Indicates whether
-    // child account should become regular, regular account should become child
-    // or neither.
-    ArcSupervisionTransition supervision_transition =
-        ArcSupervisionTransition::NO_TRANSITION;
-
-    // Define language configuration set during Android container boot.
-    // |preferred_languages| may be empty.
-    std::string locale;
-    std::vector<std::string> preferred_languages;
-
-    // Whether ARC is being upgraded in a demo session.
-    bool is_demo_session = false;
-
-    // |demo_session_apps_path| is a file path to the image containing set of
-    // demo apps that should be pre-installed into the Android container for
-    // demo sessions. It might be empty, in which case no demo apps will be
-    // pre-installed.
-    // Should be empty if |is_demo_session| is not set.
-    base::FilePath demo_session_apps_path;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(UpgradeParams);
-  };
-
   // Creates a default instance of ArcSession.
   static std::unique_ptr<ArcSession> Create(
       ArcBridgeService* arc_bridge_service,
@@ -104,8 +64,8 @@ class ArcSession {
   // Sends D-Bus message to start a mini-container.
   virtual void StartMiniInstance() = 0;
 
-  // Sends a D-Bus message to upgrade to a full instance if possible. This might
-  // be done asynchronously; the message might only be sent after other
+  // Sends a D-Bus message to upgrade to a full instance if possible. This
+  // might be done asynchronously; the message might only be sent after other
   // operations have completed.
   virtual void RequestUpgrade(UpgradeParams params) = 0;
 

components/arc/session/arc_session_impl.cc

@@ -27,7 +27,6 @@
 #include "base/task/task_traits.h"
 #include "chromeos/constants/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
-#include "chromeos/dbus/login_manager/arc.pb.h"
 #include "chromeos/system/scheduler_configuration_manager_base.h"
 #include "components/arc/arc_features.h"
 #include "components/arc/arc_util.h"
@@ -83,27 +82,6 @@ bool WaitForSocketReadable(int raw_socket_fd, int raw_cancel_fd) {
   return true;
 }
 
-// Converts ArcSupervisionTransition into
-// login_manager::UpgradeArcContainerRequest_SupervisionTransition.
-login_manager::UpgradeArcContainerRequest_SupervisionTransition
-ToLoginManagerSupervisionTransition(ArcSupervisionTransition transition) {
-  switch (transition) {
-    case ArcSupervisionTransition::NO_TRANSITION:
-      return login_manager::
-          UpgradeArcContainerRequest_SupervisionTransition_NONE;
-    case ArcSupervisionTransition::CHILD_TO_REGULAR:
-      return login_manager::
-          UpgradeArcContainerRequest_SupervisionTransition_CHILD_TO_REGULAR;
-    case ArcSupervisionTransition::REGULAR_TO_CHILD:
-      return login_manager::
-          UpgradeArcContainerRequest_SupervisionTransition_REGULAR_TO_CHILD;
-    default:
-      NOTREACHED() << "Invalid transition " << transition;
-      return login_manager::
-          UpgradeArcContainerRequest_SupervisionTransition_NONE;
-  }
-}
-
 // Real Delegate implementation to connect Mojo.
 class ArcSessionDelegateImpl : public ArcSessionImpl::Delegate {
  public:
@@ -325,9 +303,6 @@ void ArcSessionDelegateImpl::OnMojoConnected(
 
 }  // namespace
 
-const char ArcSessionImpl::kPackagesCacheModeCopy[] = "copy";
-const char ArcSessionImpl::kPackagesCacheModeSkipCopy[] = "skip-copy";
-
 // static
 std::unique_ptr<ArcSessionImpl::Delegate> ArcSessionImpl::CreateDelegate(
     ArcBridgeService* arc_bridge_service,
@@ -384,24 +359,24 @@ void ArcSessionImpl::OnLcdDensity(int32_t lcd_density) {
 
 void ArcSessionImpl::DoStartMiniInstance(size_t num_cores_disabled) {
   DCHECK_GT(lcd_density_, 0);
-  StartArcMiniContainerRequest request;
-  request.set_native_bridge_experiment(
-      base::FeatureList::IsEnabled(arc::kNativeBridgeToggleFeature));
-  request.set_arc_file_picker_experiment(
-      base::FeatureList::IsEnabled(arc::kFilePickerExperimentFeature));
+  StartParams params;
+  params.native_bridge_experiment =
+      base::FeatureList::IsEnabled(arc::kNativeBridgeToggleFeature);
+  params.arc_file_picker_experiment =
+      base::FeatureList::IsEnabled(arc::kFilePickerExperimentFeature);
   // Enable Custom Tabs only on Dev and Cannary, and only when Mash is enabled.
   const bool is_custom_tab_enabled =
       base::FeatureList::IsEnabled(arc::kCustomTabsExperimentFeature) &&
       delegate_->GetChannel() != version_info::Channel::STABLE &&
       delegate_->GetChannel() != version_info::Channel::BETA;
-  request.set_arc_custom_tabs_experiment(is_custom_tab_enabled);
+  params.arc_custom_tabs_experiment = is_custom_tab_enabled;
   const bool is_arc_print_spooler_enabled =
       base::FeatureList::IsEnabled(arc::kPrintSpoolerExperimentFeature) &&
       delegate_->GetChannel() != version_info::Channel::STABLE &&
       delegate_->GetChannel() != version_info::Channel::BETA;
-  request.set_arc_print_spooler_experiment(is_arc_print_spooler_enabled);
-  request.set_lcd_density(lcd_density_);
-  request.set_num_cores_disabled(num_cores_disabled);
+  params.arc_print_spooler_experiment = is_arc_print_spooler_enabled;
+  params.lcd_density = lcd_density_;
+  params.num_cores_disabled = num_cores_disabled;
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kArcPlayStoreAutoUpdate)) {
@@ -409,14 +384,12 @@ void ArcSessionImpl::DoStartMiniInstance(size_t num_cores_disabled) {
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             chromeos::switches::kArcPlayStoreAutoUpdate);
     if (value == kOn) {
-      request.set_play_store_auto_update(
-          login_manager::
-              StartArcMiniContainerRequest_PlayStoreAutoUpdate_AUTO_UPDATE_ON);
+      params.play_store_auto_update =
+          StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_ON;
       VLOG(1) << "Play Store auto-update is forced on";
     } else if (value == kOff) {
-      request.set_play_store_auto_update(
-          login_manager::
-              StartArcMiniContainerRequest_PlayStoreAutoUpdate_AUTO_UPDATE_OFF);
+      params.play_store_auto_update =
+          StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_OFF;
       VLOG(1) << "Play Store auto-update is forced off";
     } else {
       LOG(ERROR) << "Invalid parameter " << value << " for "
@@ -425,10 +398,10 @@ void ArcSessionImpl::DoStartMiniInstance(size_t num_cores_disabled) {
   }
 
   VLOG(1) << "Starting ARC mini instance with lcd_density="
-          << request.lcd_density()
-          << ", num_cores_disabled=" << request.num_cores_disabled();
+          << params.lcd_density
+          << ", num_cores_disabled=" << params.num_cores_disabled;
 
-  client_->StartMiniArc(request,
+  client_->StartMiniArc(std::move(params),
                         base::BindOnce(&ArcSessionImpl::OnMiniInstanceStarted,
                                        weak_factory_.GetWeakPtr()));
 }
@@ -534,54 +507,10 @@ void ArcSessionImpl::OnSocketCreated(base::ScopedFD socket_fd) {
   }
 
   VLOG(2) << "Socket is created. Starting ARC container";
-  UpgradeArcContainerRequest request;
-  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
-  DCHECK(user_manager->GetPrimaryUser());
-
-  request.set_account_id(
-      cryptohome::Identification(user_manager->GetPrimaryUser()->GetAccountId())
-          .id());
-  request.set_skip_boot_completed_broadcast(
-      !base::FeatureList::IsEnabled(arc::kBootCompletedBroadcastFeature));
-
-  // Set packages cache mode coming from autotests.
-  const std::string packages_cache_mode_string =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          chromeos::switches::kArcPackagesCacheMode);
-  if (packages_cache_mode_string == kPackagesCacheModeSkipCopy) {
-    request.set_packages_cache_mode(
-        login_manager::
-            UpgradeArcContainerRequest_PackageCacheMode_SKIP_SETUP_COPY_ON_INIT);
-  } else if (packages_cache_mode_string == kPackagesCacheModeCopy) {
-    request.set_packages_cache_mode(
-        login_manager::
-            UpgradeArcContainerRequest_PackageCacheMode_COPY_ON_INIT);
-  } else if (!packages_cache_mode_string.empty()) {
-    VLOG(2) << "Invalid packages cache mode switch "
-            << packages_cache_mode_string << ".";
-  }
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kArcDisableGmsCoreCache)) {
-    request.set_skip_gms_core_cache(true);
-  }
-
-  request.set_supervision_transition(ToLoginManagerSupervisionTransition(
-      upgrade_params_.supervision_transition));
-  request.set_locale(upgrade_params_.locale);
-  for (const std::string& language : upgrade_params_.preferred_languages)
-    request.add_preferred_languages(language);
-
-  request.set_is_demo_session(upgrade_params_.is_demo_session);
-  if (!upgrade_params_.demo_session_apps_path.empty()) {
-    DCHECK(upgrade_params_.is_demo_session);
-    request.set_demo_session_apps_path(
-        upgrade_params_.demo_session_apps_path.value());
-  }
-
-  client_->UpgradeArc(request, base::BindOnce(&ArcSessionImpl::OnUpgraded,
-                                              weak_factory_.GetWeakPtr(),
-                                              std::move(socket_fd)));
+  client_->UpgradeArc(
+      std::move(upgrade_params_),
+      base::BindOnce(&ArcSessionImpl::OnUpgraded, weak_factory_.GetWeakPtr(),
+                     std::move(socket_fd)));
 }
 
 void ArcSessionImpl::OnUpgraded(base::ScopedFD socket_fd, bool result) {

components/arc/session/arc_session_impl.h

@@ -136,9 +136,6 @@ class ArcSessionImpl
     STOPPED,
   };
 
-  static const char kPackagesCacheModeCopy[];
-  static const char kPackagesCacheModeSkipCopy[];
-
   // Delegate interface to emulate ArcBridgeHost mojo connection establishment.
   class Delegate {
    public:

components/arc/session/arc_session_impl_unittest.cc

@@ -35,8 +35,8 @@ constexpr char kFakeGmail[] = "user@gmail.com";
 constexpr char kFakeGmailGaiaId[] = "1234567890";
 constexpr char kDefaultLocale[] = "en-US";
 
-ArcSession::UpgradeParams DefaultUpgradeParams() {
-  ArcSession::UpgradeParams params;
+UpgradeParams DefaultUpgradeParams() {
+  UpgradeParams params;
   params.locale = kDefaultLocale;
   return params;
 }
@@ -597,14 +597,14 @@ constexpr PackagesCacheModeState kPackagesCacheModeStates[] = {
      login_manager::UpgradeArcContainerRequest_PackageCacheMode_DEFAULT},
     {nullptr, false,
      login_manager::UpgradeArcContainerRequest_PackageCacheMode_DEFAULT},
-    {ArcSessionImpl::kPackagesCacheModeCopy, true,
+    {kPackagesCacheModeCopy, true,
      login_manager::UpgradeArcContainerRequest_PackageCacheMode_COPY_ON_INIT},
-    {ArcSessionImpl::kPackagesCacheModeCopy, false,
+    {kPackagesCacheModeCopy, false,
      login_manager::UpgradeArcContainerRequest_PackageCacheMode_DEFAULT},
-    {ArcSessionImpl::kPackagesCacheModeSkipCopy, true,
+    {kPackagesCacheModeSkipCopy, true,
      login_manager::
          UpgradeArcContainerRequest_PackageCacheMode_SKIP_SETUP_COPY_ON_INIT},
-    {ArcSessionImpl::kPackagesCacheModeCopy, false,
+    {kPackagesCacheModeCopy, false,
      login_manager::UpgradeArcContainerRequest_PackageCacheMode_DEFAULT},
 };
 
@@ -664,7 +664,7 @@ TEST_F(ArcSessionImplTest, DemoSession) {
 
   const std::string demo_apps_path =
       "/run/imageloader/demo_mode_resources/android_apps.squash";
-  ArcSession::UpgradeParams params;
+  UpgradeParams params;
   params.is_demo_session = true;
   params.demo_session_apps_path = base::FilePath(demo_apps_path);
   params.locale = kDefaultLocale;
@@ -683,7 +683,7 @@ TEST_F(ArcSessionImplTest, DemoSessionWithoutOfflineDemoApps) {
   auto arc_session = CreateArcSession();
   arc_session->StartMiniInstance();
 
-  ArcSession::UpgradeParams params;
+  UpgradeParams params;
   params.is_demo_session = true;
   params.locale = kDefaultLocale;
   arc_session->RequestUpgrade(std::move(params));
@@ -701,7 +701,7 @@ TEST_F(ArcSessionImplTest, SupervisionTransitionShouldGraduate) {
   auto arc_session = CreateArcSession();
   arc_session->StartMiniInstance();
 
-  ArcSession::UpgradeParams params;
+  UpgradeParams params;
   params.supervision_transition = ArcSupervisionTransition::CHILD_TO_REGULAR;
   params.locale = kDefaultLocale;
   arc_session->RequestUpgrade(std::move(params));

components/arc/session/arc_session_runner.cc

@@ -142,7 +142,7 @@ void ArcSessionRunner::RequestStartMiniInstance() {
   RequestStart(ArcInstanceMode::MINI_INSTANCE);
 }
 
-void ArcSessionRunner::RequestUpgrade(ArcSession::UpgradeParams params) {
+void ArcSessionRunner::RequestUpgrade(UpgradeParams params) {
   upgrade_params_ = std::move(params);
   RequestStart(ArcInstanceMode::FULL_INSTANCE);
 }

components/arc/session/arc_session_runner.h

@@ -20,6 +20,7 @@
 #include "components/arc/session/arc_instance_mode.h"
 #include "components/arc/session/arc_session.h"
 #include "components/arc/session/arc_stop_reason.h"
+#include "components/arc/session/arc_upgrade_params.h"
 
 namespace arc {
 
@@ -82,7 +83,7 @@ class ArcSessionRunner : public ArcSession::Observer {
 
   // Starts the full ARC instance, then it will connect the Mojo channel. When
   // the bridge becomes ready, registered Observer's OnSessionReady() is called.
-  void RequestUpgrade(ArcSession::UpgradeParams params);
+  void RequestUpgrade(UpgradeParams params);
 
   // Stops the ARC service.
   void RequestStop();
@@ -141,7 +142,7 @@ class ArcSessionRunner : public ArcSession::Observer {
   std::unique_ptr<ArcSession> arc_session_;
 
   // Parameters to upgrade request.
-  ArcSession::UpgradeParams upgrade_params_;
+  UpgradeParams upgrade_params_;
 
   // A hash string of the profile user ID.
   std::string user_id_hash_;

components/arc/session/arc_session_runner_unittest.cc

@@ -34,8 +34,8 @@ constexpr int kContainerCrashedEarly =
 constexpr int kContainerCrashed =
     static_cast<int>(ArcContainerLifetimeEvent::CONTAINER_CRASHED);
 
-ArcSession::UpgradeParams DefaultUpgradeParams() {
-  ArcSession::UpgradeParams params;
+UpgradeParams DefaultUpgradeParams() {
+  UpgradeParams params;
   params.locale = "en-US";
   return params;
 }

components/arc/session/arc_start_params.cc

+// 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.
+
+#include "components/arc/session/arc_start_params.h"
+
+namespace arc {
+
+StartParams::StartParams() = default;
+StartParams::~StartParams() = default;
+StartParams::StartParams(StartParams&& other) = default;
+StartParams& StartParams::operator=(StartParams&& other) = default;
+
+}  // namespace arc

components/arc/session/arc_start_params.h

+// 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.
+
+#ifndef COMPONENTS_ARC_SESSION_ARC_START_PARAMS_H_
+#define COMPONENTS_ARC_SESSION_ARC_START_PARAMS_H_
+
+#include <stdint.h>
+
+#include "base/macros.h"
+
+namespace arc {
+
+// Parameters to start request.
+struct StartParams {
+  enum class PlayStoreAutoUpdate {
+    // Play Store auto-update is left unchanged.
+    AUTO_UPDATE_DEFAULT = 0,
+    // Play Store auto-update is forced to on.
+    AUTO_UPDATE_ON,
+    // Play Store auto-update is forced to off.
+    AUTO_UPDATE_OFF,
+  };
+
+  StartParams();
+  ~StartParams();
+  StartParams(StartParams&& other);
+  StartParams& operator=(StartParams&& other);
+
+  bool native_bridge_experiment = false;
+  int lcd_density = -1;
+
+  // Experiment flag for go/arc-file-picker.
+  bool arc_file_picker_experiment = false;
+
+  // Optional mode for play store auto-update.
+  PlayStoreAutoUpdate play_store_auto_update =
+      PlayStoreAutoUpdate::AUTO_UPDATE_DEFAULT;
+
+  // Experiment flag for ARC Custom Tabs.
+  bool arc_custom_tabs_experiment = false;
+
+  // Experiment flag for ARC Print Spooler.
+  bool arc_print_spooler_experiment = false;
+
+  // The number of logical CPU cores that are currently disabled on the host.
+  // This parameter is used only for starting ARCVM.
+  uint32_t num_cores_disabled = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StartParams);
+};
+
+}  // namespace arc
+
+#endif  // COMPONENTS_ARC_SESSION_ARC_START_PARAMS_H_

components/arc/session/arc_upgrade_params.cc

+// 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.
+
+#include "components/arc/session/arc_upgrade_params.h"
+
+#include "base/command_line.h"
+#include "base/feature_list.h"
+#include "base/logging.h"
+#include "chromeos/constants/chromeos_switches.h"
+#include "components/arc/arc_features.h"
+
+namespace arc {
+namespace {
+
+UpgradeParams::PackageCacheMode GetPackagesCacheMode() {
+  // Set packages cache mode coming from autotests.
+  const std::string packages_cache_mode_string =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          chromeos::switches::kArcPackagesCacheMode);
+  if (packages_cache_mode_string == kPackagesCacheModeSkipCopy)
+    return UpgradeParams::PackageCacheMode::SKIP_SETUP_COPY_ON_INIT;
+  if (packages_cache_mode_string == kPackagesCacheModeCopy)
+    return UpgradeParams::PackageCacheMode::COPY_ON_INIT;
+
+  VLOG_IF(2, !packages_cache_mode_string.empty())
+      << "Invalid packages cache mode switch " << packages_cache_mode_string;
+  return UpgradeParams::PackageCacheMode::DEFAULT;
+}
+
+}  // namespace
+
+UpgradeParams::UpgradeParams()
+    : skip_boot_completed_broadcast(
+          !base::FeatureList::IsEnabled(arc::kBootCompletedBroadcastFeature)),
+      packages_cache_mode(GetPackagesCacheMode()),
+      skip_gms_core_cache(base::CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kArcDisableGmsCoreCache)) {}
+
+UpgradeParams::UpgradeParams(UpgradeParams&& other) = default;
+UpgradeParams& UpgradeParams::operator=(UpgradeParams&& other) = default;
+UpgradeParams::~UpgradeParams() = default;
+
+}  // namespace arc

components/arc/session/arc_upgrade_params.h

+// 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.
+
+#ifndef COMPONENTS_ARC_SESSION_ARC_UPGRADE_PARAMS_H_
+#define COMPONENTS_ARC_SESSION_ARC_UPGRADE_PARAMS_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include "base/files/file_path.h"
+#include "base/macros.h"
+#include "components/arc/session/arc_supervision_transition.h"
+
+namespace arc {
+
+constexpr char kPackagesCacheModeCopy[] = "copy";
+constexpr char kPackagesCacheModeSkipCopy[] = "skip-copy";
+
+// Parameters to upgrade request.
+struct UpgradeParams {
+  enum class PackageCacheMode {
+    // Performs packages cache setup if the pre-generated cache exists.
+    DEFAULT = 0,
+    // Performs packages cache setup if the pre-generated cache exists and
+    // copies resulting packages.xml to the temporary location after
+    // SystemServer initialized the package manager.
+    COPY_ON_INIT,
+    // Skips packages cache setup and copies resulting packages.xml to the
+    // temporary location after SystemServer initialized the package manager.
+    SKIP_SETUP_COPY_ON_INIT,
+  };
+
+  // Explicit ctor/dtor declaration is necessary for complex struct. See
+  // https://cs.chromium.org/chromium/src/tools/clang/plugins/FindBadConstructsConsumer.cpp
+  UpgradeParams();
+  ~UpgradeParams();
+  UpgradeParams(UpgradeParams&& other);
+  UpgradeParams& operator=(UpgradeParams&& other);
+
+  // Account ID of the user to start ARC for.
+  std::string account_id;
+
+  // Option to disable ACTION_BOOT_COMPLETED broadcast for 3rd party apps.
+  // The constructor automatically populates this from command-line.
+  bool skip_boot_completed_broadcast;
+
+  // Optional mode for packages cache tests.
+  // The constructor automatically populates this from command-line.
+  PackageCacheMode packages_cache_mode;
+
+  // Option to disable GMS CORE cache.
+  // The constructor automatically populates this from command-line.
+  bool skip_gms_core_cache;
+
+  // The supervision transition state for this account. Indicates whether
+  // child account should become regular, regular account should become child
+  // or neither.
+  ArcSupervisionTransition supervision_transition =
+      ArcSupervisionTransition::NO_TRANSITION;
+
+  // Define language configuration set during Android container boot.
+  // |preferred_languages| may be empty.
+  std::string locale;
+  std::vector<std::string> preferred_languages;
+
+  // Whether ARC is being upgraded in a demo session.
+  bool is_demo_session = false;
+
+  // |demo_session_apps_path| is a file path to the image containing set of
+  // demo apps that should be pre-installed into the Android container for
+  // demo sessions. It might be empty, in which case no demo apps will be
+  // pre-installed.
+  // Should be empty if |is_demo_session| is not set.
+  base::FilePath demo_session_apps_path;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(UpgradeParams);
+};
+
+}  // namespace arc
+
+#endif  // COMPONENTS_ARC_SESSION_ARC_UPGRADE_PARAMS_H_

components/arc/session/arc_vm_client_adapter.cc

@@ -35,11 +35,11 @@
 #include "chromeos/dbus/concierge_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/debug_daemon/debug_daemon_client.h"
-#include "chromeos/dbus/login_manager/arc.pb.h"
 #include "chromeos/dbus/upstart/upstart_client.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/arc/arc_features.h"
 #include "components/arc/arc_util.h"
+#include "components/arc/session/arc_session.h"
 
 namespace arc {
 namespace {
@@ -179,6 +179,8 @@ vm_tools::concierge::CreateDiskImageRequest CreateArcDiskRequest(
   return request;
 }
 
+// TODO(yusukes): ArcSessionImpl already has this info through the delegate.
+// Use it and remove this function.
 std::string GetReleaseChannel() {
   constexpr const char kUnknown[] = "unknown";
   const std::set<std::string> channels = {"beta",    "canary", "dev",
@@ -215,50 +217,46 @@ std::string MonotonicTimestamp() {
 }
 
 std::vector<std::string> GenerateKernelCmdline(
-    int32_t lcd_density,
-    const base::Optional<bool>& play_store_auto_update,
+    const StartParams& start_params,
     const FileSystemStatus& file_system_status,
     bool is_dev_mode,
     bool is_host_on_vm) {
-  const std::string release_channel = GetReleaseChannel();
-  const bool stable_or_beta =
-      release_channel == "stable" || release_channel == "beta";
-
   std::vector<std::string> result = {
       "androidboot.hardware=bertha",
       "androidboot.container=1",
-      // TODO(b/139480143): when ArcNativeBridgeExperiment is enabled, switch
-      // to ndk_translation.
+      // TODO(b/139480143): when |start_params.native_bridge_experiment| is
+      // enabled, switch to ndk_translation.
       "androidboot.native_bridge=libhoudini.so",
       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),
       base::StringPrintf("androidboot.debuggable=%d",
                          file_system_status.is_android_debuggable()),
-      base::StringPrintf("androidboot.lcd_density=%d", lcd_density),
-      base::StringPrintf(
-          "androidboot.arc_file_picker=%d",
-          base::FeatureList::IsEnabled(kFilePickerExperimentFeature)),
-      base::StringPrintf(
-          "androidboot.arc_custom_tabs=%d",
-          base::FeatureList::IsEnabled(kCustomTabsExperimentFeature) &&
-              !stable_or_beta),
-      base::StringPrintf(
-          "androidboot.arc_print_spooler=%d",
-          base::FeatureList::IsEnabled(kPrintSpoolerExperimentFeature) &&
-              !stable_or_beta),
-      "androidboot.chromeos_channel=" + release_channel,
+      base::StringPrintf("androidboot.lcd_density=%d",
+                         start_params.lcd_density),
+      base::StringPrintf("androidboot.arc_file_picker=%d",
+                         start_params.arc_file_picker_experiment),
+      base::StringPrintf("androidboot.arc_custom_tabs=%d",
+                         start_params.arc_custom_tabs_experiment),
+      base::StringPrintf("androidboot.arc_print_spooler=%d",
+                         start_params.arc_print_spooler_experiment),
+      "androidboot.chromeos_channel=" + GetReleaseChannel(),
       "androidboot.boottime_offset=" + MonotonicTimestamp(),
       // TODO(yusukes): remove this once arcvm supports SELinux.
       "androidboot.selinux=permissive",
   };
 
-  if (play_store_auto_update) {
-    result.push_back(base::StringPrintf("androidboot.play_store_auto_update=%d",
-                                        *play_store_auto_update));
+  switch (start_params.play_store_auto_update) {
+    case StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_DEFAULT:
+      break;
+    case StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_ON:
+      result.push_back("androidboot.play_store_auto_update=1");
+      break;
+    case StartParams::PlayStoreAutoUpdate::AUTO_UPDATE_OFF:
+      result.push_back("androidboot.play_store_auto_update=0");
+      break;
   }
 
-  // TODO(yusukes): include command line parameters from arcbootcontinue.
   return result;
 }
 
@@ -359,25 +357,14 @@ class ArcVmClientAdapter : public ArcClientAdapter,
   }
 
   // ArcClientAdapter overrides:
-  void StartMiniArc(const StartArcMiniContainerRequest& request,
+  void StartMiniArc(StartParams params,
                     chromeos::VoidDBusMethodCallback callback) override {
     // TODO(yusukes): Support mini ARC.
     VLOG(2) << "Mini ARCVM instance is not supported.";
-    // Save the lcd density and auto update mode for the later call to
-    // UpgradeArc.
-    lcd_density_ = request.lcd_density();
-    cpus_ = base::SysInfo::NumberOfProcessors() - request.num_cores_disabled();
-    DCHECK_LT(0u, cpus_);
-    if (request.play_store_auto_update() ==
-        login_manager::
-            StartArcMiniContainerRequest_PlayStoreAutoUpdate_AUTO_UPDATE_ON) {
-      play_store_auto_update_ = true;
-    } else if (
-        request.play_store_auto_update() ==
-        login_manager::
-            StartArcMiniContainerRequest_PlayStoreAutoUpdate_AUTO_UPDATE_OFF) {
-      play_store_auto_update_ = false;
-    }
+
+    // Save the parameters for the later call to UpgradeArc.
+    start_params_ = std::move(params);
+
     base::PostTaskAndReplyWithResult(
         FROM_HERE,
         {base::ThreadPool(), base::MayBlock(),
@@ -388,13 +375,14 @@ class ArcVmClientAdapter : public ArcClientAdapter,
                        weak_factory_.GetWeakPtr(), std::move(callback)));
   }
 
-  void UpgradeArc(const UpgradeArcContainerRequest& request,
+  void UpgradeArc(UpgradeParams params,
                   chromeos::VoidDBusMethodCallback callback) override {
     VLOG(1) << "Starting arcvm-server-proxy";
     chromeos::UpstartClient::Get()->StartJob(
         kArcVmServerProxyJobName, /*environment=*/{},
         base::BindOnce(&ArcVmClientAdapter::OnArcVmServerProxyJobStarted,
-                       weak_factory_.GetWeakPtr(), std::move(callback)));
+                       weak_factory_.GetWeakPtr(), std::move(params),
+                       std::move(callback)));
   }
 
   void StopArcInstance() override {
@@ -431,7 +419,8 @@ class ArcVmClientAdapter : public ArcClientAdapter,
     should_notify_observers_ = true;
   }
 
-  void OnConciergeStarted(chromeos::VoidDBusMethodCallback callback,
+  void OnConciergeStarted(UpgradeParams params,
+                          chromeos::VoidDBusMethodCallback callback,
                           bool success) {
     if (!success) {
       LOG(ERROR) << "Failed to start Concierge service for arcvm";
@@ -449,10 +438,13 @@ class ArcVmClientAdapter : public ArcClientAdapter,
         base::BindOnce(&base::SysInfo::AmountOfFreeDiskSpace,
                        base::FilePath(kHomeDirectory)),
         base::BindOnce(&ArcVmClientAdapter::CreateDiskImageAfterSizeCheck,
-                       weak_factory_.GetWeakPtr(), std::move(callback)));
+
+                       weak_factory_.GetWeakPtr(), std::move(params),
+                       std::move(callback)));
   }
 
-  void CreateDiskImageAfterSizeCheck(chromeos::VoidDBusMethodCallback callback,
+  void CreateDiskImageAfterSizeCheck(UpgradeParams params,
+                                     chromeos::VoidDBusMethodCallback callback,
                                      int64_t free_disk_bytes) {
     VLOG(2) << "Got free disk size: " << free_disk_bytes;
     if (user_id_hash_.empty()) {
@@ -464,12 +456,14 @@ class ArcVmClientAdapter : public ArcClientAdapter,
     GetConciergeClient()->CreateDiskImage(
         CreateArcDiskRequest(user_id_hash_, free_disk_bytes),
         base::BindOnce(&ArcVmClientAdapter::OnDiskImageCreated,
-                       weak_factory_.GetWeakPtr(), std::move(callback)));
+                       weak_factory_.GetWeakPtr(), std::move(params),
+                       std::move(callback)));
   }
 
   // TODO(pliard): Export host-side /data to the VM, and remove the first half
   // of the function.
   void OnDiskImageCreated(
+      UpgradeParams params,
       chromeos::VoidDBusMethodCallback callback,
       base::Optional<vm_tools::concierge::CreateDiskImageResponse> reply) {
     if (!reply.has_value()) {
@@ -496,21 +490,28 @@ class ArcVmClientAdapter : public ArcClientAdapter,
          base::TaskPriority::USER_VISIBLE},
         base::BindOnce(&FileSystemStatus::GetFileSystemStatusBlocking),
         base::BindOnce(&ArcVmClientAdapter::OnFileSystemStatus,
-                       weak_factory_.GetWeakPtr(), std::move(callback),
+                       weak_factory_.GetWeakPtr(), std::move(params),
+                       std::move(callback),
                        base::FilePath(response.disk_path())));
   }
 
-  void OnFileSystemStatus(chromeos::VoidDBusMethodCallback callback,
+  void OnFileSystemStatus(UpgradeParams params,
+                          chromeos::VoidDBusMethodCallback callback,
                           const base::FilePath& data_disk_path,
                           FileSystemStatus file_system_status) {
     VLOG(2) << "Got file system status";
+    const int32_t cpus =
+        base::SysInfo::NumberOfProcessors() - start_params_.num_cores_disabled;
+    DCHECK_LT(0, cpus);
+
+    // TODO(yusukes): Use |params| for generating kernel command line too.
     DCHECK(is_dev_mode_);
     std::vector<std::string> kernel_cmdline = GenerateKernelCmdline(
-        lcd_density_, play_store_auto_update_, file_system_status,
-        *is_dev_mode_, is_host_on_vm_);
+        start_params_, file_system_status, *is_dev_mode_, is_host_on_vm_);
     auto start_request =
-        CreateStartArcVmRequest(user_id_hash_, cpus_, data_disk_path,
+        CreateStartArcVmRequest(user_id_hash_, cpus, data_disk_path,
                                 file_system_status, std::move(kernel_cmdline));
+
     GetConciergeClient()->StartArcVm(
         start_request,
         base::BindOnce(&ArcVmClientAdapter::OnStartArcVmReply,
@@ -571,7 +572,8 @@ class ArcVmClientAdapter : public ArcClientAdapter,
     OnArcInstanceStopped();
   }
 
-  void OnArcVmServerProxyJobStarted(chromeos::VoidDBusMethodCallback callback,
+  void OnArcVmServerProxyJobStarted(UpgradeParams params,
+                                    chromeos::VoidDBusMethodCallback callback,
                                     bool result) {
     if (!result) {
       LOG(ERROR) << "Failed to start arcvm-server-proxy job";
@@ -582,7 +584,8 @@ class ArcVmClientAdapter : public ArcClientAdapter,
     VLOG(1) << "Starting Concierge service";
     chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->StartConcierge(
         base::BindOnce(&ArcVmClientAdapter::OnConciergeStarted,
-                       weak_factory_.GetWeakPtr(), std::move(callback)));
+                       weak_factory_.GetWeakPtr(), std::move(params),
+                       std::move(callback)));
   }
 
   void OnArcVmServerProxyJobStopped(bool result) {
@@ -596,10 +599,7 @@ class ArcVmClientAdapter : public ArcClientAdapter,
   // A hash of the primary profile user ID.
   std::string user_id_hash_;
 
-  int32_t lcd_density_;
-  uint32_t cpus_;
-  base::Optional<bool> play_store_auto_update_;
-
+  StartParams start_params_;
   bool should_notify_observers_ = false;
 
   // For callbacks.

components/arc/session/arc_vm_client_adapter_unittest.cc

@@ -16,9 +16,9 @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/debug_daemon/fake_debug_daemon_client.h"
 #include "chromeos/dbus/fake_concierge_client.h"
-#include "chromeos/dbus/login_manager/arc.pb.h"
 #include "chromeos/dbus/upstart/fake_upstart_client.h"
 #include "components/arc/arc_util.h"
+#include "components/arc/session/arc_session.h"
 #include "content/public/test/browser_task_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -143,21 +143,19 @@ class ArcVmClientAdapterTest : public testing::Test,
   void SetValidUserIdHash() { adapter()->SetUserIdHashForProfile(kUserIdHash); }
 
   void StartMiniArc() {
-    StartArcMiniContainerRequest req;
     adapter()->StartMiniArc(
-        req, base::BindOnce(&ArcVmClientAdapterTest::ExpectTrueThenQuit,
-                            base::Unretained(this)));
+        {}, base::BindOnce(&ArcVmClientAdapterTest::ExpectTrueThenQuit,
+                           base::Unretained(this)));
     run_loop()->Run();
     RecreateRunLoop();
   }
 
   void UpgradeArc(bool expect_success) {
-    UpgradeArcContainerRequest req;
     adapter()->UpgradeArc(
-        req, base::BindOnce(expect_success
-                                ? &ArcVmClientAdapterTest::ExpectTrueThenQuit
-                                : &ArcVmClientAdapterTest::ExpectFalseThenQuit,
-                            base::Unretained(this)));
+        {}, base::BindOnce(expect_success
+                               ? &ArcVmClientAdapterTest::ExpectTrueThenQuit
+                               : &ArcVmClientAdapterTest::ExpectFalseThenQuit,
+                           base::Unretained(this)));
     run_loop()->Run();
     RecreateRunLoop();
   }