1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/chromeos/login/session/session_manager.h"
6
7 #include <string>
8
9 #include "base/base_paths.h"
10 #include "base/bind.h"
11 #include "base/command_line.h"
12 #include "base/logging.h"
13 #include "base/path_service.h"
14 #include "base/prefs/pref_member.h"
15 #include "base/prefs/pref_registry_simple.h"
16 #include "base/prefs/pref_service.h"
17 #include "base/strings/string16.h"
18 #include "base/sys_info.h"
19 #include "base/task_runner_util.h"
20 #include "base/threading/worker_pool.h"
21 #include "chrome/browser/app_mode/app_mode_utils.h"
22 #include "chrome/browser/browser_process.h"
23 #include "chrome/browser/chrome_notification_types.h"
24 #include "chrome/browser/chromeos/boot_times_loader.h"
25 #include "chrome/browser/chromeos/input_method/input_method_util.h"
26 #include "chrome/browser/chromeos/login/demo_mode/demo_app_launcher.h"
27 #include "chrome/browser/chromeos/login/profile_auth_data.h"
28 #include "chrome/browser/chromeos/login/saml/saml_offline_signin_limiter.h"
29 #include "chrome/browser/chromeos/login/saml/saml_offline_signin_limiter_factory.h"
30 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager.h"
31 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager_factory.h"
32 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
33 #include "chrome/browser/chromeos/login/users/user.h"
34 #include "chrome/browser/chromeos/login/users/user_manager.h"
35 #include "chrome/browser/first_run/first_run.h"
36 #include "chrome/browser/google/google_brand_chromeos.h"
37 #include "chrome/browser/lifetime/application_lifetime.h"
38 #include "chrome/browser/profiles/profile.h"
39 #include "chrome/browser/profiles/profile_manager.h"
40 #include "chrome/browser/rlz/rlz.h"
41 #include "chrome/browser/signin/signin_manager_factory.h"
42 #include "chrome/common/chrome_switches.h"
43 #include "chrome/common/logging_chrome.h"
44 #include "chrome/common/pref_names.h"
45 #include "chromeos/chromeos_switches.h"
46 #include "chromeos/cryptohome/cryptohome_util.h"
47 #include "chromeos/dbus/cryptohome_client.h"
48 #include "chromeos/dbus/dbus_thread_manager.h"
49 #include "chromeos/dbus/session_manager_client.h"
50 #include "chromeos/ime/input_method_manager.h"
51 #include "components/signin/core/browser/signin_manager_base.h"
52 #include "content/public/browser/notification_service.h"
53
54 namespace chromeos {
55
56 namespace {
57
InitLocaleAndInputMethodsForNewUser(PrefService * prefs)58 void InitLocaleAndInputMethodsForNewUser(PrefService* prefs) {
59 // First, we'll set kLanguagePreloadEngines.
60 std::string locale = g_browser_process->GetApplicationLocale();
61 input_method::InputMethodManager* manager =
62 input_method::InputMethodManager::Get();
63 std::vector<std::string> input_method_ids;
64 manager->GetInputMethodUtil()->GetFirstLoginInputMethodIds(
65 locale, manager->GetCurrentInputMethod(), &input_method_ids);
66
67 // Save the input methods in the user's preferences.
68 StringPrefMember language_preload_engines;
69 language_preload_engines.Init(prefs::kLanguagePreloadEngines, prefs);
70 language_preload_engines.SetValue(JoinString(input_method_ids, ','));
71 BootTimesLoader::Get()->AddLoginTimeMarker("IMEStarted", false);
72
73 // Second, we'll set kLanguagePreferredLanguages.
74 std::vector<std::string> language_codes;
75
76 // The current locale should be on the top.
77 language_codes.push_back(locale);
78
79 // Add input method IDs based on the input methods, as there may be
80 // input methods that are unrelated to the current locale. Example: the
81 // hardware keyboard layout xkb:us::eng is used for logging in, but the
82 // UI language is set to French. In this case, we should set "fr,en"
83 // to the preferred languages preference.
84 std::vector<std::string> candidates;
85 manager->GetInputMethodUtil()->GetLanguageCodesFromInputMethodIds(
86 input_method_ids, &candidates);
87 for (size_t i = 0; i < candidates.size(); ++i) {
88 const std::string& candidate = candidates[i];
89 // Skip if it's already in language_codes.
90 if (std::count(language_codes.begin(), language_codes.end(),
91 candidate) == 0) {
92 language_codes.push_back(candidate);
93 }
94 }
95
96 // Save the preferred languages in the user's preferences.
97 StringPrefMember language_preferred_languages;
98 language_preferred_languages.Init(prefs::kLanguagePreferredLanguages, prefs);
99 language_preferred_languages.SetValue(JoinString(language_codes, ','));
100 }
101
102 #if defined(ENABLE_RLZ)
103 // Flag file that disables RLZ tracking, when present.
104 const base::FilePath::CharType kRLZDisabledFlagName[] =
105 FILE_PATH_LITERAL(".rlz_disabled");
106
GetRlzDisabledFlagPath()107 base::FilePath GetRlzDisabledFlagPath() {
108 base::FilePath homedir;
109 PathService::Get(base::DIR_HOME, &homedir);
110 return homedir.Append(kRLZDisabledFlagName);
111 }
112 #endif
113
114 } // namespace
115
116 // static
GetInstance()117 SessionManager* SessionManager::GetInstance() {
118 return Singleton<SessionManager,
119 DefaultSingletonTraits<SessionManager> >::get();
120 }
121
122 // static
RegisterPrefs(PrefRegistrySimple * registry)123 void SessionManager::RegisterPrefs(PrefRegistrySimple* registry) {
124 registry->RegisterStringPref(prefs::kRLZBrand, std::string());
125 registry->RegisterBooleanPref(prefs::kRLZDisabled, false);
126 }
127
SessionManager()128 SessionManager::SessionManager()
129 : delegate_(NULL),
130 has_web_auth_cookies_(false),
131 exit_after_session_restore_(false),
132 session_restore_strategy_(
133 OAuth2LoginManager::RESTORE_FROM_SAVED_OAUTH2_REFRESH_TOKEN) {
134 net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
135 }
136
~SessionManager()137 SessionManager::~SessionManager() {
138 net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
139 }
140
OnSessionRestoreStateChanged(Profile * user_profile,OAuth2LoginManager::SessionRestoreState state)141 void SessionManager::OnSessionRestoreStateChanged(
142 Profile* user_profile,
143 OAuth2LoginManager::SessionRestoreState state) {
144 User::OAuthTokenStatus user_status = User::OAUTH_TOKEN_STATUS_UNKNOWN;
145 OAuth2LoginManager* login_manager =
146 OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
147
148 bool connection_error = false;
149 switch (state) {
150 case OAuth2LoginManager::SESSION_RESTORE_DONE:
151 user_status = User::OAUTH2_TOKEN_STATUS_VALID;
152 break;
153 case OAuth2LoginManager::SESSION_RESTORE_FAILED:
154 user_status = User::OAUTH2_TOKEN_STATUS_INVALID;
155 break;
156 case OAuth2LoginManager::SESSION_RESTORE_CONNECTION_FAILED:
157 connection_error = true;
158 break;
159 case OAuth2LoginManager::SESSION_RESTORE_NOT_STARTED:
160 case OAuth2LoginManager::SESSION_RESTORE_PREPARING:
161 case OAuth2LoginManager::SESSION_RESTORE_IN_PROGRESS:
162 return;
163 }
164
165 // We should not be clearing existing token state if that was a connection
166 // error. http://crbug.com/295245
167 if (!connection_error) {
168 // We are in one of "done" states here.
169 UserManager::Get()->SaveUserOAuthStatus(
170 UserManager::Get()->GetLoggedInUser()->email(),
171 user_status);
172 }
173
174 login_manager->RemoveObserver(this);
175 }
176
OnNewRefreshTokenAvaiable(Profile * user_profile)177 void SessionManager::OnNewRefreshTokenAvaiable(Profile* user_profile) {
178 // Check if we were waiting to restart chrome.
179 if (!exit_after_session_restore_)
180 return;
181
182 OAuth2LoginManager* login_manager =
183 OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
184 login_manager->RemoveObserver(this);
185
186 // Mark user auth token status as valid.
187 UserManager::Get()->SaveUserOAuthStatus(
188 UserManager::Get()->GetLoggedInUser()->email(),
189 User::OAUTH2_TOKEN_STATUS_VALID);
190
191 LOG(WARNING) << "Exiting after new refresh token fetched";
192
193 // We need to restart cleanly in this case to make sure OAuth2 RT is actually
194 // saved.
195 chrome::AttemptRestart();
196 }
197
OnConnectionTypeChanged(net::NetworkChangeNotifier::ConnectionType type)198 void SessionManager::OnConnectionTypeChanged(
199 net::NetworkChangeNotifier::ConnectionType type) {
200 UserManager* user_manager = UserManager::Get();
201 if (type == net::NetworkChangeNotifier::CONNECTION_NONE ||
202 user_manager->IsLoggedInAsGuest() || !user_manager->IsUserLoggedIn()) {
203 return;
204 }
205
206 // Need to iterate over all users and their OAuth2 session state.
207 const UserList& users = user_manager->GetLoggedInUsers();
208 for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
209 Profile* user_profile = user_manager->GetProfileByUser(*it);
210 bool should_restore_session =
211 pending_restore_sessions_.find((*it)->email()) !=
212 pending_restore_sessions_.end();
213 OAuth2LoginManager* login_manager =
214 OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
215 if (login_manager->state() ==
216 OAuth2LoginManager::SESSION_RESTORE_IN_PROGRESS) {
217 // If we come online for the first time after successful offline login,
218 // we need to kick off OAuth token verification process again.
219 login_manager->ContinueSessionRestore();
220 } else if (should_restore_session) {
221 pending_restore_sessions_.erase((*it)->email());
222 RestoreAuthSessionImpl(user_profile, has_web_auth_cookies_);
223 }
224 }
225 }
226
StartSession(const UserContext & user_context,scoped_refptr<Authenticator> authenticator,bool has_cookies,bool has_active_session,Delegate * delegate)227 void SessionManager::StartSession(const UserContext& user_context,
228 scoped_refptr<Authenticator> authenticator,
229 bool has_cookies,
230 bool has_active_session,
231 Delegate* delegate) {
232 authenticator_ = authenticator;
233 delegate_ = delegate;
234
235 VLOG(1) << "Starting session for " << user_context.GetUserID();
236
237 PreStartSession();
238 CreateUserSession(user_context, has_cookies);
239
240 if (!has_active_session)
241 StartCrosSession();
242
243 // TODO(nkostylev): Notify UserLoggedIn() after profile is actually
244 // ready to be used (http://crbug.com/361528).
245 NotifyUserLoggedIn();
246 PrepareProfile();
247 }
248
RestoreAuthenticationSession(Profile * user_profile)249 void SessionManager::RestoreAuthenticationSession(Profile* user_profile) {
250 UserManager* user_manager = UserManager::Get();
251 // We don't need to restore session for demo/guest/stub/public account users.
252 if (!user_manager->IsUserLoggedIn() ||
253 user_manager->IsLoggedInAsGuest() ||
254 user_manager->IsLoggedInAsPublicAccount() ||
255 user_manager->IsLoggedInAsDemoUser() ||
256 user_manager->IsLoggedInAsStub()) {
257 return;
258 }
259
260 User* user = user_manager->GetUserByProfile(user_profile);
261 DCHECK(user);
262 if (!net::NetworkChangeNotifier::IsOffline()) {
263 pending_restore_sessions_.erase(user->email());
264 RestoreAuthSessionImpl(user_profile, false);
265 } else {
266 // Even if we're online we should wait till initial
267 // OnConnectionTypeChanged() call. Otherwise starting fetchers too early may
268 // end up canceling all request when initial network connection type is
269 // processed. See http://crbug.com/121643.
270 pending_restore_sessions_.insert(user->email());
271 }
272 }
273
InitRlz(Profile * profile)274 void SessionManager::InitRlz(Profile* profile) {
275 #if defined(ENABLE_RLZ)
276 if (!g_browser_process->local_state()->HasPrefPath(prefs::kRLZBrand)) {
277 // Read brand code asynchronously from an OEM data and repost ourselves.
278 google_brand::chromeos::InitBrand(
279 base::Bind(&SessionManager::InitRlz, AsWeakPtr(), profile));
280 return;
281 }
282 base::PostTaskAndReplyWithResult(
283 base::WorkerPool::GetTaskRunner(false),
284 FROM_HERE,
285 base::Bind(&base::PathExists, GetRlzDisabledFlagPath()),
286 base::Bind(&SessionManager::InitRlzImpl, AsWeakPtr(), profile));
287 #endif
288 }
289
290 OAuth2LoginManager::SessionRestoreStrategy
GetSigninSessionRestoreStrategy()291 SessionManager::GetSigninSessionRestoreStrategy() {
292 return session_restore_strategy_;
293 }
294
295 // static
SetFirstLoginPrefs(PrefService * prefs)296 void SessionManager::SetFirstLoginPrefs(PrefService* prefs) {
297 VLOG(1) << "Setting first login prefs";
298 InitLocaleAndInputMethodsForNewUser(prefs);
299 }
300
CreateUserSession(const UserContext & user_context,bool has_cookies)301 void SessionManager::CreateUserSession(const UserContext& user_context,
302 bool has_cookies) {
303 user_context_ = user_context;
304 has_web_auth_cookies_ = has_cookies;
305 InitSessionRestoreStrategy();
306 }
307
PreStartSession()308 void SessionManager::PreStartSession() {
309 // Switch log file as soon as possible.
310 if (base::SysInfo::IsRunningOnChromeOS())
311 logging::RedirectChromeLogging(*(CommandLine::ForCurrentProcess()));
312 }
313
StartCrosSession()314 void SessionManager::StartCrosSession() {
315 BootTimesLoader* btl = BootTimesLoader::Get();
316 btl->AddLoginTimeMarker("StartSession-Start", false);
317 DBusThreadManager::Get()->GetSessionManagerClient()->
318 StartSession(user_context_.GetUserID());
319 btl->AddLoginTimeMarker("StartSession-End", false);
320 }
321
NotifyUserLoggedIn()322 void SessionManager:: NotifyUserLoggedIn() {
323 BootTimesLoader* btl = BootTimesLoader::Get();
324 btl->AddLoginTimeMarker("UserLoggedIn-Start", false);
325 UserManager* user_manager = UserManager::Get();
326 user_manager->UserLoggedIn(user_context_.GetUserID(),
327 user_context_.GetUserIDHash(),
328 false);
329 btl->AddLoginTimeMarker("UserLoggedIn-End", false);
330 }
331
PrepareProfile()332 void SessionManager::PrepareProfile() {
333 UserManager* user_manager = UserManager::Get();
334 bool is_demo_session =
335 DemoAppLauncher::IsDemoAppSession(user_context_.GetUserID());
336
337 // TODO(nkostylev): Figure out whether demo session is using the right profile
338 // path or not. See https://codereview.chromium.org/171423009
339 g_browser_process->profile_manager()->CreateProfileAsync(
340 user_manager->GetUserProfileDir(user_context_.GetUserID()),
341 base::Bind(&SessionManager::OnProfileCreated, AsWeakPtr(),
342 user_context_.GetUserID(), is_demo_session),
343 base::string16(), base::string16(), std::string());
344 }
345
OnProfileCreated(const std::string & user_id,bool is_incognito_profile,Profile * profile,Profile::CreateStatus status)346 void SessionManager::OnProfileCreated(const std::string& user_id,
347 bool is_incognito_profile,
348 Profile* profile,
349 Profile::CreateStatus status) {
350 CHECK(profile);
351
352 switch (status) {
353 case Profile::CREATE_STATUS_CREATED:
354 // Profile created but before initializing extensions and promo resources.
355 InitProfilePreferences(profile, user_id);
356 break;
357 case Profile::CREATE_STATUS_INITIALIZED:
358 // Profile is created, extensions and promo resources are initialized.
359 // At this point all other Chrome OS services will be notified that it is
360 // safe to use this profile.
361 UserProfileInitialized(profile, is_incognito_profile);
362 break;
363 case Profile::CREATE_STATUS_LOCAL_FAIL:
364 case Profile::CREATE_STATUS_REMOTE_FAIL:
365 case Profile::CREATE_STATUS_CANCELED:
366 case Profile::MAX_CREATE_STATUS:
367 NOTREACHED();
368 break;
369 }
370 }
371
InitProfilePreferences(Profile * profile,const std::string & user_id)372 void SessionManager::InitProfilePreferences(Profile* profile,
373 const std::string& user_id) {
374 if (UserManager::Get()->IsCurrentUserNew())
375 SetFirstLoginPrefs(profile->GetPrefs());
376
377 if (UserManager::Get()->IsLoggedInAsLocallyManagedUser()) {
378 User* active_user = UserManager::Get()->GetActiveUser();
379 std::string managed_user_sync_id =
380 UserManager::Get()->GetSupervisedUserManager()->
381 GetUserSyncId(active_user->email());
382 profile->GetPrefs()->SetString(prefs::kSupervisedUserId,
383 managed_user_sync_id);
384 } else if (UserManager::Get()->IsLoggedInAsRegularUser()) {
385 // Make sure that the google service username is properly set (we do this
386 // on every sign in, not just the first login, to deal with existing
387 // profiles that might not have it set yet).
388 SigninManagerBase* signin_manager =
389 SigninManagerFactory::GetForProfile(profile);
390 signin_manager->SetAuthenticatedUsername(user_id);
391 }
392 }
393
UserProfileInitialized(Profile * profile,bool is_incognito_profile)394 void SessionManager::UserProfileInitialized(Profile* profile,
395 bool is_incognito_profile) {
396 if (is_incognito_profile) {
397 profile->OnLogin();
398 // Send the notification before creating the browser so additional objects
399 // that need the profile (e.g. the launcher) can be created first.
400 content::NotificationService::current()->Notify(
401 chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
402 content::NotificationService::AllSources(),
403 content::Details<Profile>(profile));
404
405 if (delegate_)
406 delegate_->OnProfilePrepared(profile);
407
408 return;
409 }
410
411 BootTimesLoader* btl = BootTimesLoader::Get();
412 btl->AddLoginTimeMarker("UserProfileGotten", false);
413
414 if (user_context_.IsUsingOAuth()) {
415 // Transfer proxy authentication cache, cookies (optionally) and server
416 // bound certs from the profile that was used for authentication. This
417 // profile contains cookies that auth extension should have already put in
418 // place that will ensure that the newly created session is authenticated
419 // for the websites that work with the used authentication schema.
420 ProfileAuthData::Transfer(
421 authenticator_->authentication_profile(),
422 profile,
423 has_web_auth_cookies_, // transfer_cookies
424 base::Bind(&SessionManager::CompleteProfileCreateAfterAuthTransfer,
425 AsWeakPtr(),
426 profile));
427 return;
428 }
429
430 FinalizePrepareProfile(profile);
431 }
432
CompleteProfileCreateAfterAuthTransfer(Profile * profile)433 void SessionManager::CompleteProfileCreateAfterAuthTransfer(Profile* profile) {
434 RestoreAuthSessionImpl(profile, has_web_auth_cookies_);
435 FinalizePrepareProfile(profile);
436 }
437
FinalizePrepareProfile(Profile * profile)438 void SessionManager::FinalizePrepareProfile(Profile* profile) {
439 BootTimesLoader* btl = BootTimesLoader::Get();
440
441 // Own TPM device if, for any reason, it has not been done in EULA screen.
442 CryptohomeClient* client = DBusThreadManager::Get()->GetCryptohomeClient();
443 btl->AddLoginTimeMarker("TPMOwn-Start", false);
444 if (cryptohome_util::TpmIsEnabled() && !cryptohome_util::TpmIsBeingOwned()) {
445 if (cryptohome_util::TpmIsOwned()) {
446 client->CallTpmClearStoredPasswordAndBlock();
447 } else {
448 client->TpmCanAttemptOwnership(EmptyVoidDBusMethodCallback());
449 }
450 }
451 btl->AddLoginTimeMarker("TPMOwn-End", false);
452
453 UserManager* user_manager = UserManager::Get();
454 if (user_manager->IsLoggedInAsRegularUser()) {
455 SAMLOfflineSigninLimiter* saml_offline_signin_limiter =
456 SAMLOfflineSigninLimiterFactory::GetForProfile(profile);
457 if (saml_offline_signin_limiter)
458 saml_offline_signin_limiter->SignedIn(user_context_.GetAuthFlow());
459 }
460
461 profile->OnLogin();
462
463 // Send the notification before creating the browser so additional objects
464 // that need the profile (e.g. the launcher) can be created first.
465 content::NotificationService::current()->Notify(
466 chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
467 content::NotificationService::AllSources(),
468 content::Details<Profile>(profile));
469
470 // Initialize RLZ only for primary user.
471 if (user_manager->GetPrimaryUser() ==
472 user_manager->GetUserByProfile(profile)) {
473 InitRlz(profile);
474 }
475
476 // TODO(altimofeev): This pointer should probably never be NULL, but it looks
477 // like LoginUtilsImpl::OnProfileCreated() may be getting called before
478 // SessionManager::PrepareProfile() has set |delegate_| when Chrome is killed
479 // during shutdown in tests -- see http://crosbug.com/18269. Replace this
480 // 'if' statement with a CHECK(delegate_) once the underlying issue is
481 // resolved.
482 if (delegate_)
483 delegate_->OnProfilePrepared(profile);
484 }
485
InitSessionRestoreStrategy()486 void SessionManager::InitSessionRestoreStrategy() {
487 CommandLine* command_line = CommandLine::ForCurrentProcess();
488 bool in_app_mode = chrome::IsRunningInForcedAppMode();
489
490 // Are we in kiosk app mode?
491 if (in_app_mode) {
492 if (command_line->HasSwitch(::switches::kAppModeOAuth2Token)) {
493 oauth2_refresh_token_ = command_line->GetSwitchValueASCII(
494 ::switches::kAppModeOAuth2Token);
495 }
496
497 if (command_line->HasSwitch(::switches::kAppModeAuthCode)) {
498 user_context_.SetAuthCode(command_line->GetSwitchValueASCII(
499 ::switches::kAppModeAuthCode));
500 }
501
502 DCHECK(!has_web_auth_cookies_);
503 if (!user_context_.GetAuthCode().empty()) {
504 session_restore_strategy_ = OAuth2LoginManager::RESTORE_FROM_AUTH_CODE;
505 } else if (!oauth2_refresh_token_.empty()) {
506 session_restore_strategy_ =
507 OAuth2LoginManager::RESTORE_FROM_PASSED_OAUTH2_REFRESH_TOKEN;
508 } else {
509 session_restore_strategy_ =
510 OAuth2LoginManager::RESTORE_FROM_SAVED_OAUTH2_REFRESH_TOKEN;
511 }
512 return;
513 }
514
515 if (has_web_auth_cookies_) {
516 session_restore_strategy_ = OAuth2LoginManager::RESTORE_FROM_COOKIE_JAR;
517 } else if (!user_context_.GetAuthCode().empty()) {
518 session_restore_strategy_ = OAuth2LoginManager::RESTORE_FROM_AUTH_CODE;
519 } else {
520 session_restore_strategy_ =
521 OAuth2LoginManager::RESTORE_FROM_SAVED_OAUTH2_REFRESH_TOKEN;
522 }
523 }
524
RestoreAuthSessionImpl(Profile * profile,bool restore_from_auth_cookies)525 void SessionManager::RestoreAuthSessionImpl(Profile* profile,
526 bool restore_from_auth_cookies) {
527 CHECK((authenticator_.get() && authenticator_->authentication_profile()) ||
528 !restore_from_auth_cookies);
529
530 if (chrome::IsRunningInForcedAppMode() ||
531 CommandLine::ForCurrentProcess()->HasSwitch(
532 chromeos::switches::kOobeSkipPostLogin)) {
533 return;
534 }
535
536 exit_after_session_restore_ = false;
537
538 // Remove legacy OAuth1 token if we have one. If it's valid, we should already
539 // have OAuth2 refresh token in OAuth2TokenService that could be used to
540 // retrieve all other tokens and user_context.
541 OAuth2LoginManager* login_manager =
542 OAuth2LoginManagerFactory::GetInstance()->GetForProfile(profile);
543 login_manager->AddObserver(this);
544 login_manager->RestoreSession(
545 authenticator_.get() && authenticator_->authentication_profile()
546 ? authenticator_->authentication_profile()->GetRequestContext()
547 : NULL,
548 session_restore_strategy_,
549 oauth2_refresh_token_,
550 user_context_.GetAuthCode());
551 }
552
InitRlzImpl(Profile * profile,bool disabled)553 void SessionManager::InitRlzImpl(Profile* profile, bool disabled) {
554 #if defined(ENABLE_RLZ)
555 PrefService* local_state = g_browser_process->local_state();
556 if (disabled) {
557 // Empty brand code means an organic install (no RLZ pings are sent).
558 google_brand::chromeos::ClearBrandForCurrentSession();
559 }
560 if (disabled != local_state->GetBoolean(prefs::kRLZDisabled)) {
561 // When switching to RLZ enabled/disabled state, clear all recorded events.
562 RLZTracker::ClearRlzState();
563 local_state->SetBoolean(prefs::kRLZDisabled, disabled);
564 }
565 // Init the RLZ library.
566 int ping_delay = profile->GetPrefs()->GetInteger(
567 first_run::GetPingDelayPrefName().c_str());
568 // Negative ping delay means to send ping immediately after a first search is
569 // recorded.
570 RLZTracker::InitRlzFromProfileDelayed(
571 profile, UserManager::Get()->IsCurrentUserNew(),
572 ping_delay < 0, base::TimeDelta::FromMilliseconds(abs(ping_delay)));
573 if (delegate_)
574 delegate_->OnRlzInitialized();
575 #endif
576 }
577
578 } // namespace chromeos
579