Split ArcSessionManager::OnPrimaryUserProfilePrepared().

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 368 matching lines @@
 
 void ArcSessionManager::SetState(State state) {
   state_ = state;
 }
 
 bool ArcSessionManager::IsAllowed() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return profile_ != nullptr;
 }
 
-void ArcSessionManager::OnPrimaryUserProfilePrepared(Profile* profile) {
+void ArcSessionManager::SetProfile(Profile* profile) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(profile && profile != profile_);
+  DCHECK(IsArcAllowedForProfile(profile));
 
+  // TODO(hidehiko): Remove this condition, and following Shutdown().
+  // Do not expect that SetProfile() is called for various Profile instances.
+  // At the moment, it is used for testing purpose.
+  DCHECK(profile != profile_);
   Shutdown();
 
-  if (!IsArcAllowedForProfile(profile))
-    return;
-
-  // TODO(khmel): Move this to IsArcAllowedForProfile.
-  if (policy_util::IsArcDisabledForEnterprise() &&
-      policy_util::IsAccountManaged(profile)) {
-    VLOG(2) << "Enterprise users are not supported in ARC.";
-    return;
-  }
-
   profile_ = profile;
 
   // Create the support host at initialization. Note that, practically,
   // ARC support Chrome app is rarely used (only opt-in and re-auth flow).
   // So, it may be better to initialize it lazily.
   // TODO(hidehiko): Revisit to think about lazy initialization.
   //
   // Don't show UI for ARC Kiosk because the only one UI in kiosk mode must
   // be the kiosk app. In case of error the UI will be useless as well, because
   // in typical use case there will be no one nearby the kiosk device, who can
   // do some action to solve the problem be means of UI.
   if (!g_disable_ui_for_testing && !IsArcOptInVerificationDisabled() &&
       !IsArcKioskMode()) {
     DCHECK(!support_host_);
     support_host_ = base::MakeUnique<ArcSupportHost>(profile_);
-    support_host_->SetArcManaged(
-        IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_));
     support_host_->AddObserver(this);
   }
 
   DCHECK_EQ(State::NOT_INITIALIZED, state_);
   SetState(State::STOPPED);
 
-  context_.reset(new ArcAuthContext(profile_));
+  context_ = base::MakeUnique<ArcAuthContext>(profile_);
 
   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()));
-
   // Chrome may be shut down before completing ARC data removal.
   // In such a case, start removing the data now.
   if (profile_->GetPrefs()->GetBoolean(prefs::kArcDataRemoveRequested)) {
     VLOG(1) << "ARC data removal requested in previous session.";
     RemoveArcData();
   }
-
-  if (IsArcPlayStoreEnabledForProfile(profile_)) {
-    VLOG(1) << "ARC is already enabled.";
-    DCHECK(!enable_requested_);
-    RequestEnable();
-  } else {
-    if (IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_)) {
-      // All users that can disable ARC by themselves will have the
-      // |kARcDataRemoveRequested| pref set, so we don't need to eagerly remove
-      // the data for that case.
-      // For managed users, the preference can change when the Profile object is
-      // not alive, so we still need to check it here in case it was disabled to
-      // ensure that the data is deleted in case it was disabled between
-      // launches.
-      VLOG(1) << "ARC is initially disabled for managed 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())
     return;
 
   pref_service_syncable->RemoveObserver(this);
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 28 matching lines @@
 void ArcSessionManager::StopArc() {
   if (state_ != State::STOPPED) {
     profile_->GetPrefs()->SetBoolean(prefs::kArcSignedIn, false);
     profile_->GetPrefs()->SetBoolean(prefs::kArcTermsAccepted, false);
   }
   ShutdownSession();
   if (support_host_)
     support_host_->Close();
 }
 
+void ArcSessionManager::StartPreferenceHandler() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(profile_);
+
+  // Start observing Google Play Store enabled preference.
+  pref_change_registrar_.Init(profile_->GetPrefs());
+  pref_change_registrar_.Add(
+      prefs::kArcEnabled,
+      base::Bind(&ArcSessionManager::OnOptInPreferenceChanged,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  // Set initial managed state to ArcSupportHost to update the message.
+  if (support_host_) {
+    support_host_->SetArcManaged(
+        IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_));
+  }
+
+  // Update the state based on the initial Google Play Store enabled value.
+  if (IsArcPlayStoreEnabledForProfile(profile_)) {
+    VLOG(1) << "ARC is already enabled.";
+    DCHECK(!enable_requested_);
+    RequestEnable();
+  } else {
+    if (IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_)) {
+      // All users that can disable ARC by themselves will have the
+      // |kARcDataRemoveRequested| pref set, so we don't need to eagerly remove
+      // the data for that case.
+      // For managed users, the preference can change when the Profile object is
+      // not alive, so we still need to check it here in case it was disabled to
+      // ensure that the data is deleted in case it was disabled between
+      // launches.
+      VLOG(1) << "ARC is initially disabled for managed profile. "
+              << "Removing data.";
+      RemoveArcData();
+    }
+    PrefServiceSyncableFromProfile(profile_)->AddObserver(this);
+    OnIsSyncingChanged();
+  }
+}
+
 void ArcSessionManager::OnOptInPreferenceChanged() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
 
   const bool is_play_store_enabled = IsArcPlayStoreEnabledForProfile(profile_);
   const bool is_play_store_managed =
       IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_);
   if (!is_play_store_managed) {
     // Update UMA only for non-Managed cases.
     UpdateOptInActionUMA(is_play_store_enabled ? OptInActionType::OPTED_IN
@@ skipping 469 matching lines @@
 
 #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