Add policy for limiting the session length

chrome/browser/chromeos/login/user_manager_impl.cc

 // Copyright (c) 2012 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/user_manager_impl.h"
 
 #include <cstddef>
 #include <set>
 #include <vector>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cert_library.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/remove_user_delegate.h"
 #include "chrome/browser/chromeos/login/user_image_manager_impl.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
+#include "chrome/browser/chromeos/power/session_length_limiter.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/cryptohome/async_method_caller.h"
@@ skipping 110 matching lines @@
   local_state->RegisterListPref(kRegularUsers, PrefService::UNSYNCABLE_PREF);
   local_state->RegisterListPref(kPublicAccounts, PrefService::UNSYNCABLE_PREF);
   local_state->RegisterStringPref(kPublicAccountPendingDataRemoval, "",
                                   PrefService::UNSYNCABLE_PREF);
   local_state->RegisterDictionaryPref(kUserOAuthTokenStatus,
                                       PrefService::UNSYNCABLE_PREF);
   local_state->RegisterDictionaryPref(kUserDisplayName,
                                       PrefService::UNSYNCABLE_PREF);
   local_state->RegisterDictionaryPref(kUserDisplayEmail,
                                       PrefService::UNSYNCABLE_PREF);
+  SessionLengthLimiter::RegisterPrefs(local_state);
 }
 
 UserManagerImpl::UserManagerImpl()
     : cros_settings_(CrosSettings::Get()),
       users_loaded_(false),
       logged_in_user_(NULL),
       session_started_(false),
       is_current_user_owner_(false),
       is_current_user_new_(false),
       is_current_user_ephemeral_regular_user_(false),
@@ skipping 17 matching lines @@
       logged_in_user_ = NULL;
     delete *it;
   }
   delete logged_in_user_;
 }
 
 void UserManagerImpl::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   cros_settings_->RemoveSettingsObserver(kAccountsPrefDeviceLocalAccounts,
                                          this);
+  // Stop the session length limiter.
+  session_length_limiter_.reset();
 }
 
 UserImageManager* UserManagerImpl::GetUserImageManager() {
   return user_image_manager_.get();
 }
 
 const UserList& UserManagerImpl::GetUsers() const {
   const_cast<UserManagerImpl*>(this)->EnsureUsersLoaded();
   return users_;
 }
@@ skipping 15 matching lines @@
       PublicAccountUserLoggedIn(user);
     } else if (browser_restart && email == g_browser_process->local_state()->
                    GetString(kPublicAccountPendingDataRemoval)) {
       PublicAccountUserLoggedIn(User::CreatePublicAccountUser(email));
     } else if (email != owner_email_ && !user &&
                (AreEphemeralUsersEnabled() || browser_restart)) {
       RegularUserLoggedInAsEphemeral(email);
     } else {
       RegularUserLoggedIn(email, browser_restart);
     }
+
+    // Start the session length limiter.
+    session_length_limiter_.reset(new SessionLengthLimiter(NULL,
+                                                           browser_restart));
   }
 
   NotifyOnLogin();
 }
 
 void UserManagerImpl::RetailModeUserLoggedIn() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_current_user_new_ = true;
   logged_in_user_ = User::CreateRetailModeUser();
   user_image_manager_->UserLoggedIn(kRetailModeUserEMail, is_current_user_new_);
@@ skipping 333 matching lines @@
 bool UserManagerImpl::IsLoggedInAsStub() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() && logged_in_user_->email() == kStubUser;
 }
 
 bool UserManagerImpl::IsSessionStarted() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return session_started_;
 }
 
+bool UserManagerImpl::HasBrowserRestarted() const {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  return base::chromeos::IsRunningOnChromeOS() &&
+         command_line->HasSwitch(switches::kLoginUser) &&
+         !command_line->HasSwitch(switches::kLoginPassword);
+}
+
 bool UserManagerImpl::IsUserNonCryptohomeDataEphemeral(
     const std::string& email) const {
   // Data belonging to the guest, retail mode and stub users is always
   // ephemeral.
   if (email == kGuestUserEMail || email == kRetailModeUserEMail ||
       email == kStubUser) {
     return true;
   }
 
   // Data belonging to the owner, anyone found on the user list and obsolete
@@ skipping 12 matching lines @@
   if (IsUserLoggedIn() && (email == GetLoggedInUser()->email()) &&
       (is_current_user_ephemeral_regular_user_ || !IsLoggedInAsRegularUser())) {
     return true;
   }
 
   // Data belonging to any other user is ephemeral when:
   // a) Going through the regular login flow and the ephemeral users policy is
   //    enabled.
   //    - or -
   // b) The browser is restarting after a crash.
-  return AreEphemeralUsersEnabled() ||
-         (base::chromeos::IsRunningOnChromeOS() &&
-          !CommandLine::ForCurrentProcess()->
-              HasSwitch(switches::kLoginManager));
+  return AreEphemeralUsersEnabled() || HasBrowserRestarted();
 }
 
 void UserManagerImpl::AddObserver(UserManager::Observer* obs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observer_list_.AddObserver(obs);
 }
 
 void UserManagerImpl::RemoveObserver(UserManager::Observer* obs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observer_list_.RemoveObserver(obs);
@@ skipping 274 matching lines @@
       users_.insert(users_.begin(), User::CreatePublicAccountUser(*it));
   }
 
   user_image_manager_->LoadUserImages(
       UserList(users_.begin(), users_.begin() + new_public_accounts.size()));
 
   return true;
 }
 
 }  // namespace chromeos