Add account_type into AccountId

components/signin/core/account_id/account_id.h

 // Copyright 2015 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.
 
 #ifndef COMPONENTS_SIGNIN_CORE_ACCOUNT_ID_ACCOUNT_ID_H_
 #define COMPONENTS_SIGNIN_CORE_ACCOUNT_ID_ACCOUNT_ID_H_
 
 #include <stddef.h>
 
 #include <string>
 #include "base/containers/hash_tables.h"
 
+enum class AccountType { UNKNOWN, GOOGLE, ACTIVE_DIRECTORY };
+
 // Type that contains enough information to identify user.
 //
 // TODO(alemate): we are in the process of moving away from std::string as a
 // type for storing user identifier to AccountId. At this time GaiaId is mostly
 // empty, so this type is used as a replacement for e-mail string.
 // But in near future AccountId will become full feature user identifier.
 class AccountId {
  public:
   struct EmptyAccountId;
 
   AccountId(const AccountId& other);
 
   bool operator==(const AccountId& other) const;
   bool operator!=(const AccountId& other) const;
   bool operator<(const AccountId& right) const;
 
   // empty() is deprecated. Use !is_valid() instead.
   bool empty() const;
   bool is_valid() const;
   void clear();
 
-  const std::string& GetAccountType() const;
+  const AccountType& GetAccountType() const;

[Roger Tawa OOO till Jul 10th, 2016/12/05 16:34:31]

Is there reason to keep this as a const &?  I would suggest removing the
reference from here and all methods below.

[Alexander Alekseev, 2016/12/06 02:21:14]

The reason was "it's better to return a reference to string".
If we switch from const & to copy here (which is probably better for enum), it
will later be more difficult to switch back to string if we ever need. (I
believe you had ideas why we could need string here).

But as we do not see this transition in any foreseeable future, let's remove '&'
here and switch to copy enum.

[Roger Tawa OOO till Jul 10th, 2016/12/07 22:09:37]

My 2 cents: given C++11 move semantics and return value optimizations and copy
elision and rvalue references, I don't think returning a reference is
necessarily better even for strings.

[Roman Sorokin (ftl), 2016/12/13 13:45:59]

Done.

[Roman Sorokin (ftl), 2016/12/13 13:45:59]

Done.

   const std::string& GetGaiaId() const;
   // Users of AccountId should make no assumptions on the format of email.
   // I.e. it cannot be used as account identifier, because it is (in general)
   // non-comparable.
   const std::string& GetUserEmail() const;
 
   // This returns prefixed some string that can be used as a storage key.
   // You should make no assumptions on the format of this string.
   const std::string GetAccountIdKey() const;
 
   void SetGaiaId(const std::string& gaia_id);
   void SetUserEmail(const std::string& email);
+  void SetAccountType(const AccountType& account_type);
 
   // This method is to be used during transition period only.
   static AccountId FromUserEmail(const std::string& user_email);
   // This method is to be used during transition period only.
   static AccountId FromGaiaId(const std::string& gaia_id);
   // This method is the preferred way to construct AccountId if you have
   // full account information.
   static AccountId FromUserEmailGaiaId(const std::string& user_email,
                                        const std::string& gaia_id);
+  // This method is used to construct AccountId with specific types.
+  static AccountId FromUserEmailGaiaIdAccountType(
+      const std::string& email,
+      const std::string& gaia_id,
+      const AccountType& account_type);
+  static AccountId FromGaiaIdAccountType(const std::string& gaia_id,
+                                         const AccountType& account_type);
+
+  // Translation functions between AccountType and std::string. Used for
+  // serialization.
+  static AccountType StringToAccountType(
+      const std::string& account_type_string);
+  static std::string AccountTypeToString(const AccountType& account_type);
 
   // These are (for now) unstable and cannot be used to store serialized data to
   // persistent storage. Only in-memory storage is safe.
   // Serialize() returns JSON dictionary,
   // Deserialize() restores AccountId after serialization.
   std::string Serialize() const;
   static bool Deserialize(const std::string& serialized,
                           AccountId* out_account_id);
 
  private:
   AccountId();
   AccountId(const std::string& gaia_id, const std::string& user_email);
+  AccountId(const std::string& gaia_id,
+            const std::string& user_email,
+            const AccountType& account_type);
 
   std::string gaia_id_;
   std::string user_email_;
+  AccountType account_type_ = AccountType::GOOGLE;
 };
 
 // Returns a reference to a singleton.
 const AccountId& EmptyAccountId();
 
 namespace BASE_HASH_NAMESPACE {
 
 // Implement hashing of AccountId, so it can be used as a key in STL containers.
 template <>
 struct hash<AccountId> {
   std::size_t operator()(const AccountId& user_id) const;
 };
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // COMPONENTS_SIGNIN_CORE_ACCOUNT_ID_ACCOUNT_ID_H_