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

chrome/test/base/testing_profile.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 "chrome/test/base/testing_profile.h"
 
 #include "build/build_config.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 114 matching lines @@
   return new DesktopNotificationService(profile, NULL);
 }
 
 }  // namespace
 
 TestingProfile::TestingProfile()
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       incognito_(false),
       last_session_exited_cleanly_(true),
+      enable_lazy_service_initialization_(false),

[Paweł Hajdan Jr., 2011/11/21 12:19:37]

This new variable is not checked consistently in TestingProfile. Please make
either everything check it, or change the name, or find some other solution.

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

I added it to all Get*Service methods which:
- are explicitly named for a service 
- do not currently return NULL
- do not require additional parameters to initialize

There were 4 such methods. The only exception was GetPrefs() which always
initializes lazily.

If this is insufficient, please let me know and I will find a different way
around it.

       profile_dependency_manager_(ProfileDependencyManager::GetInstance()) {
   if (!temp_dir_.CreateUniqueTempDir()) {
     LOG(ERROR) << "Failed to create unique temporary directory.";
 
     // Fallback logic in case we fail to create unique temporary directory.
     FilePath system_tmp_dir;
     bool success = PathService::Get(base::DIR_TEMP, &system_tmp_dir);
 
     // We're severly screwed if we can't get the system temporary
     // directory. Die now to avoid writing to the filesystem root
@@ skipping 15 matching lines @@
   profile_path_ = temp_dir_.path();
 
   Init();
 }
 
 TestingProfile::TestingProfile(const FilePath& path)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       incognito_(false),
       last_session_exited_cleanly_(true),
+      enable_lazy_service_initialization_(false),
       profile_path_(path),
       profile_dependency_manager_(ProfileDependencyManager::GetInstance()) {
   Init();
 }
 
+TestingProfile::TestingProfile(const FilePath& path,
+                               Delegate* delegate)
+    : start_time_(Time::Now()),
+      testing_prefs_(NULL),
+      incognito_(false),
+      last_session_exited_cleanly_(true),
+      enable_lazy_service_initialization_(false),
+      profile_path_(path),
+      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      delegate_(delegate) {
+  if (delegate_) {
+    profile_dependency_manager_->CreateProfileServices(this, true);

[Paweł Hajdan Jr., 2011/11/21 12:19:37]

Isn't this essentially identical to Init except the PostTask bit? Could you
factor the code in a way that doesn't duplicate most of it?

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

Done.

+
+    // Install profile keyed service factory hooks for dummy/test services
+    DesktopNotificationServiceFactory::GetInstance()->SetTestingFactory(
+        this, CreateTestDesktopNotificationService);
+
+    MessageLoop::current()->PostTask(FROM_HERE,
+                                     base::Bind(&TestingProfile::FinishInit,
+                                                base::Unretained(this)));
+  } else {
+    Init();
+  }
+}
+
 void TestingProfile::Init() {
   profile_dependency_manager_->CreateProfileServices(this, true);
 
   // Install profile keyed service factory hooks for dummy/test services
   DesktopNotificationServiceFactory::GetInstance()->SetTestingFactory(
       this, CreateTestDesktopNotificationService);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CREATED,
       content::Source<Profile>(static_cast<Profile*>(this)),
       content::NotificationService::NoDetails());
 }
 
+void TestingProfile::FinishInit() {
+  NotificationService::current()->Notify(
+      chrome::NOTIFICATION_PROFILE_CREATED,
+      content::Source<Profile>(static_cast<Profile*>(this)),
+      NotificationService::NoDetails());
+
+  if (delegate_)
+    delegate_->OnProfileCreated(this, true);
+}
+
 TestingProfile::~TestingProfile() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_DESTROYED,
       content::Source<Profile>(static_cast<Profile*>(this)),
       content::NotificationService::NoDetails());
 
   profile_dependency_manager_->DestroyProfileServices(this);
 
   if (host_content_settings_map_)
     host_content_settings_map_->ShutdownOnUIThread();
@@ skipping 275 matching lines @@
   if (!extension_special_storage_policy_.get())
     extension_special_storage_policy_ = new ExtensionSpecialStoragePolicy(NULL);
   return extension_special_storage_policy_.get();
 }
 
 SSLHostState* TestingProfile::GetSSLHostState() {
   return NULL;
 }
 
 FaviconService* TestingProfile::GetFaviconService(ServiceAccessType access) {
+  if (enable_lazy_service_initialization_ && !favicon_service_.get())
+    CreateFaviconService();
   return favicon_service_.get();
 }
 
 HistoryService* TestingProfile::GetHistoryService(ServiceAccessType access) {
+  if (enable_lazy_service_initialization_ && !history_service_.get())
+    CreateHistoryService(true, false);
   return history_service_.get();
 }
 
 HistoryService* TestingProfile::GetHistoryServiceWithoutCreating() {
   return history_service_.get();
 }
 
 net::CookieMonster* TestingProfile::GetCookieMonster() {
   if (!GetRequestContext())
     return NULL;
   return GetRequestContext()->GetURLRequestContext()->cookie_store()->
       GetCookieMonster();
 }
 
 AutocompleteClassifier* TestingProfile::GetAutocompleteClassifier() {
   return autocomplete_classifier_.get();
 }
 
 history::ShortcutsBackend* TestingProfile::GetShortcutsBackend() {
   return NULL;
 }
 
 WebDataService* TestingProfile::GetWebDataService(ServiceAccessType access) {
+  if (enable_lazy_service_initialization_ && !web_data_service_.get())
+    CreateWebDataService(false);
   return web_data_service_.get();
 }
 
 WebDataService* TestingProfile::GetWebDataServiceWithoutCreating() {
   return web_data_service_.get();
 }
 
 PasswordStore* TestingProfile::GetPasswordStore(ServiceAccessType access) {
   return NULL;
 }
@@ skipping 158 matching lines @@
 
 void TestingProfile::SetID(const std::wstring& id) {
   id_ = id;
 }
 
 bool TestingProfile::DidLastSessionExitCleanly() {
   return last_session_exited_cleanly_;
 }
 
 BookmarkModel* TestingProfile::GetBookmarkModel() {
+  if (enable_lazy_service_initialization_ && !bookmark_bar_model_.get())
+    CreateBookmarkModel(true);
   return bookmark_bar_model_.get();
 }
 
 bool TestingProfile::IsSameProfile(Profile *p) {
   return this == p;
 }
 
 base::Time TestingProfile::GetStartTime() const {
   return start_time_;
 }
@@ skipping 111 matching lines @@
 quota::SpecialStoragePolicy* TestingProfile::GetSpecialStoragePolicy() {
   return GetExtensionSpecialStoragePolicy();
 }
 
 void TestingProfile::DestroyWebDataService() {
   if (!web_data_service_.get())
     return;
 
   web_data_service_->Shutdown();
 }