arc: Make request to remove Android's data folder persistent.

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 <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/arc/arc_optin_uma.h"
 #include "chrome/browser/chromeos/arc/arc_session_manager.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/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/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_bridge_service.h"
 #include "components/arc/test/fake_arc_bridge_service.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/sync/model/fake_sync_change_processor.h"
 #include "components/sync/model/sync_error_factory_mock.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/http/http_status_code.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace arc {
 
 class ArcSessionManagerTest : public testing::Test {
  public:
   ArcSessionManagerTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         user_manager_enabler_(new chromeos::FakeChromeUserManager) {}
   ~ArcSessionManagerTest() override = default;
 
   void SetUp() override {
+    chromeos::DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
+        base::WrapUnique(new chromeos::FakeSessionManagerClient));
+
     chromeos::DBusThreadManager::Initialize();
 
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         chromeos::switches::kEnableArc);
     ArcSessionManager::DisableUIForTesting();
 
     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
     TestingProfile::Builder profile_builder;
     profile_builder.SetPath(temp_dir_.GetPath().AppendASCII("TestArcProfile"));
 
@@ skipping 25 matching lines @@
         user_manager::UserManager::Get());
   }
 
  protected:
   Profile* profile() { return profile_.get(); }
   FakeArcBridgeService* bridge_service() { return bridge_service_.get(); }
   ArcSessionManager* arc_session_manager() {
     return arc_session_manager_.get();
   }
 
+  void WaitForDataRemoved(ArcSessionManager::State expected_state) {
+    ASSERT_EQ(ArcSessionManager::State::DELETING_DATA_FOLDER,

[hidehiko, 2016/12/06 05:05:30]

This won't work.

ASSERT_EQ is a macro to return from the current function.
So, ASSERT_EQ in a utility method just returns from the utility method, but will
not quit the test scenario in caller, unfortunately.

[khmel, 2016/12/06 18:16:13]

IIUC abort is called if any problem with ASSERT_EQ. Anyway I changed to
returning bool result and checking it in test body.

[hidehiko, 2016/12/06 18:32:10]

FYI:
https://cs.chromium.org/chromium/src/testing/gtest/include/gtest/internal/gte...
is the impl, IIUC.

+              arc_session_manager()->state());
+    base::RunLoop().RunUntilIdle();
+    ASSERT_EQ(expected_state, arc_session_manager()->state());
+  }
+
  private:
   void StartPreferenceSyncing() const {
     PrefServiceSyncableFromProfile(profile_.get())
         ->GetSyncableService(syncer::PREFERENCES)
         ->MergeDataAndStartSyncing(syncer::PREFERENCES, syncer::SyncDataList(),
                                    std::unique_ptr<syncer::SyncChangeProcessor>(
                                        new syncer::FakeSyncChangeProcessor),
                                    std::unique_ptr<syncer::SyncErrorFactory>(
                                        new syncer::SyncErrorFactoryMock()));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<FakeArcBridgeService> bridge_service_;
   std::unique_ptr<TestingProfile> profile_;
   std::unique_ptr<ArcSessionManager> arc_session_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   base::ScopedTempDir temp_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcSessionManagerTest);
 };
 
 TEST_F(ArcSessionManagerTest, PrefChangeTriggersService) {
   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_EQ(ArcSessionManager::State::STOPPED, arc_session_manager()->state());
+
+  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_EQ(ArcSessionManager::State::STOPPED, arc_session_manager()->state());
+
+  WaitForDataRemoved(ArcSessionManager::State::STOPPED);
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
 TEST_F(ArcSessionManagerTest, DisabledForEphemeralDataUsers) {
   PrefService* const prefs = profile()->GetPrefs();
   EXPECT_FALSE(prefs->GetBoolean(prefs::kArcSignedIn));
   prefs->SetBoolean(prefs::kArcEnabled, true);
 
@@ skipping 38 matching lines @@
 }
 
 TEST_F(ArcSessionManagerTest, BaseWorkflow) {
   ASSERT_FALSE(bridge_service()->ready());
   ASSERT_EQ(ArcSessionManager::State::NOT_INITIALIZED,
             arc_session_manager()->state());
 
   arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
 
   // By default ARC is not enabled.
-  ASSERT_EQ(ArcSessionManager::State::STOPPED, arc_session_manager()->state());
+  WaitForDataRemoved(ArcSessionManager::State::STOPPED);
 
   profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
+  base::RunLoop().RunUntilIdle();
 
   // Setting profile and pref initiates a code fetching process.
   ASSERT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
             arc_session_manager()->state());
 
   // TODO(hidehiko): Verify state transition from SHOWING_TERMS_OF_SERVICE ->
   // CHECKING_ANDROID_MANAGEMENT, when we extract ArcSessionManager.
   arc_session_manager()->StartArc();
 
   ASSERT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
@@ skipping 20 matching lines @@
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
 TEST_F(ArcSessionManagerTest, CancelFetchingDisablesArc) {
   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();
-  ASSERT_EQ(ArcSessionManager::State::STOPPED, arc_session_manager()->state());
+
+  // Wait until data is removed.
+  WaitForDataRemoved(ArcSessionManager::State::STOPPED);
+
   ASSERT_FALSE(pref->GetBoolean(prefs::kArcEnabled));
 
   // Correctly stop service.
   arc_session_manager()->Shutdown();
 }
 
 TEST_F(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.
@@ skipping 105 matching lines @@
   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) {
+  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::DELETING_DATA_FOLDER,
+            arc_session_manager()->state());
+  // Enable ARC. Data is removed asyncronously. At this moment session manager
+  // should be in DELETING_DATA_FOLDER state.
+  profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
+  EXPECT_TRUE(
+      profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
+  EXPECT_EQ(ArcSessionManager::State::DELETING_DATA_FOLDER,
+            arc_session_manager()->state());
+  // Wait until data is removed.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(
+      profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
+  EXPECT_EQ(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE,
+            arc_session_manager()->state());
+  arc_session_manager()->StartArc();
+  EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
+
+  // Now request to remove data and stop session manager.
+  arc_session_manager()->RemoveArcData();
+  ASSERT_TRUE(
+      profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
+  EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
+  arc_session_manager()->Shutdown();
+  base::RunLoop().RunUntilIdle();
+  // Request should persist.
+  ASSERT_TRUE(
+      profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
+
+  // Emulate next sign-in. Data should be removed first and ARC started after.
+  arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
+  EXPECT_TRUE(
+      profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
+
+  WaitForDataRemoved(ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE);
+
+  EXPECT_FALSE(
+      profile()->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
+
+  arc_session_manager()->StartArc();
+  EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
+  arc_session_manager()->Shutdown();
+}
+
 }  // namespace arc