arc: Skip GMS Sign-In in case Android is already signed-in.

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/memory/ptr_util.h"
@@ skipping 72 matching lines @@
       const GetAuthCodeAndAccountTypeDeprecatedCallback& auth_account_callback)
       : callback_type_(CallbackType::AUTH_CODE_AND_ACCOUNT),
         auth_account_callback_(auth_account_callback) {}
 
   explicit AccountInfoNotifier(const AccountInfoCallback& account_info_callback)
       : callback_type_(CallbackType::ACCOUNT_INFO),
         account_info_callback_(account_info_callback) {}
 
   void Notify(bool is_enforced,
               const std::string& auth_info,
+              const std::string& account_name,
               mojom::ChromeAccountType account_type,
               bool is_managed) {
     switch (callback_type_) {
       case CallbackType::AUTH_CODE:
         DCHECK(!auth_callback_.is_null());
         auth_callback_.Run(auth_info, is_enforced);
         break;
       case CallbackType::AUTH_CODE_AND_ACCOUNT:
         DCHECK(!auth_account_callback_.is_null());
         auth_account_callback_.Run(auth_info, is_enforced, account_type);
         break;
       case CallbackType::ACCOUNT_INFO:
         DCHECK(!account_info_callback_.is_null());
         mojom::AccountInfoPtr account_info = mojom::AccountInfo::New();
+        account_info->account_name = account_name;
         if (account_type ==
             mojom::ChromeAccountType::ACTIVE_DIRECTORY_ACCOUNT) {
           account_info->enrollment_token = auth_info;
         } else {
           if (!is_enforced)
             account_info->auth_code = base::nullopt;
           else
             account_info->auth_code = auth_info;
         }
         account_info->account_type = account_type;
@@ skipping 71 matching lines @@
       UpdateAuthCheckinAttempts(value);
       break;
     case mojom::MetricsType::CHECKIN_TIME_MILLISECONDS:
       UpdateAuthTiming("ArcAuth.CheckinTime",
                        base::TimeDelta::FromMilliseconds(value));
       break;
     case mojom::MetricsType::SIGNIN_TIME_MILLISECONDS:
       UpdateAuthTiming("ArcAuth.SignInTime",
                        base::TimeDelta::FromMilliseconds(value));
       break;
+    case mojom::MetricsType::ACCOUNT_CHECK_MILLISECONDS:
+      UpdateAuthTiming("ArcAuth.AccountCheckTime",
+                       base::TimeDelta::FromMilliseconds(value));
+      break;
   }
 }
 
+void ArcAuthService::ReportAccountCheckStatus(
+    mojom::AccountCheckStatus status) {
+  switch (status) {
+    case mojom::AccountCheckStatus::UP_TO_DATE:
+      UpdateAuthAccountCheckStatus(AccountCheckStatus::UP_TO_DATE);
+      break;
+    case mojom::AccountCheckStatus::NEW:
+      UpdateAuthAccountCheckStatus(AccountCheckStatus::NEW);
+      break;
+    case mojom::AccountCheckStatus::NEED_REAUTH:
+      UpdateAuthAccountCheckStatus(AccountCheckStatus::NEED_REAUTH);
+      break;
+    case mojom::AccountCheckStatus::UNKNOWN:
+      UpdateAuthAccountCheckStatus(AccountCheckStatus::UNKNOWN);
+      break;
+    case mojom::AccountCheckStatus::CHECK_FAILED:
+      UpdateAuthAccountCheckStatus(AccountCheckStatus::CHECK_FAILED);
+      break;
+    default:
+      NOTREACHED() << "Unknown account check status";

[dcheng, 2017/03/25 00:55:04]

Please typemap this enum instead =)

(Or just use the mojo enum everywhere)

[khmel, 2017/03/25 01:24:14]

Not sure if I got you correctly. I added << status;

+  }
+}
+
 void ArcAuthService::OnAccountInfoReady(mojom::AccountInfoPtr account_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   auto* instance = ARC_GET_INSTANCE_FOR_METHOD(arc_bridge_service()->auth(),
                                                OnAccountInfoReady);
   DCHECK(instance);
   instance->OnAccountInfoReady(std::move(account_info));
 }
 
 void ArcAuthService::GetAuthCodeDeprecated0(
     const GetAuthCodeDeprecated0Callback& callback) {
@@ skipping 25 matching lines @@
 
 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 (IsArcOptInVerificationDisabled()) {
     notifier->Notify(
-        false /* = is_enforced */, std::string(), GetAccountType(),
+        false /* = is_enforced */, std::string() /* auth_info */,
+        std::string() /* auth_name */, GetAccountType(),
         policy_util::IsAccountManaged(ArcSessionManager::Get()->profile()));
     return;
   }
 
   // Hereafter asynchronous operation. Remember the notifier.
   notifier_ = std::move(notifier);
 
   Profile* profile = ArcSessionManager::Get()->profile();
   const user_manager::User* user = nullptr;
   if (profile)
     user = chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
+
   if (user && user->IsActiveDirectoryUser()) {
     // For Active Directory enrolled devices, we get an enrollment token for a
     // managed Google Play account from DMServer.
     fetcher_ = base::MakeUnique<ArcActiveDirectoryEnrollmentTokenFetcher>();
     fetcher_->Fetch(base::Bind(&ArcAuthService::OnEnrollmentTokenFetched,
                                weak_ptr_factory_.GetWeakPtr()));
     return;
   }
   // For non-AD enrolled devices an auth code is fetched.
   if (IsArcKioskMode()) {
@@ skipping 22 matching lines @@
 
 void ArcAuthService::OnEnrollmentTokenFetched(
     ArcAuthInfoFetcher::Status status,
     const std::string& enrollment_token) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   fetcher_.reset();
 
   switch (status) {
     case ArcAuthInfoFetcher::Status::SUCCESS:
       notifier_->Notify(true /*is_enforced*/, enrollment_token,
+                        std::string() /* account_name */,
                         mojom::ChromeAccountType::ACTIVE_DIRECTORY_ACCOUNT,
                         true);
       notifier_.reset();
       return;
     case ArcAuthInfoFetcher::Status::FAILURE:
       ArcSessionManager::Get()->OnProvisioningFinished(
           ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
       return;
     case ArcAuthInfoFetcher::Status::ARC_DISABLED:
       ArcSessionManager::Get()->OnProvisioningFinished(
           ProvisioningResult::ARC_DISABLED);
       return;
   }
 }
 
 void ArcAuthService::OnAuthCodeFetched(ArcAuthInfoFetcher::Status status,
                                        const std::string& auth_code) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   fetcher_.reset();
 
   if (status != ArcAuthInfoFetcher::Status::SUCCESS) {
     ArcSessionManager::Get()->OnProvisioningFinished(
         ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
     return;
   }
 
   notifier_->Notify(
-      !IsArcOptInVerificationDisabled(), auth_code, GetAccountType(),
+      !IsArcOptInVerificationDisabled(), auth_code,
+      ArcSessionManager::Get()->auth_context()->full_account_id(),
+      GetAccountType(),
       policy_util::IsAccountManaged(ArcSessionManager::Get()->profile()));
   notifier_.reset();
 }
 
 }  // namespace arc