Only return fully initialized profiles in ProfileManager::GetProfileByPath.

chrome/browser/profiles/profile_manager.cc

 // Copyright (c) 2012 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/profiles/profile_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 361 matching lines @@
   return profile;
 }
 
 Profile* ProfileManager::GetProfile(const base::FilePath& profile_dir) {
   TRACE_EVENT0("browser", "ProfileManager::GetProfile");
   SCOPED_UMA_HISTOGRAM_TIMER("Profile.GetProfile");
 
   // If the profile is already loaded (e.g., chrome.exe launched twice), just
   // return it.
   Profile* profile = GetProfileByPath(profile_dir);
-  if (NULL != profile)
+  if (profile)
     return profile;
 
+  // If the profile has not been found, check that we have not started loading
+  // it (which would mean that the profile is not fully initialized yet).
+  DCHECK(!GetProfileByPathInternal(profile_dir));

[noms (inactive), 2015/02/18 21:26:21]

Hmm, so in non-debug world, if the profile has not been founded but we *have*
started loading it (and it's not fully initialized), don't we then, on line 389,
create it again?

[Bernhard Bauer, 2015/02/19 10:22:37]

Made it a CHECK.

+
   profile = CreateProfileHelper(profile_dir);
   DCHECK(profile);
   if (profile) {
     bool result = AddProfile(profile);
     DCHECK(result);
   }
   return profile;
 }
 
 size_t ProfileManager::GetNumberOfProfiles() {
@@ skipping 158 matching lines @@
 std::vector<Profile*> ProfileManager::GetLoadedProfiles() const {
   std::vector<Profile*> profiles;
   for (ProfilesInfoMap::const_iterator iter = profiles_info_.begin();
        iter != profiles_info_.end(); ++iter) {
     if (iter->second->created)
       profiles.push_back(iter->second->profile.get());
   }
   return profiles;
 }
 
+Profile* ProfileManager::GetProfileByPathInternal(
+    const base::FilePath& path) const {
+  TRACE_EVENT0("browser", "ProfileManager::GetProfileByPathInternal");
+  ProfileInfo* profile_info = GetProfileInfoByPath(path);
+  return profile_info ? profile_info->profile.get() : nullptr;
+}
+
 Profile* ProfileManager::GetProfileByPath(const base::FilePath& path) const {
   TRACE_EVENT0("browser", "ProfileManager::GetProfileByPath");
   ProfileInfo* profile_info = GetProfileInfoByPath(path);
-  return profile_info ? profile_info->profile.get() : NULL;
+  return profile_info && profile_info->created ? profile_info->profile.get()
+                                               : nullptr;
 }
 
 // static
 base::FilePath ProfileManager::CreateMultiProfileAsync(
     const base::string16& name,
     const base::string16& icon_url,
     const CreateCallback& callback,
     const std::string& supervised_user_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 281 matching lines @@
       // If we don't have a mounted profile directory we're in trouble.
       // TODO(davemoore) Once we have better api this check should ensure that
       // our profile directory is the one that's mounted, and that it's mounted
       // as the current user.
       chromeos::DBusThreadManager::Get()->GetCryptohomeClient()->IsMounted(
           base::Bind(&CheckCryptohomeIsMounted));
 
       // Confirm that we hadn't loaded the new profile previously.
       base::FilePath default_profile_dir = user_data_dir_.Append(
           GetInitialProfileDir());
-      CHECK(!GetProfileByPath(default_profile_dir))
+      CHECK(!GetProfileByPathInternal(default_profile_dir))
           << "The default profile was loaded before we mounted the cryptohome.";
     }
     return;
   }
 #endif
   bool save_active_profiles = false;
   switch (type) {
     case chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST: {
       // Ignore any browsers closing from now on.
       closing_all_browsers_ = true;
@@ skipping 243 matching lines @@
   return GetProfile(default_profile_dir);
 #endif
 }
 
 bool ProfileManager::AddProfile(Profile* profile) {
   TRACE_EVENT0("browser", "ProfileManager::AddProfile");
   DCHECK(profile);
 
   // Make sure that we're not loading a profile with the same ID as a profile
   // that's already loaded.
-  if (GetProfileByPath(profile->GetPath())) {
+  if (GetProfileByPathInternal(profile->GetPath())) {
     NOTREACHED() << "Attempted to add profile with the same path (" <<
                     profile->GetPath().value() <<
                     ") as an already-loaded profile.";
     return false;
   }
 
   RegisterProfile(profile, true);
   InitProfileUserPrefs(profile);
   DoFinalInit(profile, ShouldGoOffTheRecord(profile));
   return true;
@@ skipping 235 matching lines @@
           last_non_supervised_profile_path.BaseName().MaybeAsASCII());
       FinishDeletingProfile(profile_to_delete_path);
     }
   }
 }
 #endif
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }