user_manager component: Add UserManagerBase class.

chrome/browser/chromeos/login/session/user_session_manager.cc

 // Copyright 2014 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/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/chromeos/login/saml/saml_offline_signin_limiter.h"
 #include "chrome/browser/chromeos/login/saml/saml_offline_signin_limiter_factory.h"
 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager.h"
 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager_factory.h"
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/google/google_brand_chromeos.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/browser/net/crl_set_fetcher.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/cert_loader.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 256 matching lines @@
     return;
   }
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(false),
       FROM_HERE,
       base::Bind(&base::PathExists, GetRlzDisabledFlagPath()),
       base::Bind(&UserSessionManager::InitRlzImpl, AsWeakPtr(), profile));
 #endif
 }
 
-bool UserSessionManager::HasBrowserRestarted() const {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  return base::SysInfo::IsRunningOnChromeOS() &&
-         command_line->HasSwitch(switches::kLoginUser);
-}
-
 OAuth2LoginManager::SessionRestoreStrategy
 UserSessionManager::GetSigninSessionRestoreStrategy() {
   return session_restore_strategy_;
 }
 
 // static
 void UserSessionManager::SetFirstLoginPrefs(
     PrefService* prefs,
     const std::string& public_session_locale,
     const std::string& public_session_input_method) {
@@ skipping 398 matching lines @@
   FinalizePrepareProfile(profile);
 }
 
 void UserSessionManager::FinalizePrepareProfile(Profile* profile) {
   BootTimesLoader* btl = BootTimesLoader::Get();
 
   // Own TPM device if, for any reason, it has not been done in EULA screen.
   CryptohomeClient* client = DBusThreadManager::Get()->GetCryptohomeClient();
   btl->AddLoginTimeMarker("TPMOwn-Start", false);
   if (cryptohome_util::TpmIsEnabled() && !cryptohome_util::TpmIsBeingOwned()) {
-    if (cryptohome_util::TpmIsOwned()) {
+    if (cryptohome_util::TpmIsOwned())
       client->CallTpmClearStoredPasswordAndBlock();
-    } else {
+    else
       client->TpmCanAttemptOwnership(EmptyVoidDBusMethodCallback());
-    }
   }
   btl->AddLoginTimeMarker("TPMOwn-End", false);
 
   UserManager* user_manager = UserManager::Get();
   if (user_manager->IsLoggedInAsRegularUser()) {
     SAMLOfflineSigninLimiter* saml_offline_signin_limiter =
         SAMLOfflineSigninLimiterFactory::GetForProfile(profile);
     if (saml_offline_signin_limiter)
       saml_offline_signin_limiter->SignedIn(user_context_.GetAuthFlow());
   }
 
   profile->OnLogin();
 
   g_browser_process->platform_part()->SessionManager()->SetSessionState(
       session_manager::SESSION_STATE_LOGGED_IN_NOT_ACTIVE);
 
   // Send the notification before creating the browser so additional objects
   // that need the profile (e.g. the launcher) can be created first.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
       content::Details<Profile>(profile));
 
-  InitializeCertsForPrimaryUser(profile);
-
-  // Initialize RLZ only for primary user.
+  // Initialize various services only for primary user.
   const user_manager::User* user =
       ProfileHelper::Get()->GetUserByProfile(profile);
-  if (user_manager->GetPrimaryUser() == user)
+  if (user_manager->GetPrimaryUser() == user) {
     InitRlz(profile);
+    InitializeCerts(profile);
+    InitializeCRLSetFetcher(user);
+  }
 
-  // TODO(altimofeev): This pointer should probably never be NULL, but it looks
+  // TODO(nkostylev): This pointer should probably never be NULL, but it looks
   // like LoginUtilsImpl::OnProfileCreated() may be getting called before
   // UserSessionManager::PrepareProfile() has set |delegate_| when Chrome is
   // killed during shutdown in tests -- see http://crosbug.com/18269.  Replace
   // this 'if' statement with a CHECK(delegate_) once the underlying issue is
   // resolved.
   if (delegate_)
     delegate_->OnProfilePrepared(profile);
 }
 
 void UserSessionManager::InitSessionRestoreStrategy() {
@@ skipping 81 matching lines @@
   // Negative ping delay means to send ping immediately after a first search is
   // recorded.
   RLZTracker::InitRlzFromProfileDelayed(
       profile, UserManager::Get()->IsCurrentUserNew(),
       ping_delay < 0, base::TimeDelta::FromMilliseconds(abs(ping_delay)));
   if (delegate_)
     delegate_->OnRlzInitialized();
 #endif
 }
 
-void UserSessionManager::InitializeCertsForPrimaryUser(Profile* profile) {
+void UserSessionManager::InitializeCerts(Profile* profile) {
   // Now that the user profile has been initialized
   // |GetNSSCertDatabaseForProfile| is safe to be used.
-  UserManager* user_manager = UserManager::Get();
-  const user_manager::User* primary_user = user_manager->GetPrimaryUser();
-  if (user_manager->IsUserLoggedIn() &&
-      primary_user &&
-      profile == ProfileHelper::Get()->GetProfileByUser(primary_user) &&
-      CertLoader::IsInitialized() &&
-      base::SysInfo::IsRunningOnChromeOS()) {
+  if (CertLoader::IsInitialized() && base::SysInfo::IsRunningOnChromeOS()) {
     GetNSSCertDatabaseForProfile(profile,
                                  base::Bind(&OnGetNSSCertDatabaseForUser));
   }
 }
 
+void UserSessionManager::InitializeCRLSetFetcher(
+    const user_manager::User* user) {
+  const std::string username_hash = user->username_hash();
+  if (!username_hash.empty()) {
+    base::FilePath path;
+    path = ProfileHelper::GetProfilePathByUserIdHash(username_hash);
+    component_updater::ComponentUpdateService* cus =
+        g_browser_process->component_updater();
+    CRLSetFetcher* crl_set = g_browser_process->crl_set_fetcher();
+    if (crl_set && cus)
+      crl_set->StartInitialLoad(cus, path);
+  }
+}
+
 void UserSessionManager::OnRestoreActiveSessions(
     const SessionManagerClient::ActiveSessionsMap& sessions,
     bool success) {
   if (!success) {
     LOG(ERROR) << "Could not get list of active user sessions after crash.";
     // If we could not get list of active user sessions it is safer to just
     // sign out so that we don't get in the inconsistent state.
     DBusThreadManager::Get()->GetSessionManagerClient()->StopSession();
     return;
   }
@@ skipping 61 matching lines @@
 
 void UserSessionManager::NotifyPendingUserSessionsRestoreFinished() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   user_sessions_restored_ = true;
   FOR_EACH_OBSERVER(UserSessionStateObserver,
                     session_state_observer_list_,
                     PendingUserSessionsRestoreFinished());
 }
 
 }  // namespace chromeos