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

chrome/browser/chromeos/arc/arc_session_manager.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 "chrome/browser/chromeos/arc/arc_session_manager.h"
 
 #include <utility>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm_shell.h"
@@ skipping 92 matching lines @@
 ArcSessionManager* ArcSessionManager::Get() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return g_arc_session_manager;
 }
 
 // static
 void ArcSessionManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // TODO(dspaid): Implement a mechanism to allow this to sync on first boot
   // only.
+  registry->RegisterBooleanPref(prefs::kArcDataRemoveRequested, false);
   registry->RegisterBooleanPref(prefs::kArcEnabled, false);
   registry->RegisterBooleanPref(prefs::kArcSignedIn, false);
   registry->RegisterBooleanPref(prefs::kArcTermsAccepted, false);
   registry->RegisterBooleanPref(prefs::kArcBackupRestoreEnabled, true);
   registry->RegisterBooleanPref(prefs::kArcLocationServiceEnabled, true);
 }
 
 // static
 void ArcSessionManager::DisableUIForTesting() {
   g_disable_ui_for_testing = true;
@@ skipping 65 matching lines @@
 bool ArcSessionManager::IsArcKioskMode() {
   return user_manager::UserManager::Get()->IsLoggedInAsArcKioskApp();
 }
 
 void ArcSessionManager::OnBridgeStopped(ArcBridgeService::StopReason reason) {
   // TODO(crbug.com/625923): Use |reason| to report more detailed errors.
   if (arc_sign_in_timer_.IsRunning()) {
     OnProvisioningFinished(ProvisioningResult::ARC_STOPPED);
   }
 
-  if (clear_required_) {
+  if (profile_->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested)) {
     // This should be always true, but just in case as this is looked at
     // inside RemoveArcData() at first.
     DCHECK(arc_bridge_service()->stopped());
     RemoveArcData();
   } else {
     // To support special "Stop and enable ARC" procedure for enterprise,
-    // here call OnArcDataRemoved(true) as if the data removal is successfully
-    // done.
+    // here call MaybeReenableArc() asyncronously.
     // TODO(hidehiko): Restructure the code. crbug.com/665316
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&ArcSessionManager::OnArcDataRemoved,
-                              weak_ptr_factory_.GetWeakPtr(), true));
+        FROM_HERE, base::Bind(&ArcSessionManager::MaybeReenableArc,
+                              weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void ArcSessionManager::RemoveArcData() {
+  // Ignore redundant data removal request.
+  if (state() == State::REMOVING_DATA_DIR)
+    return;
+
+  // OnArcDataRemoved resets this flag.
+  profile_->GetPrefs()->SetBoolean(prefs::kArcDataRemoveRequested, true);
+
   if (!arc_bridge_service()->stopped()) {
     // Just set a flag. On bridge stopped, this will be re-called,
     // then session manager should remove the data.
-    clear_required_ = true;
     return;
   }
-  clear_required_ = false;
+
+  SetState(State::REMOVING_DATA_DIR);
   chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->RemoveArcData(
       cryptohome::Identification(
           multi_user_util::GetAccountIdFromProfile(profile_)),
       base::Bind(&ArcSessionManager::OnArcDataRemoved,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ArcSessionManager::OnArcDataRemoved(bool success) {
   LOG_IF(ERROR, !success) << "Required ARC user data wipe failed.";
 
+  // TODO(khmel): Browser tests may shutdown profile by itself. Update browser
+  // tests and remove this check.
+  if (state() == State::NOT_INITIALIZED)
+    return;
+
+  for (auto& observer : observer_list_)
+    observer.OnArcDataRemoved();
+
+  profile_->GetPrefs()->SetBoolean(prefs::kArcDataRemoveRequested, false);
+  DCHECK_EQ(state(), State::REMOVING_DATA_DIR);
+  SetState(State::STOPPED);
+
+  MaybeReenableArc();
+}
+
+void ArcSessionManager::MaybeReenableArc() {
   // Here check if |reenable_arc_| is marked or not.
   // The only case this happens should be in the special case for enterprise
   // "on managed lost" case. In that case, OnBridgeStopped() should trigger
   // the RemoveArcData(), then this.
-  // TODO(hidehiko): Restructure the code.
-  if (!reenable_arc_)
+  if (!reenable_arc_ || !IsArcEnabled())
     return;
 
   // Restart ARC anyway. Let the enterprise reporting instance decide whether
   // the ARC user data wipe is still required or not.
   reenable_arc_ = false;
   VLOG(1) << "Reenable ARC";
   EnableArc();
 }
 
 void ArcSessionManager::OnProvisioningFinished(ProvisioningResult result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK_EQ(state_, State::ACTIVE);
+
+  // Due asynchronous nature of stopping Arc bridge, OnProvisioningFinished may

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

Nice commenting!

+  // arrive after setting the |State::STOPPED| state and |State::Active| is not
+  // guaranty set here. prefs::kArcDataRemoveRequested is also can be active
+  // for now.
 
   if (result == ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR) {
     if (IsArcKioskMode()) {
       VLOG(1) << "Robot account auth code fetching error";
       // Log out the user. All the cleanup will be done in Shutdown() method.
       // The callback is not called because auth code is empty.
       chrome::AttemptUserExit();
       return;
     }
 
@@ skipping 145 matching lines @@
   if (!g_disable_ui_for_testing ||
       g_enable_check_android_management_for_testing) {
     ArcAndroidManagementChecker::StartClient();
   }
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kArcEnabled,
       base::Bind(&ArcSessionManager::OnOptInPreferenceChanged,
                  weak_ptr_factory_.GetWeakPtr()));
   if (profile_->GetPrefs()->GetBoolean(prefs::kArcEnabled)) {
-    OnOptInPreferenceChanged();
+    // Don't start ARC if there is a pending request to remove the data. Restart
+    // ARC once data removal finishes.
+    if (profile_->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested)) {
+      reenable_arc_ = true;
+      RemoveArcData();
+    } else {
+      OnOptInPreferenceChanged();
+    }
   } else {
     RemoveArcData();
     PrefServiceSyncableFromProfile(profile_)->AddObserver(this);
     OnIsSyncingChanged();
   }
 }
 
 void ArcSessionManager::OnIsSyncingChanged() {
   sync_preferences::PrefServiceSyncable* const pref_service_syncable =
       PrefServiceSyncableFromProfile(profile_);
@@ skipping 59 matching lines @@
   DCHECK(profile_);
 
   // TODO(dspaid): Move code from OnSyncedPrefChanged into this method.
   OnSyncedPrefChanged(prefs::kArcEnabled, IsArcManaged());
 
   const bool arc_enabled = IsArcEnabled();
   for (auto& observer : observer_list_)
     observer.OnOptInEnabled(arc_enabled);
 
   if (!arc_enabled) {
+    // Reset any pending request to re-enable Arc.
+    reenable_arc_ = false;
     StopArc();
     RemoveArcData();
     return;
   }
 
   if (state_ == State::ACTIVE)
     return;
 
+  if (state_ == State::REMOVING_DATA_DIR) {
+    // Data removal request is in progress. Set flag to re-enable Arc once it is
+    // finished.
+    reenable_arc_ = true;
+    return;
+  }
+
   if (support_host_)
     support_host_->SetArcManaged(IsArcManaged());
 
   // For ARC Kiosk we skip ToS because it is very likely that near the device
   // there will be no one who is eligible to accept them.
   // TODO(poromov): Move to more Kiosk dedicated set-up phase.
   if (IsArcKioskMode())
     profile_->GetPrefs()->SetBoolean(prefs::kArcTermsAccepted, true);
 
   // If it is marked that sign in has been successfully done, then directly
@@ skipping 44 matching lines @@
   // Need user's explicit Terms Of Service agreement.
   StartTermsOfServiceNegotiation();
 }
 
 void ArcSessionManager::ShutdownBridge() {
   arc_sign_in_timer_.Stop();
   playstore_launcher_.reset();
   terms_of_service_negotiator_.reset();
   android_management_checker_.reset();
   arc_bridge_service()->RequestStop();
-  if (state_ != State::NOT_INITIALIZED)
+  if (state_ != State::NOT_INITIALIZED && state_ != State::REMOVING_DATA_DIR)
     SetState(State::STOPPED);
   for (auto& observer : observer_list_)
     observer.OnShutdownBridge();
 }
 
 void ArcSessionManager::AddObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   observer_list_.AddObserver(observer);
 }
 
 void ArcSessionManager::RemoveObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   observer_list_.RemoveObserver(observer);
 }
 
 // This is the special method to support enterprise mojo API.
 // TODO(hidehiko): Remove this.
 void ArcSessionManager::StopAndEnableArc() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!arc_bridge_service()->stopped());
   reenable_arc_ = true;
   StopArc();
 }
 
 void ArcSessionManager::StartArc() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  // Arc must be started only if no pending data removal request exists.
