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 360 matching lines @@
   CHECK(profile) << profile_manager->user_data_dir().AsUTF8Unsafe();
   return profile;
 }
 
 Profile* ProfileManager::GetProfile(const base::FilePath& profile_dir) {
   TRACE_EVENT0("browser", "ProfileManager::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;
   return CreateAndInitializeProfile(profile_dir);
 }
 
 size_t ProfileManager::GetNumberOfProfiles() {
   return GetProfileInfoCache().GetNumberOfProfiles();
 }
 
 void ProfileManager::CreateProfileAsync(
     const base::FilePath& profile_path,
@@ skipping 153 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()

[Pam (message me for reviews), 2015/02/23 12:02:02]

nit: This would be slightly clearer with the condition parenthesized.

[Bernhard Bauer, 2015/02/23 18:42:13]

Done (in https://codereview.chromium.org/953453002).

+                                               : 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 245 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;
 }
 
 Profile* ProfileManager::CreateAndInitializeProfile(
     const base::FilePath& profile_dir) {
   TRACE_EVENT0("browser", "ProfileManager::CreateAndInitializeProfile");
   SCOPED_UMA_HISTOGRAM_LONG_TIMER("Profile.CreateAndInitializeProfile");
+
+  // CHECK that we are not trying to load the same profile twice, to prevent
+  // profile corruption. Note that this check also covers the case when we have
+  // already started loading the profile but it is not fully initialized yet,
+  // which would make Bad Things happen if we returned it.
+  CHECK(!GetProfileByPathInternal(profile_dir));
   Profile* profile = CreateProfileHelper(profile_dir);
   DCHECK(profile);
   if (profile) {
     bool result = AddProfile(profile);
     DCHECK(result);
   }
   return profile;
 }
 
 void ProfileManager::FinishDeletingProfile(const base::FilePath& profile_dir) {
@@ skipping 232 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) {
 }