src/chrome/browser/chromeos/login/users/user.cc

   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/users/user.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/threading/thread_restrictions.h"
  11 #include "chrome/browser/chromeos/login/helper.h"
  12 #include "chrome/browser/chromeos/login/users/avatar/default_user_images.h"
  13 #include "chrome/browser/chromeos/login/users/user_manager.h"
  14 #include "google_apis/gaia/gaia_auth_util.h"
  15 #include "grit/theme_resources.h"
  16 #include "ui/base/resource/resource_bundle.h"
  17
  18 namespace chromeos {
  19
  20 namespace {
  21
  22 // Returns account name portion of an email.
  23 std::string GetUserName(const std::string& email) {
  24   std::string::size_type i = email.find('@');
  25   if (i == 0 || i == std::string::npos) {
  26     return email;
  27   }
  28   return email.substr(0, i);
  29 }
  30
  31 }  // namespace
  32
  33 const int User::kExternalImageIndex;
  34 const int User::kProfileImageIndex;
  35 const int User::kInvalidImageIndex;
  36
  37 class RegularUser : public User {
  38  public:
  39   explicit RegularUser(const std::string& email);
  40   virtual ~RegularUser();
  41
  42   // Overridden from User:
  43   virtual UserType GetType() const OVERRIDE;
  44   virtual bool CanSyncImage() const OVERRIDE;
  45
  46  private:
  47   DISALLOW_COPY_AND_ASSIGN(RegularUser);
  48 };
  49
  50 class GuestUser : public User {
  51  public:
  52   GuestUser();
  53   virtual ~GuestUser();
  54
  55   // Overridden from User:
  56   virtual UserType GetType() const OVERRIDE;
  57
  58  private:
  59   DISALLOW_COPY_AND_ASSIGN(GuestUser);
  60 };
  61
  62 class KioskAppUser : public User {
  63  public:
  64   explicit KioskAppUser(const std::string& app_id);
  65   virtual ~KioskAppUser();
  66
  67   // Overridden from User:
  68   virtual UserType GetType() const OVERRIDE;
  69
  70  private:
  71   DISALLOW_COPY_AND_ASSIGN(KioskAppUser);
  72 };
  73
  74 class LocallyManagedUser : public User {
  75  public:
  76   explicit LocallyManagedUser(const std::string& username);
  77   virtual ~LocallyManagedUser();
  78
  79   // Overridden from User:
  80   virtual UserType GetType() const OVERRIDE;
  81   virtual std::string display_email() const OVERRIDE;
  82
  83  private:
  84   DISALLOW_COPY_AND_ASSIGN(LocallyManagedUser);
  85 };
  86
  87 class RetailModeUser : public User {
  88  public:
  89   RetailModeUser();
  90   virtual ~RetailModeUser();
  91
  92   // Overridden from User:
  93   virtual UserType GetType() const OVERRIDE;
  94
  95  private:
  96   DISALLOW_COPY_AND_ASSIGN(RetailModeUser);
  97 };
  98
  99 class PublicAccountUser : public User {
 100  public:
 101   explicit PublicAccountUser(const std::string& email);
 102   virtual ~PublicAccountUser();
 103
 104   // Overridden from User:
 105   virtual UserType GetType() const OVERRIDE;
 106
 107  private:
 108   DISALLOW_COPY_AND_ASSIGN(PublicAccountUser);
 109 };
 110
 111 std::string User::GetEmail() const {
 112   return display_email();
 113 }
 114
 115 base::string16 User::GetDisplayName() const {
 116   // Fallback to the email account name in case display name haven't been set.
 117   return display_name_.empty() ?
 118       base::UTF8ToUTF16(GetAccountName(true)) :
 119       display_name_;
 120 }
 121
 122 base::string16 User::GetGivenName() const {
 123   return given_name_;
 124 }
 125
 126 const gfx::ImageSkia& User::GetImage() const {
 127   return user_image_.image();
 128 }
 129
 130 std::string User::GetUserID() const {
 131   return gaia::CanonicalizeEmail(gaia::SanitizeEmail(email()));
 132 }
 133
 134 std::string User::GetAccountName(bool use_display_email) const {
 135   if (use_display_email && !display_email_.empty())
 136     return GetUserName(display_email_);
 137   else
 138     return GetUserName(email_);
 139 }
 140
 141 bool User::HasDefaultImage() const {
 142   return image_index_ >= 0 && image_index_ < kDefaultImagesCount;
 143 }
 144
 145 bool User::CanSyncImage() const {
 146   return false;
 147 }
 148
 149 std::string User::display_email() const {
 150   return display_email_;
 151 }
 152
 153 bool User::can_lock() const {
 154   return can_lock_;
 155 }
 156
 157 std::string User::username_hash() const {
 158   return username_hash_;
 159 }
 160
 161 bool User::is_logged_in() const {
 162   return is_logged_in_;
 163 }
 164
 165 bool User::is_active() const {
 166   return is_active_;
 167 }
 168
 169 User* User::CreateRegularUser(const std::string& email) {
 170   return new RegularUser(email);
 171 }
 172
 173 User* User::CreateGuestUser() {
 174   return new GuestUser;
 175 }
 176
 177 User* User::CreateKioskAppUser(const std::string& kiosk_app_username) {
 178   return new KioskAppUser(kiosk_app_username);
 179 }
 180
 181 User* User::CreateLocallyManagedUser(const std::string& username) {
 182   return new LocallyManagedUser(username);
 183 }
 184
 185 User* User::CreateRetailModeUser() {
 186   return new RetailModeUser;
 187 }
 188
 189 User* User::CreatePublicAccountUser(const std::string& email) {
 190   return new PublicAccountUser(email);
 191 }
 192
 193 User::User(const std::string& email)
 194     : email_(email),
 195       oauth_token_status_(OAUTH_TOKEN_STATUS_UNKNOWN),
 196       force_online_signin_(false),
 197       image_index_(kInvalidImageIndex),
 198       image_is_stub_(false),
 199       image_is_loading_(false),
 200       can_lock_(false),
 201       is_logged_in_(false),
 202       is_active_(false),
 203       profile_is_created_(false) {
 204 }
 205
 206 User::~User() {}
 207
 208 void User::SetAccountLocale(const std::string& resolved_account_locale) {
 209   account_locale_.reset(new std::string(resolved_account_locale));
 210 }
 211
 212 void User::SetImage(const UserImage& user_image, int image_index) {
 213   user_image_ = user_image;
 214   image_index_ = image_index;
 215   image_is_stub_ = false;
 216   image_is_loading_ = false;
 217   DCHECK(HasDefaultImage() || user_image.has_raw_image());
 218 }
 219
 220 void User::SetImageURL(const GURL& image_url) {
 221   user_image_.set_url(image_url);
 222 }
 223
 224 void User::SetStubImage(int image_index, bool is_loading) {
 225   user_image_ = UserImage(
 226       *ResourceBundle::GetSharedInstance().
 227           GetImageSkiaNamed(IDR_PROFILE_PICTURE_LOADING));
 228   image_index_ = image_index;
 229   image_is_stub_ = true;
 230   image_is_loading_ = is_loading;
 231 }
 232
 233 RegularUser::RegularUser(const std::string& email) : User(email) {
 234   set_can_lock(true);
 235   set_display_email(email);
 236 }
 237
 238 RegularUser::~RegularUser() {}
 239
 240 User::UserType RegularUser::GetType() const {
 241   return USER_TYPE_REGULAR;
 242 }
 243
 244 bool RegularUser::CanSyncImage() const {
 245   return true;
 246 }
 247
 248 GuestUser::GuestUser() : User(UserManager::kGuestUserName) {
 249   set_display_email(std::string());
 250 }
 251
 252 GuestUser::~GuestUser() {}
 253
 254 User::UserType GuestUser::GetType() const {
 255   return USER_TYPE_GUEST;
 256 }
 257
 258 KioskAppUser::KioskAppUser(const std::string& kiosk_app_username)
 259     : User(kiosk_app_username) {
 260   set_display_email(kiosk_app_username);
 261 }
 262
 263 KioskAppUser::~KioskAppUser() {}
 264
 265 User::UserType KioskAppUser::GetType() const {
 266   return USER_TYPE_KIOSK_APP;
 267 }
 268
 269 LocallyManagedUser::LocallyManagedUser(const std::string& username)
 270     : User(username) {
 271   set_can_lock(true);
 272 }
 273
 274 LocallyManagedUser::~LocallyManagedUser() {}
 275
 276 User::UserType LocallyManagedUser::GetType() const {
 277   return USER_TYPE_LOCALLY_MANAGED;
 278 }
 279
 280 std::string LocallyManagedUser::display_email() const {
 281   return base::UTF16ToUTF8(display_name());
 282 }
 283
 284 RetailModeUser::RetailModeUser() : User(UserManager::kRetailModeUserName) {
 285   set_display_email(std::string());
 286 }
 287
 288 RetailModeUser::~RetailModeUser() {}
 289
 290 User::UserType RetailModeUser::GetType() const {
 291   return USER_TYPE_RETAIL_MODE;
 292 }
 293
 294 PublicAccountUser::PublicAccountUser(const std::string& email) : User(email) {
 295 }
 296
 297 PublicAccountUser::~PublicAccountUser() {}
 298
 299 User::UserType PublicAccountUser::GetType() const {
 300   return USER_TYPE_PUBLIC_ACCOUNT;
 301 }
 302
 303 bool User::has_gaia_account() const {
 304   COMPILE_ASSERT(NUM_USER_TYPES == 6, num_user_types_unexpected);
 305   switch (GetType()) {
 306     case USER_TYPE_REGULAR:
 307       return true;
 308     case USER_TYPE_GUEST:
 309     case USER_TYPE_RETAIL_MODE:
 310     case USER_TYPE_PUBLIC_ACCOUNT:
 311     case USER_TYPE_LOCALLY_MANAGED:
 312     case USER_TYPE_KIOSK_APP:
 313       return false;
 314     default:
 315       NOTREACHED();
 316   }
 317   return false;
 318 }
 319
 320 }  // namespace chromeos