New user type introduced. Combines regular and supervised features.

components/user_manager/user.cc

 // Copyright 2014 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 "components/user_manager/user.h"
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 10 matching lines @@
 std::string GetUserName(const std::string& email) {
   std::string::size_type i = email.find('@');
   if (i == 0 || i == std::string::npos) {
     return email;
   }
   return email.substr(0, i);
 }
 
 }  // namespace
 
-bool User::IsSupervised() const {
-  return false;
+// static
+bool User::TypeHasGaia(UserType user_type) {

[Nikita (slow), 2014/11/14 09:34:52]

nit: TypeHasGaiaAccount

[merkulova, 2014/11/14 10:09:49]

Done.

+  return user_type == USER_TYPE_REGULAR ||
+         user_type == USER_TYPE_REGULAR_SUPERVISED;
 }
 
-void User::SetIsSupervised(bool is_supervised) {
-  VLOG(1) << "Ignoring SetIsSupervised call with param " << is_supervised;
-}
-
+// Also used for regular supervised users.
 class RegularUser : public User {
  public:
   explicit RegularUser(const std::string& email);
   virtual ~RegularUser();
 
   // Overridden from User:
   virtual UserType GetType() const override;
   virtual bool CanSyncImage() const override;
-  virtual void SetIsSupervised(bool is_supervised) override {
-    VLOG(1) << "Setting user is supervised to " << is_supervised;
-    is_supervised_ = is_supervised;
-  }
-  virtual bool IsSupervised() const override {
-    return is_supervised_;
-  }
+  virtual void SetIsSupervised(bool is_supervised) override;
 
  private:
   bool is_supervised_;
 
   DISALLOW_COPY_AND_ASSIGN(RegularUser);
 };
 
 class GuestUser : public User {
  public:
   GuestUser();
@@ skipping 18 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(KioskAppUser);
 };
 
 class SupervisedUser : public User {
  public:
   explicit SupervisedUser(const std::string& username);
   virtual ~SupervisedUser();
 
   // Overridden from User:
   virtual UserType GetType() const override;
-  virtual bool IsSupervised() const override;
   virtual std::string display_email() const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SupervisedUser);
 };
 
 class RetailModeUser : public User {
  public:
   RetailModeUser();
   virtual ~RetailModeUser();
@@ skipping 32 matching lines @@
 }
 
 const gfx::ImageSkia& User::GetImage() const {
   return user_image_.image();
 }
 
 std::string User::GetUserID() const {
   return gaia::CanonicalizeEmail(gaia::SanitizeEmail(email()));
 }
 
+void User::SetIsSupervised(bool is_supervised) {
+  VLOG(1) << "Ignoring SetIsSupervised call with param " << is_supervised;
+  NOTREACHED() << "Calling SetIsSupervised for base User class.";
+}
+
+bool User::HasGaiaAccount() const {
+  return TypeHasGaia(GetType());
+}
+
+bool User::IsSupervised() const {
+  UserType type = GetType();
+  return  type == USER_TYPE_SUPERVISED ||
+          type == USER_TYPE_REGULAR_SUPERVISED;
+}
+
 std::string User::GetAccountName(bool use_display_email) const {
   if (use_display_email && !display_email_.empty())
     return GetUserName(display_email_);
   else
     return GetUserName(email_);
 }
 
 bool User::HasDefaultImage() const {
   return image_index_ >= 0 && image_index_ < kDefaultImagesCount;
 }
@@ skipping 90 matching lines @@
 RegularUser::RegularUser(const std::string& email)
     : User(email), is_supervised_(false) {
   set_can_lock(true);
   set_display_email(email);
 }
 
 RegularUser::~RegularUser() {
 }
 
 UserType RegularUser::GetType() const {
-  return user_manager::USER_TYPE_REGULAR;
+  return is_supervised_ ? user_manager::USER_TYPE_REGULAR_SUPERVISED :
+                          user_manager::USER_TYPE_REGULAR;
 }
 
 bool RegularUser::CanSyncImage() const {
   return true;
 }
 
+void RegularUser::SetIsSupervised(bool is_supervised) {
+  VLOG(1) << "Setting user is supervised to " << is_supervised;
+  is_supervised_ = is_supervised;
+}
+
 GuestUser::GuestUser() : User(chromeos::login::kGuestUserName) {
   set_display_email(std::string());
 }
 
 GuestUser::~GuestUser() {
 }
 
 UserType GuestUser::GetType() const {
   return user_manager::USER_TYPE_GUEST;
 }
@@ skipping 18 matching lines @@
 }
 
 UserType SupervisedUser::GetType() const {
   return user_manager::USER_TYPE_SUPERVISED;
 }
 
 std::string SupervisedUser::display_email() const {
   return base::UTF16ToUTF8(display_name());
 }
 
-bool SupervisedUser::IsSupervised() const {
-  return true;
-}
-
 RetailModeUser::RetailModeUser() : User(chromeos::login::kRetailModeUserName) {
   set_display_email(std::string());
 }
 
 RetailModeUser::~RetailModeUser() {
 }
 
 UserType RetailModeUser::GetType() const {
   return user_manager::USER_TYPE_RETAIL_MODE;
 }
 
 PublicAccountUser::PublicAccountUser(const std::string& email) : User(email) {
 }
 
 PublicAccountUser::~PublicAccountUser() {
 }
 
 UserType PublicAccountUser::GetType() const {
   return user_manager::USER_TYPE_PUBLIC_ACCOUNT;
 }
 
 bool User::has_gaia_account() const {
-  COMPILE_ASSERT(user_manager::NUM_USER_TYPES == 6, num_user_types_unexpected);
+  COMPILE_ASSERT(user_manager::NUM_USER_TYPES == 7, num_user_types_unexpected);
   switch (GetType()) {
     case user_manager::USER_TYPE_REGULAR:
+    case user_manager::USER_TYPE_REGULAR_SUPERVISED:
       return true;
     case user_manager::USER_TYPE_GUEST:
     case user_manager::USER_TYPE_RETAIL_MODE:
     case user_manager::USER_TYPE_PUBLIC_ACCOUNT:
     case user_manager::USER_TYPE_SUPERVISED:
     case user_manager::USER_TYPE_KIOSK_APP:
       return false;
     default:
       NOTREACHED();
   }
   return false;
 }
 
 }  // namespace user_manager