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),
-      profile_dependency_manager_(ProfileDependencyManager::GetInstance()) {
+      enable_lazy_service_initialization_(false),
+      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      delegate_(NULL) {
   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
     // or other bad places.
     CHECK(success);
 
     FilePath fallback_dir(system_tmp_dir.AppendASCII("TestingProfilePath"));
     file_util::Delete(fallback_dir, true);
     file_util::CreateDirectory(fallback_dir);
     if (!temp_dir_.Set(fallback_dir)) {
       // That shouldn't happen, but if it does, try to recover.
       LOG(ERROR) << "Failed to use a fallback temporary directory.";
 
       // We're screwed if this fails, see CHECK above.
       CHECK(temp_dir_.Set(system_tmp_dir));
     }
   }
 
   profile_path_ = temp_dir_.path();
 
   Init();
+  FinishInit();
 }
 
 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()) {
+      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      delegate_(NULL) {
   Init();
+  FinishInit();
+}
+
+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) {
+  Init();
+  if (delegate_) {
+    MessageLoop::current()->PostTask(FROM_HERE,
+                                     base::Bind(&TestingProfile::FinishInit,
+                                                base::Unretained(this)));
+  } else {
+    FinishInit();
+  }
 }
 
 void TestingProfile::Init() {
   profile_dependency_manager_->CreateProfileServices(this, true);
 
   // Install profile keyed service factory hooks for dummy/test services
   DesktopNotificationServiceFactory::GetInstance()->SetTestingFactory(
       this, CreateTestDesktopNotificationService);
+}
 
+void TestingProfile::FinishInit() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CREATED,
       content::Source<Profile>(static_cast<Profile*>(this)),
       content::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);
 
@@ skipping 180 matching lines @@
                                                 autoupdate_enabled,
                                                 true));
   return extension_service_.get();
 }
 
 FilePath TestingProfile::GetPath() {
   return profile_path_;
 }
 
 TestingPrefService* TestingProfile::GetTestingPrefService() {
+  // Always lazily initialize so no check for

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

I don't understand the difference here. It seems that in other cases
enable_lazy_service_initialization_ = false means "disable", and the service is
not created. Why is this case different? Why do we need this boolean member
variable at all?

[rpetterson, 2011/11/22 21:43:25]

The intention of enable_lazy_service_initialization_ was that if it is true,
then we allow lazy initialization. That is, if we are getting the object and it
did not exist before, we create it then. If enable_lazy_service_initialization_
is false and the object does not exist, we do not create it and return null so
it would be up to the user of the code to create it.

I understand the point you were trying make now and rather than introducing a
new variable, I have changed the profile manager unittest. This seems to be a
cleaner solution.

+  // enable_lazy_service_initialization_.
   if (!prefs_.get())
     CreateTestingPrefService();
   DCHECK(testing_prefs_);
   return testing_prefs_;
 }
 
 TestingProfile* TestingProfile::AsTestingProfile() {
   return this;
 }
 
@@ skipping 77 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;
 }
 
 void TestingProfile::SetPrefService(PrefService* prefs) {
   DCHECK(!prefs_.get());
   prefs_.reset(prefs);
 }
 
 void TestingProfile::CreateTestingPrefService() {
   DCHECK(!prefs_.get());
   testing_prefs_ = new TestingPrefService();
   prefs_.reset(testing_prefs_);
   Profile::RegisterUserPrefs(prefs_.get());
   browser::RegisterUserPrefs(prefs_.get());
 }
 
 PrefService* TestingProfile::GetPrefs() {
   if (!prefs_.get()) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     CreateTestingPrefService();
   }
   return prefs_.get();
 }
 
 TemplateURLFetcher* TestingProfile::GetTemplateURLFetcher() {
   return template_url_fetcher_.get();
 }
 
 history::TopSites* TestingProfile::GetTopSites() {
   return top_sites_.get();
 }
 
 history::TopSites* TestingProfile::GetTopSitesWithoutCreating() {
   return top_sites_.get();
 }
 
 DownloadManager* TestingProfile::GetDownloadManager() {
   return NULL;
 }
 
 fileapi::FileSystemContext* TestingProfile::GetFileSystemContext() {
   if (!file_system_context_) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     file_system_context_ = new fileapi::FileSystemContext(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
       GetExtensionSpecialStoragePolicy(),
       NULL,
       GetPath(),
       IsOffTheRecord(),
       true,  // Allow file access from files.
       NULL);
   }
