ChromeOS user_manager: move all KnownUser code to separate file.

chrome/browser/chromeos/login/signin/token_handle_util.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/login/signin/token_handle_util.h"
 
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
-#include "components/user_manager/user_manager.h"
+#include "components/user_manager/known_user.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 
 namespace {
 
 const char kTokenHandlePref[] = "PasswordTokenHandle";
 const char kTokenHandleStatusPref[] = "TokenHandleStatus";
 
 const char kHandleStatusValid[] = "valid";
 const char kHandleStatusInvalid[] = "invalid";
 const char* kDefaultHandleStatus = kHandleStatusValid;
 
 static const int kMaxRetries = 3;
 
 }  // namespace
 
-TokenHandleUtil::TokenHandleUtil(user_manager::UserManager* user_manager)
-    : user_manager_(user_manager), weak_factory_(this) {
-}
+TokenHandleUtil::TokenHandleUtil() : weak_factory_(this) {}
 
 TokenHandleUtil::~TokenHandleUtil() {
   weak_factory_.InvalidateWeakPtrs();
   gaia_client_.reset();
 }
 
 bool TokenHandleUtil::HasToken(const AccountId& account_id) {
   const base::DictionaryValue* dict = nullptr;
   std::string token;
-  if (!user_manager_->FindKnownUserPrefs(account_id, &dict))
+  if (!user_manager::known_user::FindKnownUserPrefs(account_id, &dict))
     return false;
   if (!dict->GetString(kTokenHandlePref, &token))
     return false;
   return !token.empty();
 }
 
 bool TokenHandleUtil::ShouldObtainHandle(const AccountId& account_id) {
   const base::DictionaryValue* dict = nullptr;
   std::string token;
-  if (!user_manager_->FindKnownUserPrefs(account_id, &dict))
+  if (!user_manager::known_user::FindKnownUserPrefs(account_id, &dict))
     return true;
   if (!dict->GetString(kTokenHandlePref, &token))
     return true;
   if (token.empty())
     return true;
   std::string status(kDefaultHandleStatus);
   dict->GetString(kTokenHandleStatusPref, &status);
   return kHandleStatusInvalid == status;
 }
 
 void TokenHandleUtil::DeleteHandle(const AccountId& account_id) {
   const base::DictionaryValue* dict = nullptr;
-  if (!user_manager_->FindKnownUserPrefs(account_id, &dict))
+  if (!user_manager::known_user::FindKnownUserPrefs(account_id, &dict))
     return;
   scoped_ptr<base::DictionaryValue> dict_copy(dict->DeepCopy());
   dict_copy->Remove(kTokenHandlePref, nullptr);
   dict_copy->Remove(kTokenHandleStatusPref, nullptr);
-  user_manager_->UpdateKnownUserPrefs(account_id, *dict_copy.get(),
-                                      /* replace values */ true);
+  user_manager::known_user::UpdateKnownUserPrefs(account_id, *dict_copy.get(),
+                                                 /* replace values */ true);
 }
 
 void TokenHandleUtil::MarkHandleInvalid(const AccountId& account_id) {
-  user_manager_->SetKnownUserStringPref(account_id, kTokenHandleStatusPref,
-                                        kHandleStatusInvalid);
+  user_manager::known_user::SetKnownUserStringPref(
+      account_id, kTokenHandleStatusPref, kHandleStatusInvalid);
 }
 
 void TokenHandleUtil::CheckToken(const AccountId& account_id,
                                  const TokenValidationCallback& callback) {
   const base::DictionaryValue* dict = nullptr;
   std::string token;
-  if (!user_manager_->FindKnownUserPrefs(account_id, &dict)) {
+  if (!user_manager::known_user::FindKnownUserPrefs(account_id, &dict)) {
     callback.Run(account_id, UNKNOWN);
     return;
   }
   if (!dict->GetString(kTokenHandlePref, &token)) {
     callback.Run(account_id, UNKNOWN);
     return;
   }
 
   if (!gaia_client_.get()) {
     auto request_context =
         chromeos::ProfileHelper::Get()->GetSigninProfile()->GetRequestContext();
     gaia_client_.reset(new gaia::GaiaOAuthClient(request_context));
   }
 
   validation_delegates_.set(
       token, scoped_ptr<TokenDelegate>(new TokenDelegate(
                  weak_factory_.GetWeakPtr(), account_id, token, callback)));
   gaia_client_->GetTokenHandleInfo(token, kMaxRetries,
                                    validation_delegates_.get(token));
 }
 
 void TokenHandleUtil::StoreTokenHandle(const AccountId& account_id,
                                        const std::string& handle) {
-  user_manager_->SetKnownUserStringPref(account_id, kTokenHandlePref, handle);
-  user_manager_->SetKnownUserStringPref(account_id, kTokenHandleStatusPref,
-                                        kHandleStatusValid);
+  user_manager::known_user::SetKnownUserStringPref(account_id, kTokenHandlePref,
+                                                   handle);
+  user_manager::known_user::SetKnownUserStringPref(
+      account_id, kTokenHandleStatusPref, kHandleStatusValid);
 }
 
 void TokenHandleUtil::OnValidationComplete(const std::string& token) {
   validation_delegates_.erase(token);
 }
 
 void TokenHandleUtil::OnObtainTokenComplete(const AccountId& account_id) {
   obtain_delegates_.erase(account_id);
 }
 
@@ skipping 35 matching lines @@
     if (token_info->GetInteger("expires_in", &expires_in))
       outcome = (expires_in < 0) ? INVALID : VALID;
   }
 
   const base::TimeDelta duration =
       base::TimeTicks::Now() - tokeninfo_response_start_time_;
   UMA_HISTOGRAM_TIMES("Login.TokenCheckResponseTime", duration);
   callback_.Run(account_id_, outcome);
   NotifyDone();
 }