Move more utility functions to arc_util.

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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/chromeos/arc/arc_optin_uma.h"
 #include "chrome/browser/chromeos/arc/arc_session_manager.h"
 #include "chrome/browser/chromeos/arc/auth/arc_auth_code_fetcher.h"
 #include "chrome/browser/chromeos/arc/auth/arc_background_auth_code_fetcher.h"
 #include "chrome/browser/chromeos/arc/auth/arc_manual_auth_code_fetcher.h"
 #include "chrome/browser/chromeos/arc/auth/arc_robot_auth_code_fetcher.h"
 #include "chrome/browser/chromeos/arc/policy/arc_policy_util.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/arc_features.h"
+#include "components/arc/arc_util.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace arc {
 namespace {
 
 ArcAuthService* g_arc_auth_service = nullptr;
 
 // Convers mojom::ArcSignInFailureReason into ProvisiningResult.
 ProvisioningResult ConvertArcSignInFailureReasonToProvisioningResult(
     mojom::ArcSignInFailureReason reason) {
@@ skipping 20 matching lines @@
     MAP_PROVISIONING_RESULT(CLOUD_PROVISION_FLOW_TIMEOUT);
     MAP_PROVISIONING_RESULT(CLOUD_PROVISION_FLOW_INTERNAL_ERROR);
   }
 #undef MAP_PROVISIONING_RESULT
 
   NOTREACHED() << "unknown reason: " << static_cast<int>(reason);
   return ProvisioningResult::UNKNOWN_ERROR;
 }
 
 mojom::ChromeAccountType GetAccountType() {
-  return ArcSessionManager::IsArcKioskMode()
-             ? mojom::ChromeAccountType::ROBOT_ACCOUNT
-             : mojom::ChromeAccountType::USER_ACCOUNT;
+  return IsArcKioskMode() ? mojom::ChromeAccountType::ROBOT_ACCOUNT
+                          : mojom::ChromeAccountType::USER_ACCOUNT;
 }
 
 }  // namespace
 
 // TODO(lhchavez): Get rid of this class once we can safely remove all the
 // deprecated interfaces and only need to care about one type of callback.
 class ArcAuthService::AccountInfoNotifier {
  public:
   explicit AccountInfoNotifier(
       const GetAuthCodeDeprecatedCallback& auth_callback)
@@ skipping 105 matching lines @@
 void ArcAuthService::GetAuthCodeDeprecated0(
     const GetAuthCodeDeprecated0Callback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   NOTREACHED() << "GetAuthCodeDeprecated0() should no longer be callable";
 }
 
 void ArcAuthService::GetAuthCodeDeprecated(
     const GetAuthCodeDeprecatedCallback& callback) {
   // For robot account we must use RequestAccountInfo because it allows
   // to specify account type.
-  DCHECK(!ArcSessionManager::IsArcKioskMode());
+  DCHECK(!IsArcKioskMode());
   RequestAccountInfoInternal(
       base::MakeUnique<ArcAuthService::AccountInfoNotifier>(callback));
 }
 
 void ArcAuthService::GetAuthCodeAndAccountTypeDeprecated(
     const GetAuthCodeAndAccountTypeDeprecatedCallback& callback) {
   RequestAccountInfoInternal(
       base::MakeUnique<ArcAuthService::AccountInfoNotifier>(callback));
 }
 
 void ArcAuthService::GetIsAccountManagedDeprecated(
     const GetIsAccountManagedDeprecatedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   callback.Run(
       policy_util::IsAccountManaged(ArcSessionManager::Get()->profile()));
 }
 
 void ArcAuthService::RequestAccountInfoInternal(
     std::unique_ptr<AccountInfoNotifier> notifier) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // No other auth code-related operation may be in progress.
   DCHECK(!notifier_);
   DCHECK(!fetcher_);
 
-  if (ArcSessionManager::IsOptInVerificationDisabled()) {
+  if (IsArcOptInVerificationDisabled()) {
     notifier->Notify(
         false /* = is_enforced */, std::string(), GetAccountType(),
         policy_util::IsAccountManaged(ArcSessionManager::Get()->profile()));
     return;
   }
 
   // Hereafter asynchronous operation. Remember the notifier.
   notifier_ = std::move(notifier);
 
-  if (ArcSessionManager::IsArcKioskMode()) {
+  if (IsArcKioskMode()) {
     // In Kiosk mode, use Robot auth code fetching.
     fetcher_ = base::MakeUnique<ArcRobotAuthCodeFetcher>();
   } else if (base::FeatureList::IsEnabled(arc::kArcUseAuthEndpointFeature)) {
     // Optionally retrieve auth code in silent mode.
     fetcher_ = base::MakeUnique<ArcBackgroundAuthCodeFetcher>(
         ArcSessionManager::Get()->profile(),
         ArcSessionManager::Get()->auth_context());
   } else {
     // Report that silent auth code is not activated. All other states are
     // reported in ArcBackgroundAuthCodeFetcher.
     UpdateSilentAuthCodeUMA(OptInSilentAuthCode::DISABLED);
     // Otherwise, show LSO page and let user click "Sign in" button.
     // Here, support_host should be available always. The case support_host is
-    // not created is when 1) IsOptInVerificationDisabled() is true or 2)
+    // not created is when 1) IsArcOptInVerificationDisabled() is true or 2)
     // IsArcKioskMode() is true. Both cases are handled above.
     fetcher_ = base::MakeUnique<ArcManualAuthCodeFetcher>(
         ArcSessionManager::Get()->auth_context(),
         ArcSessionManager::Get()->support_host());
   }
   fetcher_->Fetch(base::Bind(&ArcAuthService::OnAuthCodeFetched,
                              weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ArcAuthService::OnAuthCodeFetched(const std::string& auth_code) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   fetcher_.reset();
 
   if (auth_code.empty()) {
     ArcSessionManager::Get()->OnProvisioningFinished(
         ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
     return;
   }
 
   notifier_->Notify(
-      !ArcSessionManager::IsOptInVerificationDisabled(), auth_code,
-      GetAccountType(),
+      !IsArcOptInVerificationDisabled(), auth_code, GetAccountType(),
       policy_util::IsAccountManaged(ArcSessionManager::Get()->profile()));
   notifier_.reset();
 }
 
 }  // namespace arc