Fixing ProfileManagerTest to use the TestingProfile instead of a real profile. This will allow ea...

chrome/browser/profiles/profile_manager_unittest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_event_router_forwarder.h"
 #include "chrome/browser/io_thread.h"
@@ skipping 19 matching lines @@
 
 using content::BrowserThread;
 
 namespace {
 // This global variable is used to check that value returned to different
 // observers is the same.
 Profile* g_created_profile;
 
 }  // namespace
 
+namespace testing {
+
+class ProfileManager : public ::ProfileManagerWithoutInit {
+ public:
+  explicit ProfileManager(const FilePath& user_data_dir)
+      : ::ProfileManagerWithoutInit(user_data_dir) {}
+
+ protected:
+  virtual Profile* CreateProfile(const FilePath& file_path) {
+    if (!file_util::PathExists(file_path)) {
+      if (!file_util::CreateDirectory(file_path))
+        return NULL;
+    }
+    return new TestingProfile(file_path, NULL);
+  }
+
+  virtual Profile* CreateAsyncProfile(const FilePath& path,
+                                      Delegate* delegate) {
+    // This is safe while all file operations are done on the FILE thread.
+    BrowserThread::PostTask(BrowserThread::FILE,
+                            FROM_HERE,
+                            NewRunnableFunction(&file_util::CreateDirectory,
+                                                path));
+    return new TestingProfile(path, this);

[Miranda Callahan, 2011/11/21 15:31:31]

Could there be any race conditions with immediately returning the TestingProfile
here? I know in regular asynchronous Profile creation, we don't create the
Browser attached to the Profile or register it in the ProfileInfoCache until
it's fully created, which prevents it from being accessed too early; I'm afraid
that for unit tests, we don't have the same guards. 

[rpetterson, 2011/11/21 22:59:30]

Currently in the ProfileManager we call
ProfileInfo* info =
    RegisterProfile(Profile::CreateProfileAsync(user_data_dir, this), false);

RegisterProfile registers it in the info cache so a profile is returned
immediately (since Profile::CreateProfileAsync shouldn't block) even though it
hasn't been fully initialized at this point. So this behavior should be the
same. With regards to the Browser window, since we aren't creating those for any
of the ProfileManager unittests, it shouldn't be an issue.

In either case, it should not be an issue since the primary asynchronous
activity that happens (from what I can tell) is prefs creation and that occurs
lazily in the normal TestingProfile as is.

+  }
+};
+
+}  // namespace testing
+
 class ProfileManagerTest : public testing::Test {
  protected:
   ProfileManagerTest()
       : local_state_(static_cast<TestingBrowserProcess*>(g_browser_process)),
         extension_event_router_forwarder_(new ExtensionEventRouterForwarder),
         ui_thread_(BrowserThread::UI, &message_loop_),
         db_thread_(BrowserThread::DB, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         io_thread_(local_state_.Get(), NULL,
                    extension_event_router_forwarder_) {
 #if defined(OS_MACOSX)
     base::SystemMonitor::AllocateSystemIOPorts();
 #endif
     system_monitor_dummy_.reset(new base::SystemMonitor);
     static_cast<TestingBrowserProcess*>(g_browser_process)->SetIOThread(
         &io_thread_);
   }
 
   virtual void SetUp() {
     // Create a new temporary directory, and store the path
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    profile_manager_.reset(new ProfileManagerWithoutInit(temp_dir_.path()));
+    profile_manager_.reset(new testing::ProfileManager(temp_dir_.path()));
   }
 
   virtual void TearDown() {
     profile_manager_.reset();
     message_loop_.RunAllPending();
   }
 
   class MockObserver : public ProfileManagerObserver {
    public:
     MOCK_METHOD2(OnProfileCreated, void(Profile* profile, Status status));
   };
 
 #if defined(OS_CHROMEOS)
   // Do not change order of stub_cros_enabler_, which needs to be constructed
   // before io_thread_ which requires CrosLibrary to be initialized to construct
   // its data member pref_proxy_config_tracker_ on ChromeOS.
   chromeos::ScopedStubCrosEnabler stub_cros_enabler_;
 #endif
 
   // The path to temporary directory used to contain the test operations.
   ScopedTempDir temp_dir_;
   ScopedTestingLocalState local_state_;
   scoped_refptr<ExtensionEventRouterForwarder>
       extension_event_router_forwarder_;
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   content::TestBrowserThread file_thread_;
+  // IOThread is necessary for the creation of some services below.
   IOThread io_thread_;
 
   scoped_ptr<base::SystemMonitor> system_monitor_dummy_;
 
   // Also will test profile deletion.
   scoped_ptr<ProfileManager> profile_manager_;
 };
 
 TEST_F(ProfileManagerTest, GetProfile) {
   FilePath dest_path = temp_dir_.path();
@@ skipping 47 matching lines @@
 
 #endif
 
 TEST_F(ProfileManagerTest, CreateAndUseTwoProfiles) {
   FilePath dest_path1 = temp_dir_.path();
   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 
   FilePath dest_path2 = temp_dir_.path();
   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 
-  Profile* profile1;
-  Profile* profile2;
+  // Successfully create the profiles.
+  TestingProfile* profile1 =
+      static_cast<TestingProfile*>(profile_manager_->GetProfile(dest_path1));
+  ASSERT_TRUE(profile1);
+  profile1->set_enable_lazy_service_initialization(true);
 
-  // Successfully create the profiles.
-  profile1 = profile_manager_->GetProfile(dest_path1);
-  ASSERT_TRUE(profile1);
-
-  profile2 = profile_manager_->GetProfile(dest_path2);
+  TestingProfile* profile2 =
+      static_cast<TestingProfile*>(profile_manager_->GetProfile(dest_path2));
   ASSERT_TRUE(profile2);
+  profile2->set_enable_lazy_service_initialization(true);
 
   // Force lazy-init of some profile services to simulate use.
   EXPECT_TRUE(profile1->GetHistoryService(Profile::EXPLICIT_ACCESS));
   EXPECT_TRUE(profile1->GetBookmarkModel());
   EXPECT_TRUE(profile2->GetBookmarkModel());
   EXPECT_TRUE(profile2->GetHistoryService(Profile::EXPLICIT_ACCESS));
 
   // Make sure any pending tasks run before we destroy the profiles.
   message_loop_.RunAllPending();
 
@@ skipping 78 matching lines @@
   cache.AddProfileToCache(cache.GetUserDataDir().AppendASCII("path_3"),
                           ASCIIToUTF16("name_3"), string16(), 0);
   cache.SetBackgroundStatusOfProfileAtIndex(0, true);
   cache.SetBackgroundStatusOfProfileAtIndex(2, true);
   EXPECT_EQ(3u, cache.GetNumberOfProfiles());
 
   profile_manager_->AutoloadProfiles();
 
   EXPECT_EQ(2u, profile_manager_->GetLoadedProfiles().size());
 }