Refactor ProfileInfoCache in c/b/ui/views

chrome/browser/ui/views/profiles/profile_chooser_view_browsertest.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 "chrome/browser/ui/views/profiles/profile_chooser_view.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
+#include "chrome/browser/profiles/profile_attributes_entry.h"
+#include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/profiles/avatar_menu_button.h"
 #include "chrome/browser/ui/views/profiles/user_manager_view.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 34 matching lines @@
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   Profile* profile =
       Profile::CreateProfile(path, NULL, Profile::CREATE_MODE_SYNCHRONOUS);
   profile_manager->RegisterTestingProfile(profile, true, false);
   return profile;
 }
 
 // Set up the profiles to enable Lock. Takes as parameter a profile that will be
 // signed in, and also creates a supervised user (necessary for lock).
 void SetupProfilesForLock(Profile* signed_in) {
   const char* signed_in_email = "me@google.com";

[Peter Kasting, 2016/02/16 20:49:54]

Nit: Compile-time constants like this should be named kConstant style and use
const char[]

   Profile* supervised = CreateTestingProfile("supervised");

[Peter Kasting, 2016/02/16 20:49:54]

Nit: Declare variables as close to first use as possible.

Here's a way of rewriting this function that tries to break this up into blocks
based on what locals need to be used in each block, so as to achieve the above. 
This also takes into account my other comments here, and re-wraps some of the
lines a bit based on how I think we normally do things.

  const char kSignedInEmail[] = "me@google.com";

  // Sign in the |signed_in| profile.
  ProfileAttributesStorage* storage =
      g_browser_process->profile_manager()->GetProfileAttributesStorage();
  ProfileAttributesEntry* entry_signed_in;
  ASSERT_TRUE(storage.GetProfileAttributesWithPath(signed_in->GetPath(),
                                                   &entry_signed_in));
  entry_signed_in->SetAuthInfo("12345", base::UTF8ToUTF16(kSignedInEmail));
  signed_in->GetPrefs()->SetString(prefs::kGoogleServicesHostedDomain,
                                   "google.com");

  // Create a supervised user controlled by |signed_in|.
  Profile* supervised = CreateTestingProfile("supervised");
  ProfileAttributesEntry* entry_supervised;
  ASSERT_TRUE(storage.GetProfileAttributesWithPath(supervised->GetPath(),
                                                   &entry_supervised));
  entry_supervised->SetSupervisedUserId(signed_in_email);

  // |signed_in| should now be lockable.
  EXPECT_TRUE(profiles::IsLockAvailable(signed_in));

[lwchkg, 2016/02/17 17:09:31]

Thanks a lot!

On 2016/02/16 20:49:54, Peter Kasting wrote:

-  ProfileInfoCache* cache = &g_browser_process->profile_manager()->
-      GetProfileInfoCache();
-  cache->SetAuthInfoOfProfileAtIndex(cache->GetIndexOfProfileWithPath(
-    signed_in->GetPath()), "12345", base::UTF8ToUTF16(signed_in_email));
+
+  ProfileAttributesStorage& storage =
+      g_browser_process->profile_manager()->GetProfileAttributesStorage();

[Peter Kasting, 2016/02/16 20:49:54]

Nit: Prefer pointers to non-const refs

[lwchkg, 2016/02/17 17:09:31]

Done.

+  ProfileAttributesEntry* entry_signed_in;
+  ProfileAttributesEntry* entry_supervised;
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(
+      signed_in->GetPath(), &entry_signed_in));
+  ASSERT_TRUE(storage.GetProfileAttributesWithPath(
+      supervised->GetPath(), &entry_supervised));
+
+  entry_signed_in->SetAuthInfo("12345", base::UTF8ToUTF16(signed_in_email));
   signed_in->GetPrefs()->
       SetString(prefs::kGoogleServicesHostedDomain, "google.com");
-  cache->SetSupervisedUserIdOfProfileAtIndex(cache->GetIndexOfProfileWithPath(
-    supervised->GetPath()), signed_in_email);
+  entry_supervised->SetSupervisedUserId(signed_in_email);
 
   EXPECT_TRUE(profiles::IsLockAvailable(signed_in));
 }
 
 views::View* FindWebView(views::View* view) {
   std::queue<views::View*> queue;
   queue.push(view);
   while (!queue.empty()) {
     views::View* current = queue.front();
     queue.pop();
@@ skipping 226 matching lines @@
   EXPECT_EQ(1U, BrowserList::GetInstance()->size());
 
   WaitForUserManager();
   // Assert that the first profile's extensions are not blocked.
   ASSERT_EQ(total_enabled_extensions, registry->enabled_extensions().size());
   ASSERT_EQ(0U, registry->blocked_extensions().size());
 
   // We need to hide the User Manager or else the process can't die.
   UserManager::Hide();
 }