Migrate ArcUserDataService into ArcAuthService.

chrome/browser/chromeos/arc/arc_auth_service.cc

 // Copyright 2015 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_auth_service.h"
 
 #include <utility>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm_shell.h"
@@ skipping 216 matching lines @@
 }
 
 void ArcAuthService::OnBridgeStopped(ArcBridgeService::StopReason reason) {
   // TODO(crbug.com/625923): Use |reason| to report more detailed errors.
   if (waiting_for_reply_) {
     // Using SERVICE_UNAVAILABLE instead of UNKNOWN_ERROR, since the latter
     // causes this code to not try to stop ARC, so it would retry without the
     // user noticing.
     OnSignInFailedInternal(ProvisioningResult::ARC_STOPPED);
   }
-  if (!clear_required_)
+
+  if (clear_required_) {
+    clear_required_ = false;

[Luis Héctor Chávez, 2016/08/09 16:40:02]

This is not needed, since it's the first thing RemoveArcData() will do. If
you're just worried that we can get into a bad state, I'd rather to a
DCHECK(arc_bridge_service()->stopped()) to bail out if we are.

If you end up doing the ScheduleArcDataWipe() thing, inline the data wiping
logic here.

[hidehiko, 2016/08/10 05:41:18]

Done.
It's an option, but as RemoveArcData can be called while ARC is not running, so
I prefer not to inline the removal here. WDYT?

+    RemoveArcData();
+  } else {
+    // To support special "Reenable ARC" procedure for enterprise, here call
+    // OnArcDataRemoved(true) as if the data removal is successfully done.
+    // TODO(hidehiko): Restructure the code.
+    OnArcDataRemoved(true);
+  }
+}
+
+void ArcAuthService::RemoveArcData() {
+  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;
   chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->RemoveArcData(
       cryptohome::Identification(
           multi_user_util::GetAccountIdFromProfile(profile_)),
-      chromeos::SessionManagerClient::ArcCallback());
+      base::Bind(&ArcAuthService::OnArcDataRemoved,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void ArcAuthService::OnArcDataRemoved(bool success) {
+  LOG_IF(ERROR, !success) << "Required ARC user data wipe failed.";
+
+  // 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_)
+    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();
 }
 
 std::string ArcAuthService::GetAndResetAuthCode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   std::string auth_code;
   auth_code_.swap(auth_code);
   return auth_code;
 }
 
 void ArcAuthService::GetAuthCodeDeprecated(
@@ skipping 91 matching lines @@
       profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
     ShutdownBridgeAndShowUI(UIPage::ERROR,
                             l10n_util::GetStringUTF16(error_message_id));
     return;
   }
 
   if (result == ProvisioningResult::CLOUD_PROVISION_FLOW_FAILED ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_TIMEOUT ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_INTERNAL_ERROR ||
       result == ProvisioningResult::UNKNOWN_ERROR)
-    clear_required_ = true;
+    RemoveArcData();
 
   // We'll delay shutting down the bridge in this case to allow people to send
   // feedback.
   ShowUI(UIPage::ERROR_WITH_FEEDBACK,
          l10n_util::GetStringUTF16(error_message_id));
 }
 
 void ArcAuthService::GetIsAccountManaged(
     const GetIsAccountManagedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 151 matching lines @@
 
 void ArcAuthService::OnOptInPreferenceChanged() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
 
   const bool arc_enabled = IsArcEnabled();
   FOR_EACH_OBSERVER(Observer, observer_list_, OnOptInEnabled(arc_enabled));
 
   if (!arc_enabled) {
     StopArc();
+    RemoveArcData();
     return;
   }
 
   if (state_ == State::ACTIVE)
     return;
   CloseUI();
   auth_code_.clear();
 
   if (!profile_->GetPrefs()->GetBoolean(prefs::kArcSignedIn)) {
     // Need pre-fetch auth code and show OptIn UI if needed.
@@ skipping 50 matching lines @@
     ArcAuthNotification::Hide();
 }
 
 void ArcAuthService::SetUIPage(UIPage page, const base::string16& status) {
   ui_page_ = page;
   ui_page_status_ = status;
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnOptInUIShowPage(ui_page_, ui_page_status_));
 }
 
+// This is the special method to support enterprise mojo API.
+// TODO(hidehiko): Remove this.
+void ArcAuthService::ReenableArc() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(!arc_bridge_service()->stopped());
+  reenable_arc_ = true;
+  StopArc();
+}
+
 void ArcAuthService::StartArc() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   arc_bridge_service()->HandleStartup();
   SetState(State::ACTIVE);
 }
 
 void ArcAuthService::SetAuthCodeAndStartArc(const std::string& auth_code) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!auth_code.empty());
 
@@ skipping 199 matching lines @@
       return os << kStateFetchingCode;
     case ArcAuthService::State::ACTIVE:
       return os << kStateActive;
     default:
       NOTREACHED();
       return os;
   }
 }
 
 }  // namespace arc