Extract kArcEnabled preference from ArcSessionManager part 1.

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 404 matching lines @@
   // 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(IsArcManaged());
+    support_host_->SetArcManaged(
+        IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_));
     support_host_->AddObserver(this);
   }
 
   DCHECK_EQ(State::NOT_INITIALIZED, state_);
   SetState(State::STOPPED);
 
   context_.reset(new 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 (IsArcPlayStoreEnabled()) {
+  if (IsArcPlayStoreEnabledForProfile(profile_)) {
     VLOG(1) << "ARC is already enabled.";
     DCHECK(!enable_requested_);
     RequestEnable();
   } else {
     VLOG(1) << "ARC is initially disabled. Removing data.";
     RemoveArcData();
     PrefServiceSyncableFromProfile(profile_)->AddObserver(this);
     OnIsSyncingChanged();
   }
 }
@@ skipping 43 matching lines @@
   }
   ShutdownSession();
   if (support_host_)
     support_host_->Close();
 }
 
 void ArcSessionManager::OnOptInPreferenceChanged() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(profile_);
 
-  const bool arc_enabled = IsArcPlayStoreEnabled();
-  if (!IsArcManaged()) {
+  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(arc_enabled ? OptInActionType::OPTED_IN
-                                     : OptInActionType::OPTED_OUT);
+    UpdateOptInActionUMA(is_play_store_enabled ? OptInActionType::OPTED_IN
+                                               : OptInActionType::OPTED_OUT);
 
-    if (!arc_enabled) {
+    if (!is_play_store_enabled) {
       // Remove the pinned Play Store icon launcher in Shelf.
       // This is only for non-Managed cases. In managed cases, it is expected
       // to be "disabled" rather than "removed", so keep it here.
       ash::ShelfDelegate* shelf_delegate = GetShelfDelegate();
       if (shelf_delegate)
         shelf_delegate->UnpinAppWithID(ArcSupportHost::kHostAppId);
     }
   }
 
   if (support_host_)
-    support_host_->SetArcManaged(IsArcManaged());
+    support_host_->SetArcManaged(is_play_store_managed);
 
   // 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)
+  if (is_play_store_enabled)
     RequestEnable();
   else
     RequestDisable();
 
   for (auto& observer : observer_list_)
-    observer.OnArcPlayStoreEnabledChanged(arc_enabled);
+    observer.OnArcPlayStoreEnabledChanged(is_play_store_enabled);
 }
 
 void ArcSessionManager::ShutdownSession() {
   arc_sign_in_timer_.Stop();
   playstore_launcher_.reset();
   terms_of_service_negotiator_.reset();
   android_management_checker_.reset();
   arc_session_runner_->RequestStop();
   // TODO(hidehiko): The ARC instance's stopping is asynchronous, so it might
   // still be running when we return from this function. Do not set the
@@ skipping 81 matching lines @@
   }
 
   // Update UMA with user cancel only if error is not currently shown.
   if (support_host_ &&
       support_host_->ui_page() != ArcSupportHost::UIPage::NO_PAGE &&
       support_host_->ui_page() != ArcSupportHost::UIPage::ERROR) {
     UpdateOptInCancelUMA(OptInCancelReason::USER_CANCEL);
   }
 
   StopArc();
-  SetArcPlayStoreEnabled(false);
-}
-
-bool ArcSessionManager::IsArcManaged() const {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(profile_);
-  return profile_->GetPrefs()->IsManagedPreference(prefs::kArcEnabled);
-}
-
-bool ArcSessionManager::IsArcPlayStoreEnabled() const {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (!IsAllowed())
-    return false;
-
-  DCHECK(profile_);
-  return profile_->GetPrefs()->GetBoolean(prefs::kArcEnabled);
-}
-
-void ArcSessionManager::SetArcPlayStoreEnabled(bool enabled) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(profile_);
-
-  if (IsArcManaged()) {
-    VLOG(1) << "Whether Google Play Store is enabled is managed. Do nothing.";
-    return;
-  }
-
-  profile_->GetPrefs()->SetBoolean(prefs::kArcEnabled, enabled);
+  SetArcPlayStoreEnabledForProfile(profile_, false);
 }
 
 void ArcSessionManager::RecordArcState() {
   // Only record Enabled state if ARC is allowed in the first place, so we do
   // not split the ARC population by devices that cannot run ARC.
   if (IsAllowed())
     UpdateEnabledStateUMA(enable_requested_);
 }
 
 void ArcSessionManager::RequestEnable() {
@@ skipping 27 matching lines @@
   // 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())
     prefs->SetBoolean(prefs::kArcTermsAccepted, true);
 
   // Skip to show UI asking users to enable/disable their preference for
   // backup-restore and location-service, if both are managed by the admin
   // policy. Note that the ToS agreement is anyway not shown in the case of the
   // managed ARC.
-  if (IsArcManaged() &&
+  if (arc::IsArcPlayStoreEnabledPreferenceManagedForProfile(profile_) &&
       prefs->IsManagedPreference(prefs::kArcBackupRestoreEnabled) &&
       prefs->IsManagedPreference(prefs::kArcLocationServiceEnabled)) {
     prefs->SetBoolean(prefs::kArcTermsAccepted, true);
   }
 
   // If it is marked that sign in has been successfully done, then directly
   // start ARC.
   // For testing, and for Kiosk mode, we also skip ToS negotiation procedure.
   // For backward compatibility, this check needs to be prior to the
   // kArcTermsAccepted check below.
   if (prefs->GetBoolean(prefs::kArcSignedIn) ||
       IsArcOptInVerificationDisabled() || IsArcKioskMode()) {
     StartArc();
 
     // Skip Android management check for testing.
     // We also skip if Android management check for Kiosk mode,
     // because there are no managed human users for Kiosk exist.
     if (IsArcOptInVerificationDisabled() || IsArcKioskMode() ||
         (g_disable_ui_for_testing &&
          !g_enable_check_android_management_for_testing)) {
       return;
     }
 
     // Check Android management in parallel.
     // Note: Because the callback may be called in synchronous way (i.e. called
     // on the same stack), StartCheck() needs to be called *after* StartArc().
-    // Otherwise, SetArcPlayStoreEnabled() which may be called in
+    // Otherwise, SetArcPlayStoreEnabledForProfile() which may be called in
     // OnBackgroundAndroidManagementChecked() could be ignored.
     android_management_checker_ = base::MakeUnique<ArcAndroidManagementChecker>(
         profile_, context_->token_service(), context_->account_id(),
         true /* retry_on_error */);
     android_management_checker_->StartCheck(
         base::Bind(&ArcSessionManager::OnBackgroundAndroidManagementChecked,
                    weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
@@ skipping 141 matching lines @@
 }
 
 void ArcSessionManager::OnBackgroundAndroidManagementChecked(
     policy::AndroidManagementClient::Result result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   switch (result) {
     case policy::AndroidManagementClient::Result::UNMANAGED:
       // Do nothing. ARC should be started already.
       break;
     case policy::AndroidManagementClient::Result::MANAGED:
-      SetArcPlayStoreEnabled(false);
+      SetArcPlayStoreEnabledForProfile(profile_, false);
       break;
     case policy::AndroidManagementClient::Result::ERROR:
       // This code should not be reached. For background check,
       // retry_on_error should be set.
       NOTREACHED();
   }
 }
 
 void ArcSessionManager::OnWindowClosed() {
   DCHECK(support_host_);
@@ skipping 83 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