Start ARC and sign in after Chrome OS login

chrome/browser/chromeos/arc/arc_session_manager_unittest.cc

 // Copyright 2016 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 <memory>
 #include <string>
 #include <tuple>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/prefs/pref_service_syncable_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
+#include "chrome/browser/ui/app_list/arc/arc_app_test.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "components/arc/arc_service_manager.h"
 #include "components/arc/arc_session_runner.h"
 #include "components/arc/arc_util.h"
 #include "components/arc/test/fake_arc_session.h"
@@ skipping 148 matching lines @@
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<TestingProfile> profile_;
   std::unique_ptr<ArcServiceManager> arc_service_manager_;
   std::unique_ptr<ArcSessionManager> arc_session_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   base::ScopedTempDir temp_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcSessionManagerTestBase);
 };
 
-class ArcSessionManagerTest : public ArcSessionManagerTestBase {
+// Intermediate class so that the children can inject test parameter freely.
+class AbstractArcSessionManagerTest : public ArcSessionManagerTestBase {
  public:
-  ArcSessionManagerTest() = default;
-
+  AbstractArcSessionManagerTest() = default;
   void SetUp() override {
     ArcSessionManagerTestBase::SetUp();
+    if (ShouldAlwaysStartArcInTest())
+      SetAlwaysStartArcForTesting();
 
     const AccountId account_id(AccountId::FromUserEmailGaiaId(
         profile()->GetProfileUserName(), "1234567890"));
     GetFakeUserManager()->AddUser(account_id);
     GetFakeUserManager()->LoginUser(account_id);
   }
 
+ protected:
+  virtual bool ShouldAlwaysStartArcInTest() = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AbstractArcSessionManagerTest);
+};
+
+class ArcSessionManagerTest : public AbstractArcSessionManagerTest,
+                              public ::testing::WithParamInterface<bool> {
+ public:
+  ArcSessionManagerTest() = default;
+
+ protected:
+  bool ShouldAlwaysStartArcInTest() override { return GetParam(); }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcSessionManagerTest);
 };
 