@@ skipping 31 matching lines @@
 
 void TestingProfile::ResetRequestContext() {
   request_context_ = NULL;
 }
 
 net::URLRequestContextGetter* TestingProfile::GetRequestContextForMedia() {
   return NULL;
 }
 
 net::URLRequestContextGetter* TestingProfile::GetRequestContextForExtensions() {
   if (!extensions_request_context_)

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

       extensions_request_context_ = new TestExtensionURLRequestContextGetter();
   return extensions_request_context_.get();
 }
 
 net::SSLConfigService* TestingProfile::GetSSLConfigService() {
   return NULL;
 }
 
 UserStyleSheetWatcher* TestingProfile::GetUserStyleSheetWatcher() {
   return NULL;
 }
 
 net::URLRequestContextGetter* TestingProfile::GetRequestContextForIsolatedApp(
     const std::string& app_id) {
   // We don't test isolated app storage here yet, so returning the same dummy
   // context is sufficient for now.
   return GetRequestContext();
 }
 
 const content::ResourceContext& TestingProfile::GetResourceContext() {
   return *content::MockResourceContext::GetInstance();
 }
 
 FindBarState* TestingProfile::GetFindBarState() {
   if (!find_bar_state_.get())

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     find_bar_state_.reset(new FindBarState());
   return find_bar_state_.get();
 }
 
 HostContentSettingsMap* TestingProfile::GetHostContentSettingsMap() {
   if (!host_content_settings_map_.get()) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     host_content_settings_map_ = new HostContentSettingsMap(
         GetPrefs(), GetExtensionService(), false);
   }
   return host_content_settings_map_.get();
 }
 
 GeolocationPermissionContext*
 TestingProfile::GetGeolocationPermissionContext() {
   if (!geolocation_permission_context_.get()) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     geolocation_permission_context_ =
         new ChromeGeolocationPermissionContext(this);
   }
   return geolocation_permission_context_.get();
 }
 
 SpeechInputPreferences* TestingProfile::GetSpeechInputPreferences() {
   if (!speech_input_preferences_.get())

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     speech_input_preferences_ = new ChromeSpeechInputPreferences(GetPrefs());
   return speech_input_preferences_.get();
 }
 
 HostZoomMap* TestingProfile::GetHostZoomMap() {
   return NULL;
 }
 
 bool TestingProfile::HasProfileSyncService() const {
   return (profile_sync_service_.get() != NULL);
 }
 
 std::wstring TestingProfile::GetName() {
   return std::wstring();
 }
 
 std::wstring TestingProfile::GetID() {
   return id_;
 }
 
 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_;
 }
 
 ProtocolHandlerRegistry* TestingProfile::GetProtocolHandlerRegistry() {
   return protocol_handler_registry_.get();
 }
 
 SpellCheckHost* TestingProfile::GetSpellCheckHost() {
   return NULL;
 }
 
 WebKitContext* TestingProfile::GetWebKitContext() {
   if (webkit_context_ == NULL) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     webkit_context_ = new WebKitContext(
           IsOffTheRecord(), GetPath(),
           GetExtensionSpecialStoragePolicy(),
           false, NULL, NULL);
   }
   return webkit_context_;
 }
 
 WebKitContext* TestingProfile::GetOffTheRecordWebKitContext() {
   return NULL;
 }
 
 FilePath TestingProfile::last_selected_directory() {
   return last_selected_directory_;
 }
 
 void TestingProfile::set_last_selected_directory(const FilePath& path) {
   last_selected_directory_ = path;
 }
 
 PrefProxyConfigTracker* TestingProfile::GetProxyConfigTracker() {
   if (!pref_proxy_config_tracker_.get()) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     pref_proxy_config_tracker_.reset(
         ProxyServiceFactory::CreatePrefProxyConfigTracker(GetPrefs()));
   }
   return pref_proxy_config_tracker_.get();
 }
 
 void TestingProfile::BlockUntilHistoryProcessesPendingRequests() {
   DCHECK(history_service_.get());
   DCHECK(MessageLoop::current());
 
   CancelableRequestConsumer consumer;
   history_service_->ScheduleDBTask(new QuittingHistoryDBTask(), &consumer);
   MessageLoop::current()->Run();
 }
 
 TokenService* TestingProfile::GetTokenService() {
   if (!token_service_.get()) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     token_service_.reset(new TokenService());
   }
   return token_service_.get();
 }
 
 ProfileSyncService* TestingProfile::GetProfileSyncService() {
   return GetProfileSyncService("");
 }
 
 ProfileSyncService* TestingProfile::GetProfileSyncService(
     const std::string& cros_user) {
   if (!profile_sync_service_.get()) {

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     // Use a NiceMock here since we are really using the mock as a
     // fake.  Test cases that want to set expectations on a
     // ProfileSyncService should use the ProfileMock and have this
     // method return their own mock instance.
     profile_sync_service_.reset(new NiceMock<ProfileSyncServiceMock>());
   }
   return profile_sync_service_.get();
 }
 
 ChromeBlobStorageContext* TestingProfile::GetBlobStorageContext() {
   return NULL;
 }
 
 ExtensionInfoMap* TestingProfile::GetExtensionInfoMap() {
   return NULL;
 }
 
 PromoCounter* TestingProfile::GetInstantPromoCounter() {
   return NULL;
 }
 
 ChromeURLDataManager* TestingProfile::GetChromeURLDataManager() {
   if (!chrome_url_data_manager_.get())

[Paweł Hajdan Jr., 2011/11/22 09:18:42]

Should this check enable_lazy_service_initialization_ ?

     chrome_url_data_manager_.reset(
         new ChromeURLDataManager(
             base::Callback<ChromeURLDataManagerBackend*(void)>()));
   return chrome_url_data_manager_.get();
 }
 
 chrome_browser_net::Predictor* TestingProfile::GetNetworkPredictor() {
   return NULL;
 }
 
@@ skipping 16 matching lines @@
 quota::SpecialStoragePolicy* TestingProfile::GetSpecialStoragePolicy() {
   return GetExtensionSpecialStoragePolicy();
 }
 
 void TestingProfile::DestroyWebDataService() {
   if (!web_data_service_.get())
     return;
 
   web_data_service_->Shutdown();
 }