Create LoadProfile method in profile_manager

chrome/browser/profiles/profile_manager_unittest.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 <stddef.h>
 
 #include <string>
 
 #include "base/command_line.h"
+#include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 66 matching lines @@
                                     Delegate* delegate) override {
     // This is safe while all file operations are done on the FILE thread.
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(base::IgnoreResult(&base::CreateDirectory), path));
 
     return new TestingProfile(path, this);
   }
 };
 
+void ExpectNullProfile(base::Closure closure, Profile* profile) {
+  EXPECT_EQ(nullptr, profile);
+  closure.Run();
+}
+
+void ExpectProfileWithName(const std::string& profile_name,
+                           bool incognito,
+                           base::Closure closure,
+                           Profile* profile) {
+  EXPECT_NE(nullptr, profile);
+  EXPECT_EQ(incognito, profile->IsOffTheRecord());
+  if (incognito)
+    profile = profile->GetOriginalProfile();
+
+  // Create a profile on the fly so the the same comparison
+  // can be used in Windows and other platforms.
+  EXPECT_EQ(base::FilePath().AppendASCII(profile_name),
+            profile->GetPath().BaseName());
+  closure.Run();
+}
+
 }  // namespace
 
 class ProfileManagerTest : public testing::Test {
  protected:
   class MockObserver {
    public:
     MOCK_METHOD2(OnProfileCreated,
         void(Profile* profile, Profile::CreateStatus status));
   };
 
@@ skipping 180 matching lines @@
 
   // Make sure any pending tasks run before we destroy the profiles.
     base::RunLoop().RunUntilIdle();
 
   TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
 
   // Make sure history cleans up correctly.
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_F(ProfileManagerTest, LoadNonExistingProfile) {
+  const std::string profile_name = "NonExistingProfile";
+  base::RunLoop run_loop_1;
+  base::RunLoop run_loop_2;
+
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  profile_manager->LoadProfile(
+      profile_name, false /* incognito */,
+      base::Bind(&ExpectNullProfile, run_loop_1.QuitClosure()));
+  run_loop_1.Run();
+
+  profile_manager->LoadProfile(
+      profile_name, true /* incognito */,
+      base::Bind(&ExpectNullProfile, run_loop_2.QuitClosure()));
+  run_loop_2.Run();
+}
+
+TEST_F(ProfileManagerTest, LoadExistingProfile) {
+  const std::string profile_name = "MyProfile";
+  const std::string other_name = "SomeOtherProfile";
+  MockObserver mock_observer1;
+  EXPECT_CALL(mock_observer1, OnProfileCreated(SameNotNull(), NotFail()))
+      .Times(testing::AtLeast(1));
+
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  CreateProfileAsync(profile_manager, profile_name, false, &mock_observer1);
+
+  // Make sure a real profile is created before continuing.
+  base::RunLoop().RunUntilIdle();
+
+  base::RunLoop load_profile;
+  bool incognito = false;
+  profile_manager->LoadProfile(
+      profile_name, incognito,
+      base::Bind(&ExpectProfileWithName, profile_name, incognito,
+                 load_profile.QuitClosure()));
+  load_profile.Run();
+
+  base::RunLoop load_profile_incognito;
+  incognito = true;
+  profile_manager->LoadProfile(
+      profile_name, incognito,
+      base::Bind(&ExpectProfileWithName, profile_name, incognito,
+                 load_profile_incognito.QuitClosure()));
+  load_profile_incognito.Run();
+
+  // Loading some other non existing profile should still return null.
+  base::RunLoop load_other_profile;
+  profile_manager->LoadProfile(
+      other_name, false,
+      base::Bind(&ExpectNullProfile, load_other_profile.QuitClosure()));
+  load_other_profile.Run();
+}
+
 TEST_F(ProfileManagerTest, CreateProfileAsyncMultipleRequests) {
   g_created_profile = NULL;
 
   MockObserver mock_observer1;
   EXPECT_CALL(mock_observer1, OnProfileCreated(
       SameNotNull(), NotFail())).Times(testing::AtLeast(1));
   MockObserver mock_observer2;
   EXPECT_CALL(mock_observer2, OnProfileCreated(
       SameNotNull(), NotFail())).Times(testing::AtLeast(1));
   MockObserver mock_observer3;
@@ skipping 1033 matching lines @@
                          dest_path2.BaseName().MaybeAsASCII());
   profile_manager->ScheduleProfileForDeletion(dest_path2,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(dest_path3, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name3, local_state->GetString(prefs::kProfileLastUsed));
 }
 #endif  // !defined(OS_MACOSX)