Refactor most c/b/profiles calls to ProfileInfoCache.

chrome/browser/chromeos/profiles/profile_list_chromeos.cc

 // Copyright 2013 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 "chrome/browser/chromeos/profiles/profile_list_chromeos.h"
 
 #include <algorithm>
 
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/profiles/profile_attributes_entry.h"
+#include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "components/user_manager/user_manager.h"
 
 // static
-ProfileList* ProfileList::Create(ProfileInfoInterface* profile_cache) {
-  return new chromeos::ProfileListChromeOS(profile_cache);
+ProfileList* ProfileList::Create(ProfileAttributesStorage* profile_storage) {
+  return new chromeos::ProfileListChromeOS(profile_storage);
 }
 
 namespace chromeos {
 
-ProfileListChromeOS::ProfileListChromeOS(ProfileInfoInterface* profile_cache)
-    : profile_info_(profile_cache) {
+ProfileListChromeOS::ProfileListChromeOS(
+    ProfileAttributesStorage* profile_storage)
+    : profile_storage_(profile_storage) {
 }
 
 ProfileListChromeOS::~ProfileListChromeOS() {
   ClearMenu();
 }
 
 size_t ProfileListChromeOS::GetNumberOfItems() const {
   return items_.size();
 }
 
 const AvatarMenu::Item& ProfileListChromeOS::GetItemAt(size_t index) const {
   DCHECK_LT(index, items_.size());
   return *items_[index];
 }
 
 void ProfileListChromeOS::RebuildMenu() {
   ClearMenu();
 
   // Filter for profiles associated with logged-in users.
   user_manager::UserList users =
       user_manager::UserManager::Get()->GetLoggedInUsers();
 
+  std::vector<ProfileAttributesEntry*> entries =
+      profile_storage_->GetAllProfilesAttributes();
+  // Prepare a sorted vector of the profile attributes entries that will be used
+  // to determine an item's index in the AvatarMenu.
+  std::sort(entries.begin(), entries.end(),
+            [](ProfileAttributesEntry* first, ProfileAttributesEntry* second) {
+              return first->LessThan(*second);
+            });
   // Add corresponding profiles.
   for (user_manager::UserList::const_iterator it = users.begin();
        it != users.end();
        ++it) {
-    size_t i = profile_info_->GetIndexOfProfileWithPath(
-        ProfileHelper::GetProfilePathByUserIdHash((*it)->username_hash()));
+    const base::FilePath& path =
+        ProfileHelper::GetProfilePathByUserIdHash((*it)->username_hash());
+    ProfileAttributesEntry* entry;
+    if (!profile_storage_->GetProfileAttributesWithPath(path, &entry)) {
+      continue;
+    }
 
     gfx::Image icon = gfx::Image((*it)->GetImage());
     if (!switches::IsNewProfileManagement() && !icon.IsEmpty()) {
       // old avatar menu uses resized-small images
       icon = profiles::GetAvatarIconForMenu(icon, true);
     }
 
-    AvatarMenu::Item* item = new AvatarMenu::Item(i, i, icon);
+    size_t sorted_index =

[Mike Lerman, 2015/08/06 16:06:19]

Why not just keep an iterator i that you increment as you move through the loop?
Calling find() every time seems unnecessary (and CPU expensive)

+        std::find(entries.begin(), entries.end(), entry) - entries.begin();
+    DCHECK(sorted_index < entries.size());
+    AvatarMenu::Item* item = new AvatarMenu::Item(sorted_index, icon);
     item->name = (*it)->GetDisplayName();
-    item->username = profile_info_->GetUserNameOfProfileAtIndex(i);
-    item->profile_path = profile_info_->GetPathOfProfileAtIndex(i);
-    DCHECK(!profile_info_->ProfileIsLegacySupervisedAtIndex(i));
+    item->username = entry->GetUserName();
+    item->profile_path = entry->GetPath();
+    DCHECK(!entry->IsLegacySupervised());
     item->legacy_supervised = false;
-    item->child_account = profile_info_->ProfileIsChildAtIndex(i);
+    item->child_account = entry->IsChild();
     item->signed_in = true;
-    item->active = profile_info_->GetPathOfProfileAtIndex(i) ==
-        active_profile_path_;
-    item->signin_required = profile_info_->ProfileIsSigninRequiredAtIndex(i);
+    item->active = entry->GetPath() == active_profile_path_;
+    item->signin_required = entry->IsSigninRequired();
     items_.push_back(item);
   }
 
   SortMenu();
 
   // After sorting, assign items their actual indices.
   for (size_t i = 0; i < items_.size(); ++i)
     items_[i]->menu_index = i;
 }
 
-size_t ProfileListChromeOS::MenuIndexFromProfileIndex(size_t index) {
+size_t ProfileListChromeOS::MenuIndexFromProfilePath(
+    const base::FilePath& path) {
   // On ChromeOS, the active profile might be Default, which does not show
   // up in the model as a logged-in user. In that case, we return 0.
   size_t menu_index = 0;
 
   for (size_t i = 0; i < GetNumberOfItems(); ++i) {
-    if (items_[i]->profile_index == index) {
+    if (items_[i]->profile_path == path) {
       menu_index = i;
       break;
     }
   }
 
   return menu_index;
 }
 
 void ProfileListChromeOS::ActiveProfilePathChanged(base::FilePath& path) {
   active_profile_path_ = path;
 }
 
 void ProfileListChromeOS::ClearMenu() {
   STLDeleteElements(&items_);
 }
 
 void ProfileListChromeOS::SortMenu() {
   // Sort list of items by name.
   std::sort(items_.begin(), items_.end(), &AvatarMenu::CompareItems);
 }
 
 }  // namespace chromeos