[cros] Fake a stub user login when no --login-manager and --login-user are given.

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 <vector>
 
 #include "ash/shell.h"
 #include "ash/desktop_background/desktop_background_controller.h"
@@ skipping 50 matching lines @@
 typedef GoogleServiceAuthError AuthError;
 
 namespace chromeos {
 
 namespace {
 
 // Incognito user is represented by an empty string (since some code already
 // depends on that and it's hard to figure out what).
 const char kGuestUser[] = "";
 
-// Stub user email (for test paths).
-const char kStubUser[] = "stub-user@example.com";
-
 // Names of nodes with info about user image.
 const char kImagePathNodeName[] = "path";
 const char kImageIndexNodeName[] = "index";
 
 const char kWallpaperTypeNodeName[] = "type";
 const char kWallpaperIndexNodeName[] = "index";
 
 const int kThumbnailWidth = 128;
 const int kThumbnailHeight = 80;
 
-// Index of the default image used for the |kStubUser| user.
-const int kStubDefaultImageIndex = 0;
-
 // Delay betweeen user login and attempt to update user's profile image.
 const long kProfileImageDownloadDelayMs = 10000;
 
 // Enum for reporting histograms about profile picture download.
 enum ProfileDownloadResult {
   kDownloadSuccessChanged,
   kDownloadSuccess,
   kDownloadFailure,
   kDownloadDefault,
 
@@ skipping 99 matching lines @@
       is_current_user_owner_(false),
       is_current_user_new_(false),
       is_current_user_ephemeral_(false),
       current_user_wallpaper_type_(User::UNKNOWN),
       ALLOW_THIS_IN_INITIALIZER_LIST(current_user_wallpaper_index_(
           ash::GetInvalidWallpaperIndex())),
       ephemeral_users_enabled_(false),
       observed_sync_service_(NULL),
       last_image_set_async_(false),
       downloaded_profile_image_data_url_(chrome::kAboutBlankURL) {
-  // If we're not running on ChromeOS, and are not showing the login manager
-  // or attempting a command line login? Then login the stub user.
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (!base::chromeos::IsRunningOnChromeOS() &&
-      !command_line->HasSwitch(switches::kLoginManager) &&
-      !command_line->HasSwitch(switches::kLoginPassword) &&
-      !command_line->HasSwitch(switches::kGuestSession)) {
-    StubUserLoggedIn();
-  }
-
   MigrateWallpaperData();
-
   registrar_.Add(this, chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
       content::NotificationService::AllSources());
   RetrieveTrustedDevicePolicies();
 }
 
 UserManagerImpl::~UserManagerImpl() {
   // Can't use STLDeleteElements because of the private destructor of User.
   for (size_t i = 0; i < users_.size();++i)
     delete users_[i];
   users_.clear();
   if (is_current_user_ephemeral_)
     delete logged_in_user_;
 }
 
 const UserList& UserManagerImpl::GetUsers() const {
   const_cast<UserManagerImpl*>(this)->EnsureUsersLoaded();
   return users_;
 }
 
 void UserManagerImpl::UserLoggedIn(const std::string& email,
                                    bool browser_restart) {
-  // Remove the stub user if it is still around.
-  if (logged_in_user_) {
-    DCHECK(IsLoggedInAsStub());
-    delete logged_in_user_;
-    logged_in_user_ = NULL;
-    is_current_user_ephemeral_ = false;
-  }
-
   if (email == kGuestUser) {
     GuestUserLoggedIn();
     return;
   }
 
   if (email == kDemoUser) {
     DemoUserLoggedIn();
     return;
   }
 
@@ skipping 92 matching lines @@
 
 void UserManagerImpl::EphemeralUserLoggedIn(const std::string& email) {
   is_current_user_new_ = true;
   is_current_user_ephemeral_ = true;
   logged_in_user_ = CreateUser(email);
   SetInitialUserImage(email);
   SetInitialUserWallpaper(email);
   NotifyOnLogin();
 }
 
-void UserManagerImpl::StubUserLoggedIn() {
-  is_current_user_ephemeral_ = true;
-  logged_in_user_ = new User(kStubUser, false);
-  logged_in_user_->SetImage(UserImage(GetDefaultImage(kStubDefaultImageIndex)),
-                            kStubDefaultImageIndex);
-}
-
 void UserManagerImpl::InitializeWallpaper() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!IsUserLoggedIn()) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableNewOobe)) {
       bool show_users = true;
       bool result = CrosSettings::Get()->GetBoolean(
           kAccountsPrefShowUserNamesOnSignIn, &show_users);
       DCHECK(result) << "Unable to fetch setting "
                      << kAccountsPrefShowUserNamesOnSignIn;
       if (!show_users) {
         ash::Shell::GetInstance()->desktop_background_controller()->
             SetDefaultWallpaper(ash::GetSolidColorIndex());
       }
     }
     return;
-  } else if (IsLoggedInAsStub()) {
-    ash::Shell::GetInstance()->desktop_background_controller()->
-        SetDefaultWallpaper(ash::GetInvalidWallpaperIndex());
-    return;
   }
   UserSelected(GetLoggedInUser().email());
 }
 
 void UserManagerImpl::UserSelected(const std::string& email) {
   if (IsKnownUser(email)) {
     User::WallpaperType type;
     int index;
     GetUserWallpaperProperties(email, &type, &index);
     if (type == User::RANDOM) {
@@ skipping 259 matching lines @@
   switch (type) {
     case chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED:
       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                               base::Bind(&UserManagerImpl::CheckOwnership,
                                          base::Unretained(this)));
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           base::Bind(&UserManagerImpl::RetrieveTrustedDevicePolicies,
           base::Unretained(this)));
       break;
     case chrome::NOTIFICATION_PROFILE_ADDED:
-      if (IsUserLoggedIn() && !IsLoggedInAsGuest() && !IsLoggedInAsStub()) {
+      if (IsUserLoggedIn() && !IsLoggedInAsGuest()) {
         Profile* profile = content::Source<Profile>(source).ptr();
         if (!profile->IsOffTheRecord() &&
             profile == ProfileManager::GetDefaultProfile()) {
           DCHECK(NULL == observed_sync_service_);
           observed_sync_service_ =
               ProfileSyncServiceFactory::GetForProfile(profile);
           if (observed_sync_service_)
             observed_sync_service_->AddObserver(this);
         }
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 void UserManagerImpl::OnStateChanged() {
-  DCHECK(IsUserLoggedIn() && !IsLoggedInAsGuest() && !IsLoggedInAsStub());
+  DCHECK(IsUserLoggedIn() && !IsLoggedInAsGuest());
   AuthError::State state = observed_sync_service_->GetAuthError().state();
   if (state != AuthError::NONE &&
       state != AuthError::CONNECTION_FAILED &&
       state != AuthError::SERVICE_UNAVAILABLE &&
       state != AuthError::REQUEST_CANCELED) {
       // Invalidate OAuth token to force Gaia sign-in flow. This is needed
       // because sign-out/sign-in solution is suggested to the user.
       // TODO(altimofeev): this code isn't needed after crosbug.com/25978 is
       // implemented.
       DVLOG(1) << "Invalidate OAuth token because of a sync error.";
@@ skipping 222 matching lines @@
   }
 }
 
 bool UserManagerImpl::AreEphemeralUsersEnabled() const {
   return ephemeral_users_enabled_ &&
       (g_browser_process->browser_policy_connector()->IsEnterpriseManaged() ||
       !owner_email_.empty());
 }
 
 bool UserManagerImpl::IsEphemeralUser(const std::string& email) const {
-  // The guest user always is ephemeral.
-  if (email == kGuestUser)
+  // The guest and stub user always are ephemeral.
+  if (email == kGuestUser || email == kStubUser)
     return true;
 
   // The currently logged-in user is ephemeral iff logged in as ephemeral.
   if (logged_in_user_ && (email == logged_in_user_->email()))
     return is_current_user_ephemeral_;
 
   // The owner and any users found in the persistent list are never ephemeral.
   if (email == owner_email_  || FindUserInList(email))
     return false;
 
@@ skipping 97 matching lines @@
       }
     }
   }
 }
 
 void UserManagerImpl::GetLoggedInUserWallpaperProperties(
     User::WallpaperType* type,
     int* index) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(logged_in_user_);
-
-  if (IsLoggedInAsStub()) {
-    *type = current_user_wallpaper_type_ = User::DEFAULT;
-    *index = current_user_wallpaper_index_ = ash::GetInvalidWallpaperIndex();
-    return;
-  }
-
   GetUserWallpaperProperties(GetLoggedInUser().email(), type, index);
 }
 
 void UserManagerImpl::SaveLoggedInUserWallpaperProperties(
     User::WallpaperType type,
     int index) {
   SaveUserWallpaperProperties(GetLoggedInUser().email(), type, index);
 }
 
 void UserManagerImpl::SetUserImage(const std::string& username,
@@ skipping 493 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos