components/user_manager/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 "components/user_manager/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 "chromeos/login/user_names.h"
  12 #include "components/user_manager/user_image/default_user_images.h"
  13 #include "google_apis/gaia/gaia_auth_util.h"
  14 #include "ui/base/resource/resource_bundle.h"
  15
  16 namespace user_manager {
  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 // static
  32 bool User::TypeHasGaiaAccount(UserType user_type) {
  33   return user_type == USER_TYPE_REGULAR ||
  34          user_type == USER_TYPE_REGULAR_SUPERVISED;
  35 }
  36
  37 // Also used for regular supervised users.
  38 class RegularUser : public User {
  39  public:
  40   explicit RegularUser(const std::string& email);
  41   virtual ~RegularUser();
  42
  43   // Overridden from User:
  44   virtual UserType GetType() const override;
  45   virtual bool CanSyncImage() const override;
  46   virtual void SetIsSupervised(bool is_supervised) override;
  47
  48  private:
  49   bool is_supervised_;
  50
  51   DISALLOW_COPY_AND_ASSIGN(RegularUser);
  52 };
  53
  54 class GuestUser : public User {
  55  public:
  56   GuestUser();
  57   virtual ~GuestUser();
  58
  59   // Overridden from User:
  60   virtual UserType GetType() const override;
  61
  62  private:
  63   DISALLOW_COPY_AND_ASSIGN(GuestUser);
  64 };
  65
  66 class KioskAppUser : public User {
  67  public:
  68   explicit KioskAppUser(const std::string& app_id);
  69   virtual ~KioskAppUser();
  70
  71   // Overridden from User:
  72   virtual UserType GetType() const override;
  73
  74  private:
  75   DISALLOW_COPY_AND_ASSIGN(KioskAppUser);
  76 };
  77
  78 class SupervisedUser : public User {
  79  public:
  80   explicit SupervisedUser(const std::string& username);
  81   virtual ~SupervisedUser();
  82
  83   // Overridden from User:
  84   virtual UserType GetType() const override;
  85   virtual std::string display_email() const override;
  86
  87  private:
  88   DISALLOW_COPY_AND_ASSIGN(SupervisedUser);
  89 };
  90
  91 class RetailModeUser : public User {
  92  public:
  93   RetailModeUser();
  94   virtual ~RetailModeUser();
  95
  96   // Overridden from User:
  97   virtual UserType GetType() const override;
  98
  99  private:
 100   DISALLOW_COPY_AND_ASSIGN(RetailModeUser);
 101 };
 102
 103 class PublicAccountUser : public User {
 104  public:
 105   explicit PublicAccountUser(const std::string& email);
 106   virtual ~PublicAccountUser();
 107
 108   // Overridden from User:
 109   virtual UserType GetType() const override;
 110
 111  private:
 112   DISALLOW_COPY_AND_ASSIGN(PublicAccountUser);
 113 };
 114
 115 std::string User::GetEmail() const {
 116   return display_email();
 117 }
 118
 119 base::string16 User::GetDisplayName() const {
 120   // Fallback to the email account name in case display name haven't been set.
 121   return display_name_.empty() ? base::UTF8ToUTF16(GetAccountName(true))
 122                                : display_name_;
 123 }
 124
 125 base::string16 User::GetGivenName() const {
 126   return given_name_;
 127 }
 128
 129 const gfx::ImageSkia& User::GetImage() const {
 130   return user_image_.image();
 131 }
 132
 133 std::string User::GetUserID() const {
 134   return gaia::CanonicalizeEmail(gaia::SanitizeEmail(email()));
 135 }
 136
 137 void User::SetIsSupervised(bool is_supervised) {
 138   VLOG(1) << "Ignoring SetIsSupervised call with param " << is_supervised;
 139   NOTREACHED() << "Calling SetIsSupervised for base User class.";
 140 }
 141
 142 bool User::HasGaiaAccount() const {
 143   return TypeHasGaiaAccount(GetType());
 144 }
 145
 146 bool User::IsSupervised() const {
 147   UserType type = GetType();
 148   return  type == USER_TYPE_SUPERVISED ||
 149           type == USER_TYPE_REGULAR_SUPERVISED;
 150 }
 151
 152 std::string User::GetAccountName(bool use_display_email) const {
 153   if (use_display_email && !display_email_.empty())
 154     return GetUserName(display_email_);
 155   else
 156     return GetUserName(email_);
 157 }
 158
 159 bool User::HasDefaultImage() const {
 160   return image_index_ >= 0 && image_index_ < kDefaultImagesCount;
 161 }
 162
 163 bool User::CanSyncImage() const {
 164   return false;
 165 }
 166
 167 std::string User::display_email() const {
 168   return display_email_;
 169 }
 170
 171 bool User::can_lock() const {
 172   return can_lock_;
 173 }
 174
 175 std::string User::username_hash() const {
 176   return username_hash_;
 177 }
 178
 179 bool User::is_logged_in() const {
 180   return is_logged_in_;
 181 }
 182
 183 bool User::is_active() const {
 184   return is_active_;
 185 }
 186
 187 User* User::CreateRegularUser(const std::string& email) {
 188   return new RegularUser(email);
 189 }
 190
 191 User* User::CreateGuestUser() {
 192   return new GuestUser;
 193 }
 194
 195 User* User::CreateKioskAppUser(const std::string& kiosk_app_username) {
 196   return new KioskAppUser(kiosk_app_username);
 197 }
 198
 199 User* User::CreateSupervisedUser(const std::string& username) {
 200   return new SupervisedUser(username);
 201 }
 202
 203 User* User::CreateRetailModeUser() {
 204   return new RetailModeUser;
 205 }
 206
 207 User* User::CreatePublicAccountUser(const std::string& email) {
 208   return new PublicAccountUser(email);
 209 }
 210
 211 User::User(const std::string& email)
 212     : email_(email),
 213       oauth_token_status_(OAUTH_TOKEN_STATUS_UNKNOWN),
 214       force_online_signin_(false),
 215       image_index_(USER_IMAGE_INVALID),
 216       image_is_stub_(false),
 217       image_is_loading_(false),
 218       can_lock_(false),
 219       is_logged_in_(false),
 220       is_active_(false),
 221       profile_is_created_(false) {
 222 }
 223
 224 User::~User() {
 225 }
 226
 227 void User::SetAccountLocale(const std::string& resolved_account_locale) {
 228   account_locale_.reset(new std::string(resolved_account_locale));
 229 }
 230
 231 void User::SetImage(const UserImage& user_image, int image_index) {
 232   user_image_ = user_image;
 233   image_index_ = image_index;
 234   image_is_stub_ = false;
 235   image_is_loading_ = false;
 236   DCHECK(HasDefaultImage() || user_image.has_raw_image());
 237 }
 238
 239 void User::SetImageURL(const GURL& image_url) {
 240   user_image_.set_url(image_url);
 241 }
 242
 243 void User::SetStubImage(const UserImage& stub_user_image,
 244                         int image_index,
 245                         bool is_loading) {
 246   user_image_ = stub_user_image;
 247   image_index_ = image_index;
 248   image_is_stub_ = true;
 249   image_is_loading_ = is_loading;
 250 }
 251
 252 RegularUser::RegularUser(const std::string& email)
 253     : User(email), is_supervised_(false) {
 254   set_can_lock(true);
 255   set_display_email(email);
 256 }
 257
 258 RegularUser::~RegularUser() {
 259 }
 260
 261 UserType RegularUser::GetType() const {
 262   return is_supervised_ ? user_manager::USER_TYPE_REGULAR_SUPERVISED :
 263                           user_manager::USER_TYPE_REGULAR;
 264 }
 265
 266 bool RegularUser::CanSyncImage() const {
 267   return true;
 268 }
 269
 270 void RegularUser::SetIsSupervised(bool is_supervised) {
 271   VLOG(1) << "Setting user is supervised to " << is_supervised;
 272   is_supervised_ = is_supervised;
 273 }
 274
 275 GuestUser::GuestUser() : User(chromeos::login::kGuestUserName) {
 276   set_display_email(std::string());
 277 }
 278
 279 GuestUser::~GuestUser() {
 280 }
 281
 282 UserType GuestUser::GetType() const {
 283   return user_manager::USER_TYPE_GUEST;
 284 }
 285
 286 KioskAppUser::KioskAppUser(const std::string& kiosk_app_username)
 287     : User(kiosk_app_username) {
 288   set_display_email(kiosk_app_username);
 289 }
 290
 291 KioskAppUser::~KioskAppUser() {
 292 }
 293
 294 UserType KioskAppUser::GetType() const {
 295   return user_manager::USER_TYPE_KIOSK_APP;
 296 }
 297
 298 SupervisedUser::SupervisedUser(const std::string& username) : User(username) {
 299   set_can_lock(true);
 300 }
 301
 302 SupervisedUser::~SupervisedUser() {
 303 }
 304
 305 UserType SupervisedUser::GetType() const {
 306   return user_manager::USER_TYPE_SUPERVISED;
 307 }
 308
 309 std::string SupervisedUser::display_email() const {
 310   return base::UTF16ToUTF8(display_name());
 311 }
 312
 313 RetailModeUser::RetailModeUser() : User(chromeos::login::kRetailModeUserName) {
 314   set_display_email(std::string());
 315 }
 316
 317 RetailModeUser::~RetailModeUser() {
 318 }
 319
 320 UserType RetailModeUser::GetType() const {
 321   return user_manager::USER_TYPE_RETAIL_MODE;
 322 }
 323
 324 PublicAccountUser::PublicAccountUser(const std::string& email) : User(email) {
 325 }
 326
 327 PublicAccountUser::~PublicAccountUser() {
 328 }
 329
 330 UserType PublicAccountUser::GetType() const {
 331   return user_manager::USER_TYPE_PUBLIC_ACCOUNT;
 332 }
 333
 334 bool User::has_gaia_account() const {
 335   COMPILE_ASSERT(user_manager::NUM_USER_TYPES == 7, num_user_types_unexpected);
 336   switch (GetType()) {
 337     case user_manager::USER_TYPE_REGULAR:
 338     case user_manager::USER_TYPE_REGULAR_SUPERVISED:
 339       return true;
 340     case user_manager::USER_TYPE_GUEST:
 341     case user_manager::USER_TYPE_RETAIL_MODE:
 342     case user_manager::USER_TYPE_PUBLIC_ACCOUNT:
 343     case user_manager::USER_TYPE_SUPERVISED:
 344     case user_manager::USER_TYPE_KIOSK_APP:
 345       return false;
 346     default:
 347       NOTREACHED();
 348   }
 349   return false;
 350 }
 351
 352 }  // namespace user_manager