+  DCHECK(!profile_->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested));
+
   arc_bridge_service()->RequestStart();
   SetState(State::ACTIVE);
 }
 
 void ArcSessionManager::OnArcSignInTimeout() {
   LOG(ERROR) << "Timed out waiting for first sign in.";
   OnProvisioningFinished(ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT);
 }
 
 void ArcSessionManager::CancelAuthCode() {
@@ skipping 238 matching lines @@
                          const ArcSessionManager::State& state) {
   switch (state) {
     case ArcSessionManager::State::NOT_INITIALIZED:
       return os << "NOT_INITIALIZED";
     case ArcSessionManager::State::STOPPED:
       return os << "STOPPED";
     case ArcSessionManager::State::SHOWING_TERMS_OF_SERVICE:
       return os << "SHOWING_TERMS_OF_SERVICE";
     case ArcSessionManager::State::CHECKING_ANDROID_MANAGEMENT:
       return os << "CHECKING_ANDROID_MANAGEMENT";
+    case ArcSessionManager::State::REMOVING_DATA_DIR:
+      return os << "REMOVING_DATA_DIR";
     case ArcSessionManager::State::ACTIVE:
       return os << "ACTIVE";
   }
 
   // Some compiler reports an error even if all values of an enum-class are
   // covered indivisually in a switch statement.
   NOTREACHED();
   return os;
 }
 
 }  // namespace arc