chrome/browser/chromeos/login/user.cc

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