[Merge-57] arc: Logging ARC data removal reasons

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 198 matching lines @@
 }
 
 void ArcSessionManager::OnSessionStopped(StopReason reason) {
   // TODO(crbug.com/625923): Use |reason| to report more detailed errors.
   if (arc_sign_in_timer_.IsRunning())
     OnProvisioningFinished(ProvisioningResult::ARC_STOPPED);
 
   if (profile_->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested)) {
     // This should be always true, but just in case as this is looked at
     // inside RemoveArcData() at first.
+    VLOG(1) << "ARC had previously requested to remove user data.";
     DCHECK(arc_session_runner_->IsStopped());
     RemoveArcData();
   } else {
     // To support special "Stop and enable ARC" procedure for enterprise,
     // here call MaybeReenableArc() asyncronously.
     // TODO(hidehiko): Restructure the code. crbug.com/665316
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ArcSessionManager::MaybeReenableArc,
                               weak_ptr_factory_.GetWeakPtr()));
   }
 
   for (auto& observer : arc_session_observer_list_)
     observer.OnSessionStopped(reason);
 }
 
 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_session_runner_->IsStopped()) {
     // Just set a flag. On session stopped, this will be re-called,
     // then session manager should remove the data.
     return;
   }
 
+  VLOG(1) << "Starting ARC data removal";
   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.";
+  if (success)
+    VLOG(1) << "ARC data removal successful";
+  else
+    LOG(ERROR) << "Request for ARC user data removal 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);
@@ skipping 87 matching lines @@
       playstore_launcher_.reset(
           new ArcAppLauncher(profile_, kPlayStoreAppId, true));
     }
 
     for (auto& observer : observer_list_)
       observer.OnArcInitialStart();
     return;
   }
 
   ArcSupportHost::Error error;
+  VLOG(1) << "ARC provisioning failed: " << result << ".";
   switch (result) {
     case ProvisioningResult::GMS_NETWORK_ERROR:
       error = ArcSupportHost::Error::SIGN_IN_NETWORK_ERROR;
       break;
     case ProvisioningResult::GMS_SERVICE_UNAVAILABLE:
     case ProvisioningResult::GMS_SIGN_IN_FAILED:
     case ProvisioningResult::GMS_SIGN_IN_TIMEOUT:
     case ProvisioningResult::GMS_SIGN_IN_INTERNAL_ERROR:
       error = ArcSupportHost::Error::SIGN_IN_SERVICE_UNAVAILABLE_ERROR;
       break;
@@ skipping 29 matching lines @@
   }
 
   if (result == ProvisioningResult::CLOUD_PROVISION_FLOW_FAILED ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_TIMEOUT ||
       result == ProvisioningResult::CLOUD_PROVISION_FLOW_INTERNAL_ERROR ||
       // OVERALL_SIGN_IN_TIMEOUT might be an indication that ARC believes it is
       // fully setup, but Chrome does not.
       result == ProvisioningResult::OVERALL_SIGN_IN_TIMEOUT ||
       // Just to be safe, remove data if we don't know the cause.
       result == ProvisioningResult::UNKNOWN_ERROR) {
+    VLOG(1) << "ARC provisioning failed permanently. Removing user data";
     RemoveArcData();
   }
 
   // We'll delay shutting down the ARC instance in this case to allow people
   // to send feedback.
   if (support_host_)
     support_host_->ShowError(error, true /* = show send feedback button */);
 }
 
 void ArcSessionManager::SetState(State state) {
@@ skipping 54 matching lines @@
   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)) {
     // 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;
+      VLOG(1) << "ARC previously requested to remove data.";
       RemoveArcData();
     } else {
       OnOptInPreferenceChanged();
     }
   } else {
+    VLOG(1) << "ARC disabled on profile. Removing data.";
     RemoveArcData();
     PrefServiceSyncableFromProfile(profile_)->AddObserver(this);
     OnIsSyncingChanged();
   }
 }
 
 void ArcSessionManager::OnIsSyncingChanged() {
   sync_preferences::PrefServiceSyncable* const pref_service_syncable =
       PrefServiceSyncableFromProfile(profile_);
   if (!pref_service_syncable->IsSyncing())
@@ skipping 76 matching lines @@
     observer.OnArcOptInChanged(arc_enabled);
 
   // Hide auth notification if it was opened before and arc.enabled pref was
   // explicitly set to true or false.
   if (!g_disable_ui_for_testing &&
       profile_->GetPrefs()->HasPrefPath(prefs::kArcEnabled)) {
     ArcAuthNotification::Hide();
   }
 
   if (!arc_enabled) {
-    // Reset any pending request to re-enable Arc.
+    // Reset any pending request to re-enable ARC.
+    VLOG(1) << "ARC opt-out. Removing user data.";
     reenable_arc_ = false;
     StopArc();
     RemoveArcData();
     return;
   }
 
   if (state_ == State::ACTIVE)
     return;
 
   if (state_ == State::REMOVING_DATA_DIR) {
@@ skipping 386 matching lines @@
 }
 
 void ArcSessionManager::SetAttemptUserExitCallbackForTesting(
     const base::Closure& callback) {
   DCHECK(!callback.is_null());
   attempt_user_exit_callback_ = callback;
 }
 
 std::ostream& operator<<(std::ostream& os,
                          const ArcSessionManager::State& state) {
+#define MAP_STATE(name)                \
+  case ArcSessionManager::State::name: \
+    return os << #name
+
   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";
+    MAP_STATE(NOT_INITIALIZED);
+    MAP_STATE(STOPPED);
+    MAP_STATE(SHOWING_TERMS_OF_SERVICE);
+    MAP_STATE(CHECKING_ANDROID_MANAGEMENT);
+    MAP_STATE(REMOVING_DATA_DIR);
+    MAP_STATE(ACTIVE);
   }
 
-  // Some compiler reports an error even if all values of an enum-class are
-  // covered indivisually in a switch statement.
-  NOTREACHED();
+#undef MAP_STATE
+
+  // Some compilers report an error even if all values of an enum-class are
+  // covered exhaustively in a switch statement.
+  NOTREACHED() << "Invalid value " << static_cast<int>(state);
   return os;
 }
 
 }  // namespace arc