-TEST_F(ArcSessionManagerTest, PrefChangeTriggersService) {
+INSTANTIATE_TEST_CASE_P(, ArcSessionManagerTest, ::testing::Bool());
+
+TEST_P(ArcSessionManagerTest, PrefChangeTriggersService) {
+  // TODO(victorhsieh): Implement opt-in and opt-out flow.
+  if (ShouldAlwaysStartArc())
+    return;
+
   ASSERT_EQ(ArcSessionManager::State::NOT_INITIALIZED,
             arc_session_manager()->state());
 
   PrefService* const pref = profile()->GetPrefs();
   ASSERT_FALSE(pref->GetBoolean(prefs::kArcEnabled));
 
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
 
   ASSERT_TRUE(WaitForDataRemoved(ArcSessionManager::State::STOPPED));
 
   pref->SetBoolean(prefs::kArcEnabled, true);
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
             arc_session_manager()->state());
 
   pref->SetBoolean(prefs::kArcEnabled, false);
 
   ASSERT_TRUE(WaitForDataRemoved(ArcSessionManager::State::STOPPED));
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, DisabledForEphemeralDataUsers) {
+TEST_P(ArcSessionManagerTest, DisabledForEphemeralDataUsers) {
   PrefService* const prefs = profile()->GetPrefs();
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
   prefs->SetBoolean(prefs::kArcEnabled, true);
 
   chromeos::FakeChromeUserManager* const fake_user_manager =
       GetFakeUserManager();
 
   fake_user_manager->AddUser(fake_user_manager->GetGuestAccountId());
   fake_user_manager->SwitchActiveUser(fake_user_manager->GetGuestAccountId());
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
@@ skipping 24 matching lines @@
   fake_user_manager->RemoveUserFromList(not_in_list_account_id);
   arc_session_manager()->Shutdown();
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   ASSERT_EQ(ArcSessionManager::State::NOT_INITIALIZED,
             arc_session_manager()->state());
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, BaseWorkflow) {
+TEST_P(ArcSessionManagerTest, BaseWorkflow) {
+  // See BaseWorkflowOnPersistentArc for Persistent ARC flow.
+  if (ShouldAlwaysStartArc())
+    return;
+
   ASSERT_TRUE(arc_session_manager()->IsSessionStopped());
   ASSERT_EQ(ArcSessionManager::State::NOT_INITIALIZED,
             arc_session_manager()->state());
   EXPECT_TRUE(arc_session_manager()->sign_in_start_time().is_null());
   EXPECT_TRUE(arc_session_manager()->arc_start_time().is_null());
 
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
 
   // By default ARC is not enabled.
   ASSERT_TRUE(WaitForDataRemoved(ArcSessionManager::State::STOPPED));
@@ skipping 31 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // UI is disabled in unit tests and this code is unchanged.
   ASSERT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
             arc_session_manager()->state());
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, CancelFetchingDisablesArc) {
+TEST_P(ArcSessionManagerTest, CancelFetchingDisablesArc) {
+  // TODO(victorhsieh): Implement opt-in flow on Persistent ARC.
+  if (ShouldAlwaysStartArc())
+    return;
+
   PrefService* const pref = profile()->GetPrefs();
 
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   pref->SetBoolean(prefs::kArcEnabled, true);
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
             arc_session_manager()->state());
 
   arc_session_manager()->CancelAuthCode();
 
   // Wait until data is removed.
   ASSERT_TRUE(WaitForDataRemoved(ArcSessionManager::State::STOPPED));
 
   ASSERT_FALSE(pref->GetBoolean(prefs::kArcEnabled));
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, CloseUIKeepsArcEnabled) {
+TEST_P(ArcSessionManagerTest, CloseUIKeepsArcEnabled) {
   PrefService* const pref = profile()->GetPrefs();
 
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   pref->SetBoolean(prefs::kArcEnabled, true);
   base::RunLoop().RunUntilIdle();
 
   arc_session_manager()->StartArc();
 
   ASSERT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   arc_session_manager()->CancelAuthCode();
   ASSERT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
   ASSERT_TRUE(pref->GetBoolean(prefs::kArcEnabled));
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, EnableDisablesArc) {
+TEST_P(ArcSessionManagerTest, EnableDisablesArc) {
   const PrefService* pref = profile()->GetPrefs();
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
 
   EXPECT_FALSE(pref->GetBoolean(prefs::kArcEnabled));
   arc_session_manager()->SetArcPlayStoreEnabled(true);
   EXPECT_TRUE(pref->GetBoolean(prefs::kArcEnabled));
   arc_session_manager()->SetArcPlayStoreEnabled(false);
   EXPECT_FALSE(pref->GetBoolean(prefs::kArcEnabled));
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, SignInStatus) {
+TEST_P(ArcSessionManagerTest, SignInStatus) {
   PrefService* const prefs = profile()->GetPrefs();
 
   EXPECT_TRUE(arc_session_manager()->sign_in_start_time().is_null());
   EXPECT_TRUE(arc_session_manager()->arc_start_time().is_null());
 
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
   prefs->SetBoolean(prefs::kArcEnabled, true);
 
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
-  EXPECT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
-            arc_session_manager()->state());
+  if (ShouldAlwaysStartArc()) {
+    EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
+  } else {
+    EXPECT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
+              arc_session_manager()->state());
+  }
 
   // Emulate to accept the terms of service.
   prefs->SetBoolean(prefs::kArcTermsAccepted, true);
-  arc_session_manager()->StartArc();
+  if (!ShouldAlwaysStartArc()) {
+    arc_session_manager()->StartArc();
+  }
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
   EXPECT_TRUE(arc_session_manager()->IsSessionRunning());
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
   EXPECT_FALSE(arc_session_manager()->arc_start_time().is_null());
   arc_session_manager()->OnProvisioningFinished(ProvisioningResult::SUCCESS);
   EXPECT_TRUE(prefs->GetBoolean(prefs::kArcSignedIn));
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
   EXPECT_TRUE(arc_session_manager()->IsSessionRunning());
   EXPECT_TRUE(arc_session_manager()->sign_in_start_time().is_null());
 
@@ skipping 13 matching lines @@
   // On error, UI to send feedback is showing. In that case,
   // the ARC is still necessary to run on background for gathering the logs.
   EXPECT_TRUE(prefs->GetBoolean(prefs::kArcSignedIn));
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
   EXPECT_TRUE(arc_session_manager()->IsSessionRunning());
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, DisabledForDeviceLocalAccount) {
+TEST_P(ArcSessionManagerTest, DisabledForDeviceLocalAccount) {
   PrefService* const prefs = profile()->GetPrefs();
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
   prefs->SetBoolean(prefs::kArcEnabled, true);
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   arc_session_manager()->StartArc();
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   // Create device local account and set it as active.
   const std::string email = "device-local-account@fake-email.com";
   TestingProfile::Builder profile_builder;
@@ skipping 11 matching lines @@
   device_local_profile->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
   arc_session_manager()->OnPrimaryUserProfilePrepared(
       device_local_profile.get());
   EXPECT_EQ(ArcSessionManager::State::NOT_INITIALIZED,
             arc_session_manager()->state());
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, DisabledForNonPrimaryProfile) {
+TEST_P(ArcSessionManagerTest, DisabledForNonPrimaryProfile) {
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   arc_session_manager()->StartArc();
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   // Create a second profile and set it as the active profile.
   const std::string email = "test@example.com";
   TestingProfile::Builder profile_builder;
   profile_builder.SetProfileName(email);
   std::unique_ptr<TestingProfile> second_profile(profile_builder.Build());
   const AccountId account_id(AccountId::FromUserEmail(email));
   GetFakeUserManager()->AddUser(account_id);
   GetFakeUserManager()->SwitchActiveUser(account_id);
   second_profile->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
 
   // Check that non-primary user can't use ARC.
   EXPECT_FALSE(chromeos::ProfileHelper::IsPrimaryProfile(second_profile.get()));
   EXPECT_FALSE(ArcAppListPrefs::Get(second_profile.get()));
 
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, RemoveDataFolder) {
+TEST_P(ArcSessionManagerTest, RemoveDataFolder) {
+  // TODO(victorhsieh): Implement data removal on Persistent ARC.
+  if (ShouldAlwaysStartArc())
+    return;
+
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, false);
   // Starting session manager with prefs::kArcEnabled off automatically removes
   // Android's data folder.
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   EXPECT_TRUE(
       profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
   EXPECT_EQ(ArcSessionManager::State::REMOVING_DATA_DIR,
             arc_session_manager()->state());
   // Enable ARC. Data is removed asyncronously. At this moment session manager
   // should be in REMOVING_DATA_DIR state.
@@ skipping 32 matching lines @@
 
   EXPECT_FALSE(
       profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
 
   arc_session_manager()->StartArc();
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   arc_session_manager()->Shutdown();
 }
 
-TEST_F(ArcSessionManagerTest, IgnoreSecondErrorReporting) {
+TEST_P(ArcSessionManagerTest, IgnoreSecondErrorReporting) {
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
   arc_session_manager()->StartArc();
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   // Report some failure that does not stop the bridge.
   arc_session_manager()->OnProvisioningFinished(
       ProvisioningResult::GMS_SIGN_IN_FAILED);
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   // Try to send another error that stops the bridge if sent first. It should
   // be ignored.
   arc_session_manager()->OnProvisioningFinished(
       ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
 
   arc_session_manager()->Shutdown();
 }
 
 class ArcSessionManagerPolicyTest
-    : public ArcSessionManagerTest,
-      public testing::WithParamInterface<std::tuple<base::Value, base::Value>> {
+    : public AbstractArcSessionManagerTest,
+      public testing::WithParamInterface<
+          std::tuple<base::Value, base::Value, bool>> {
  public:
   const base::Value& backup_restore_pref_value() const {
     return std::get<0>(GetParam());
   }
 
   const base::Value& location_service_pref_value() const {
     return std::get<1>(GetParam());
   }
+
+ protected:
+  bool ShouldAlwaysStartArcInTest() override { return std::get<2>(GetParam()); }
 };
 
 TEST_P(ArcSessionManagerPolicyTest, SkippingTerms) {
+  // TODO(victorhsieh): Implement opt-in flow.
+  if (ShouldAlwaysStartArc())
+    return;
+
   sync_preferences::TestingPrefServiceSyncable* const prefs =
       profile()->GetTestingPrefService();
 
   // Backup-restore and location-service prefs are off by default.
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcTermsAccepted));
 
   // Set ARC to be managed.
   prefs->SetManagedPref(prefs::kArcEnabled, new base::Value(true));
 
@@ skipping 29 matching lines @@
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcBackupRestoreEnabled));
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcLocationServiceEnabled));
 
   // Stop ARC and shutdown the service.
   prefs->RemoveManagedPref(prefs::kArcEnabled);
   WaitForDataRemoved(ArcSessionManager::State::STOPPED);
   arc_session_manager()->Shutdown();
 }
 
 INSTANTIATE_TEST_CASE_P(
-    ArcSessionManagerPolicyTest,
+    ,
     ArcSessionManagerPolicyTest,
     testing::Combine(
         testing::Values(base::Value(), base::Value(false), base::Value(true)),
-        testing::Values(base::Value(), base::Value(false), base::Value(true))));
+        testing::Values(base::Value(), base::Value(false), base::Value(true)),
+        testing::Bool()));
 
 class ArcSessionManagerKioskTest : public ArcSessionManagerTestBase {
  public:
   ArcSessionManagerKioskTest() = default;
 
   void SetUp() override {
     ArcSessionManagerTestBase::SetUp();
     const AccountId account_id(
         AccountId::FromUserEmail(profile()->GetProfileUserName()));
     GetFakeUserManager()->AddArcKioskAppUser(account_id);
@@ skipping 15 matching lines @@
   // and not invoked then, including TearDown().
   bool terminated = false;
   arc_session_manager()->SetAttemptUserExitCallbackForTesting(
       base::Bind([](bool* terminated) { *terminated = true; }, &terminated));
 
   arc_session_manager()->OnProvisioningFinished(
       ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
   EXPECT_TRUE(terminated);
 }
 
-class ArcSessionOobeOptInTest : public ArcSessionManagerTest {
+// This class takes two test parameters because the both itself and its child
+// need to be parameterized.  Having redundant parameter here avoid the trouble
+// to deal with multiple inheritance from WithParamInterface instances.
+class ArcSessionOobeOptInTest
+    : public AbstractArcSessionManagerTest,
+      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
  public:
   ArcSessionOobeOptInTest() = default;
 
  protected:
+  bool ShouldAlwaysStartArcInTest() override { return std::get<0>(GetParam()); }
+
   void CreateLoginDisplayHost() {
     fake_login_display_host_ = base::MakeUnique<FakeLoginDisplayHost>();
   }
 
   void CloseLoginDisplayHost() { fake_login_display_host_.reset(); }
 
   void AppendEnableArcOOBEOptInSwitch() {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         chromeos::switches::kEnableArcOOBEOptIn);
   }
 
  private:
   std::unique_ptr<FakeLoginDisplayHost> fake_login_display_host_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcSessionOobeOptInTest);
 };
 
-TEST_F(ArcSessionOobeOptInTest, OobeOptInActive) {
+INSTANTIATE_TEST_CASE_P(
+    ,
+    ArcSessionOobeOptInTest,
+    testing::Combine(::testing::Bool() /* always start arc */,
+                     ::testing::Values(false) /* dummy */));
+
+TEST_P(ArcSessionOobeOptInTest, OobeOptInActive) {
   // OOBE OptIn is active in case of OOBE is started for new user and ARC OOBE
   // is enabled by switch.
   EXPECT_FALSE(ArcSessionManager::IsOobeOptInActive());
   GetFakeUserManager()->set_current_user_new(true);
   EXPECT_FALSE(ArcSessionManager::IsOobeOptInActive());
   CreateLoginDisplayHost();
   EXPECT_FALSE(ArcSessionManager::IsOobeOptInActive());
 
   AppendEnableArcOOBEOptInSwitch();
   GetFakeUserManager()->set_current_user_new(false);
   CloseLoginDisplayHost();
   EXPECT_FALSE(ArcSessionManager::IsOobeOptInActive());
   GetFakeUserManager()->set_current_user_new(true);
   EXPECT_FALSE(ArcSessionManager::IsOobeOptInActive());
   CreateLoginDisplayHost();
   EXPECT_TRUE(ArcSessionManager::IsOobeOptInActive());
 }
 
 class ArcSessionOobeOptInNegotiatorTest
     : public ArcSessionOobeOptInTest,
-      public chromeos::ArcTermsOfServiceScreenActor,
-      public testing::WithParamInterface<bool> {
+      public chromeos::ArcTermsOfServiceScreenActor {
  public:
   ArcSessionOobeOptInNegotiatorTest() = default;
 
   void SetUp() override {
     ArcSessionOobeOptInTest::SetUp();
 
     AppendEnableArcOOBEOptInSwitch();
 
     ArcTermsOfServiceOobeNegotiator::SetArcTermsOfServiceScreenActorForTesting(
         this);
@@ skipping 19 matching lines @@
     // Correctly stop service.
     arc_session_manager()->Shutdown();
 
     ArcTermsOfServiceOobeNegotiator::SetArcTermsOfServiceScreenActorForTesting(
         nullptr);
 
     ArcSessionOobeOptInTest::TearDown();
   }
 
  protected:
-  bool IsManagedUser() { return GetParam(); }
+  bool ShouldAlwaysStartArcInTest() override { return std::get<0>(GetParam()); }
+  bool IsManagedUser() { return std::get<1>(GetParam()); }
 
   void ReportResult(bool accepted) {
     for (auto& observer : observer_list_) {
       if (accepted)
         observer.OnAccept();
       else
         observer.OnSkip();
     }
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 37 matching lines @@
   }
 
   void Hide() override {}
 
   base::ObserverList<chromeos::ArcTermsOfServiceScreenActorObserver>
       observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcSessionOobeOptInNegotiatorTest);
 };
 
-INSTANTIATE_TEST_CASE_P(ArcSessionOobeOptInNegotiatorTestImpl,
-                        ArcSessionOobeOptInNegotiatorTest,
-                        ::testing::Values(true, false));
+// TODO(victorhsieh): Add test to cover when ARC always start
+INSTANTIATE_TEST_CASE_P(
+    ,
+    ArcSessionOobeOptInNegotiatorTest,
+    testing::Combine(::testing::Values(false) /* always start arc */,
+                     ::testing::Bool() /* managed user */));
 
 TEST_P(ArcSessionOobeOptInNegotiatorTest, OobeTermsAccepted) {
   actor()->Show();
   MaybeWaitForDataRemoved();
   EXPECT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
             arc_session_manager()->state());
   ReportResult(true);
   EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
   EXPECT_TRUE(arc_session_manager()->IsArcPlayStoreEnabled());
 }
@@ skipping 15 matching lines @@
   EXPECT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
             arc_session_manager()->state());
   CloseLoginDisplayHost();
   ReportActorDestroyed();
   EXPECT_EQ(ArcSessionManager::State::STOPPED, arc_session_manager()->state());
   EXPECT_FALSE(!IsManagedUser() &&
                arc_session_manager()->IsArcPlayStoreEnabled());
 }
 
 }  // namespace arc