Ensure incognito TestingProfiles are incognito for their whole lifetime.

chrome/test/base/testing_profile.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/test/base/testing_profile.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 166 matching lines @@
 // Must be kept in sync with
 // ChromeBrowserMainPartsChromeos::PreEarlyInitialization.
 const char TestingProfile::kTestUserProfileDir[] = "test-user";
 #else
 const char TestingProfile::kTestUserProfileDir[] = "Default";
 #endif
 
 TestingProfile::TestingProfile()
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
-      incognito_(false),
       force_incognito_(false),
       original_profile_(NULL),
       guest_session_(false),
       last_session_exited_cleanly_(true),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
       delegate_(NULL) {
   CreateTempProfileDir();
   profile_path_ = temp_dir_.path();
 
   Init();
   FinishInit();
 }
 
 TestingProfile::TestingProfile(const base::FilePath& path)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
-      incognito_(false),
       force_incognito_(false),
       original_profile_(NULL),
       guest_session_(false),
       last_session_exited_cleanly_(true),
       profile_path_(path),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
       delegate_(NULL) {
   Init();
   FinishInit();
 }
 
 TestingProfile::TestingProfile(const base::FilePath& path,
                                Delegate* delegate)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
-      incognito_(false),
       force_incognito_(false),
       original_profile_(NULL),
       guest_session_(false),
       last_session_exited_cleanly_(true),
       profile_path_(path),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
       delegate_(delegate) {
   Init();
   if (delegate_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&TestingProfile::FinishInit, base::Unretained(this)));
   } else {
     FinishInit();
   }
 }
 
 TestingProfile::TestingProfile(
     const base::FilePath& path,
     Delegate* delegate,
 #if defined(ENABLE_EXTENSIONS)
     scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
 #endif
     scoped_ptr<PrefServiceSyncable> prefs,
-    bool incognito,
+    TestingProfile* incognito_parent,
     bool guest_session,
     const std::string& supervised_user_id,
     scoped_ptr<policy::PolicyService> policy_service,
     const TestingFactories& factories)
     : start_time_(Time::Now()),
       prefs_(prefs.release()),
       testing_prefs_(NULL),
-      incognito_(incognito),
       force_incognito_(false),
-      original_profile_(NULL),
+      original_profile_(incognito_parent),
       guest_session_(guest_session),
       supervised_user_id_(supervised_user_id),
       last_session_exited_cleanly_(true),
 #if defined(ENABLE_EXTENSIONS)
       extension_special_storage_policy_(extension_policy),
 #endif
       profile_path_(path),
       browser_context_dependency_manager_(
           BrowserContextDependencyManager::GetInstance()),
       resource_context_(NULL),
       delegate_(delegate),
       policy_service_(policy_service.release()) {
+  if (incognito_parent)
+    incognito_parent->SetTestingOffTheRecordProfile(this);  // Takes ownership.
+
   // If no profile path was supplied, create one.
   if (profile_path_.empty()) {
     CreateTempProfileDir();
     profile_path_ = temp_dir_.path();
   }
 
   // Set any testing factories prior to initializing the services.
   for (TestingFactories::const_iterator it = factories.begin();
        it != factories.end(); ++it) {
     it->first->SetTestingFactory(this, it->second);
@@ skipping 51 matching lines @@
   AndroidProfileOAuth2TokenService::set_is_testing_profile();
 #endif
 
   // Normally this would happen during browser startup, but for tests
   // we need to trigger creation of Profile-related services.
   ChromeBrowserMainExtraPartsProfiles::
       EnsureBrowserContextKeyedServiceFactoriesBuilt();
 
   if (prefs_.get())
     user_prefs::UserPrefs::Set(this, prefs_.get());
+  else if (IsOffTheRecord())
+    CreateIncognitoPrefService();
   else
     CreateTestingPrefService();
 
   if (!base::PathExists(profile_path_))
     base::CreateDirectory(profile_path_);
 
   // TODO(joaodasilva): remove this once this PKS isn't created in ProfileImpl
   // anymore, after converting the PrefService to a PKS. Until then it must
   // be associated with a TestingProfile too.
   if (!IsOffTheRecord())
     CreateProfilePolicyConnector();
 
 #if defined(ENABLE_EXTENSIONS)
   extensions::ExtensionSystemFactory::GetInstance()->SetTestingFactory(
       this, extensions::TestExtensionSystem::Build);
 #endif
 
-  // If no original profile was specified for this profile: register preferences
-  // even if this is an incognito profile - this allows tests to create a
-  // standalone incognito profile while still having prefs registered.
-  if (!IsOffTheRecord() || !original_profile_) {
+  // Prefs for incognito profiles are set in CreateIncognitoPrefService() by
+  // simulating ProfileImpl::GetOffTheRecordPrefs().
+  if (!IsOffTheRecord()) {
+    DCHECK(!original_profile_);
     user_prefs::PrefRegistrySyncable* pref_registry =
         static_cast<user_prefs::PrefRegistrySyncable*>(
             prefs_->DeprecatedGetPrefRegistry());
     browser_context_dependency_manager_->
         RegisterProfilePrefsForServices(this, pref_registry);
   }
 
   browser_context_dependency_manager_->CreateBrowserContextServicesForTest(
       this);
 
 #if defined(ENABLE_NOTIFICATIONS)
   // Install profile keyed service factory hooks for dummy/test services
   DesktopNotificationServiceFactory::GetInstance()->SetTestingFactory(
       this, CreateTestDesktopNotificationService);
 #endif
 
 #if defined(ENABLE_MANAGED_USERS)
-  SupervisedUserSettingsService* settings_service =
-      SupervisedUserSettingsServiceFactory::GetForProfile(this);
-  TestingPrefStore* store = new TestingPrefStore();
-  settings_service->Init(store);
-  store->SetInitializationCompleted();
+  if (!IsOffTheRecord()) {
+    SupervisedUserSettingsService* settings_service =
+        SupervisedUserSettingsServiceFactory::GetForProfile(this);
+    TestingPrefStore* store = new TestingPrefStore();
+    settings_service->Init(store);
+    store->SetInitializationCompleted();
+  }
 #endif
 
   profile_name_ = "testing_profile";
 }
 
 void TestingProfile::FinishInit() {
   DCHECK(content::NotificationService::current());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CREATED,
       content::Source<Profile>(static_cast<Profile*>(this)),
       content::NotificationService::NoDetails());
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   if (profile_manager)
     profile_manager->InitProfileUserPrefs(this);
 
   if (delegate_)
     delegate_->OnProfileCreated(this, true, false);
 }
 
 TestingProfile::~TestingProfile() {
   // Revert to non-incognito mode before shutdown.
   force_incognito_ = false;
 
+  // If this profile owns an incognito profile, tear it down first.
+  incognito_profile_.reset();

[tapted, 2014/09/12 07:54:09]

This was needed to resolve a lifetime issue in the
UserCloudPolicyManagerChromeOSTest tests, under
BrowserContextKeyedServiceFactory::Disassociate(). It matches what
ProfileImpl::~ProfileImpl() does.

+
   // Any objects holding live URLFetchers should be deleted before teardown.
   TemplateURLFetcherFactory::ShutdownForProfile(this);
 
   MaybeSendDestroyedNotification();
 
   browser_context_dependency_manager_->DestroyBrowserContextServices(this);
 
   if (host_content_settings_map_.get())
     host_content_settings_map_->ShutdownOnUIThread();
 
@@ skipping 172 matching lines @@
 
 base::FilePath TestingProfile::GetPath() const {
   return profile_path_;
 }
 
 scoped_refptr<base::SequencedTaskRunner> TestingProfile::GetIOTaskRunner() {
   return base::MessageLoop::current()->message_loop_proxy();
 }
 
 TestingPrefServiceSyncable* TestingProfile::GetTestingPrefService() {
-  if (!prefs_.get())
-    CreateTestingPrefService();
+  DCHECK(prefs_);
   DCHECK(testing_prefs_);
   return testing_prefs_;
 }
 
 TestingProfile* TestingProfile::AsTestingProfile() {
   return this;
 }
 
 std::string TestingProfile::GetProfileName() {
   return profile_name_;
 }
 
 Profile::ProfileType TestingProfile::GetProfileType() const {
   if (guest_session_)
     return GUEST_PROFILE;
-  if (force_incognito_ || incognito_)
+  if (force_incognito_ || original_profile_)
     return INCOGNITO_PROFILE;
   return REGULAR_PROFILE;
 }
 
 bool TestingProfile::IsOffTheRecord() const {
-  return force_incognito_ || incognito_;
+  return force_incognito_ || original_profile_;
 }
 
 void TestingProfile::SetOffTheRecordProfile(scoped_ptr<Profile> profile) {

[sky, 2014/09/12 15:33:29]

Can this be changed to take a TestingProfile? It would be nice if it set up the
necessarily backpointers.

[tapted, 2014/09/15 05:05:16]

Not easily - that was actually my first attempt, but the
OffTheRecordProfileImplTest unit tests pass an instance of
OffTheRecordProfileImpl rather than TestingProfile. However,
OffTheRecordProfileImpl sets its original_profile in the constructor too, so
I've added `DCHECK_EQ(this, profile->GetOriginalProfile());` to ensure the
backpointer is already set.

   DCHECK(!IsOffTheRecord());
   incognito_profile_ = profile.Pass();
 }
 
-void TestingProfile::SetOriginalProfile(Profile* profile) {
-  DCHECK(IsOffTheRecord());
-  original_profile_ = profile;
-}
-
 Profile* TestingProfile::GetOffTheRecordProfile() {
   if (IsOffTheRecord())
     return this;
-  if (!incognito_profile_) {
-    TestingProfile::Builder builder;
-    builder.SetIncognito();
-    scoped_ptr<TestingProfile> incognito_test_profile(builder.Build());
-    incognito_test_profile->SetOriginalProfile(this);
-    SetOffTheRecordProfile(incognito_test_profile.PassAs<Profile>());
-  }
+  if (!incognito_profile_)
+    TestingProfile::Builder().BuildIncognito(this);
   return incognito_profile_.get();
 }
 
 bool TestingProfile::HasOffTheRecordProfile() {
   return incognito_profile_.get() != NULL;
 }
 
 Profile* TestingProfile::GetOriginalProfile() {
   if (original_profile_)
     return original_profile_;
@@ skipping 30 matching lines @@
 }
 
 void TestingProfile::CreateTestingPrefService() {
   DCHECK(!prefs_.get());
   testing_prefs_ = new TestingPrefServiceSyncable();
   prefs_.reset(testing_prefs_);
   user_prefs::UserPrefs::Set(this, prefs_.get());
   chrome::RegisterUserProfilePrefs(testing_prefs_->registry());
 }
 
+void TestingProfile::CreateIncognitoPrefService() {
+  DCHECK(original_profile_);
+  DCHECK(!testing_prefs_);
+  // Simplified version of ProfileImpl::GetOffTheRecordPrefs(). Note this
+  // leaves testing_prefs_ unset.
+  prefs_.reset(original_profile_->prefs_->CreateIncognitoPrefService(NULL));
+  user_prefs::UserPrefs::Set(this, prefs_.get());
+}
+
 void TestingProfile::CreateProfilePolicyConnector() {
 #if defined(ENABLE_CONFIGURATION_POLICY)
   schema_registry_service_ =
       policy::SchemaRegistryServiceFactory::CreateForContext(
           this, policy::Schema(), NULL);
   CHECK_EQ(schema_registry_service_.get(),
            policy::SchemaRegistryServiceFactory::GetForContext(this));
 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
 
 if (!policy_service_) {
 #if defined(ENABLE_CONFIGURATION_POLICY)
     std::vector<policy::ConfigurationPolicyProvider*> providers;
     policy_service_.reset(new policy::PolicyServiceImpl(providers));
 #else
     policy_service_.reset(new policy::PolicyServiceStub());
 #endif
   }
   profile_policy_connector_.reset(new policy::ProfilePolicyConnector());
   profile_policy_connector_->InitForTesting(policy_service_.Pass());
   policy::ProfilePolicyConnectorFactory::GetInstance()->SetServiceForTesting(
       this, profile_policy_connector_.get());
   CHECK_EQ(profile_policy_connector_.get(),
            policy::ProfilePolicyConnectorFactory::GetForProfile(this));
 }
 
+void TestingProfile::SetTestingOffTheRecordProfile(Profile* incognito_profile) {

[sky, 2014/09/12 15:33:29]

Is there a reason we need this? Why not have the constructor call
SetOffTheRecordProfile directly?

[tapted, 2014/09/15 05:05:16]

Nope! Removed. I think I had this taking a TestingProfile* at one point, but
that became unnecessary. 

+  DCHECK(!IsOffTheRecord());
+  DCHECK(!incognito_profile_);
+  SetOffTheRecordProfile(make_scoped_ptr(incognito_profile));
+}
+
 PrefService* TestingProfile::GetPrefs() {
-  if (!prefs_.get()) {
-    CreateTestingPrefService();
-  }
+  DCHECK(prefs_);
   return prefs_.get();
 }
 
 history::TopSites* TestingProfile::GetTopSites() {
   return top_sites_.get();
 }
 
 history::TopSites* TestingProfile::GetTopSitesWithoutCreating() {
   return top_sites_.get();
 }
@@ skipping 175 matching lines @@
   return guest_session_;
 }
 
 Profile::ExitType TestingProfile::GetLastSessionExitType() {
   return last_session_exited_cleanly_ ? EXIT_NORMAL : EXIT_CRASHED;
 }
 
 TestingProfile::Builder::Builder()
     : build_called_(false),
       delegate_(NULL),
-      incognito_(false),
       guest_session_(false) {
 }
 
 TestingProfile::Builder::~Builder() {
 }
 
 void TestingProfile::Builder::SetPath(const base::FilePath& path) {
   path_ = path;
 }
 
 void TestingProfile::Builder::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
 #if defined(ENABLE_EXTENSIONS)
 void TestingProfile::Builder::SetExtensionSpecialStoragePolicy(
     scoped_refptr<ExtensionSpecialStoragePolicy> policy) {
   extension_policy_ = policy;
 }
 #endif
 
 void TestingProfile::Builder::SetPrefService(
     scoped_ptr<PrefServiceSyncable> prefs) {
   pref_service_ = prefs.Pass();
 }
 
-void TestingProfile::Builder::SetIncognito() {
-  incognito_ = true;
-}
-
 void TestingProfile::Builder::SetGuestSession() {
   guest_session_ = true;
 }
 
 void TestingProfile::Builder::SetSupervisedUserId(
     const std::string& supervised_user_id) {
   supervised_user_id_ = supervised_user_id;
 }
 
 void TestingProfile::Builder::SetPolicyService(
     scoped_ptr<policy::PolicyService> policy_service) {
   policy_service_ = policy_service.Pass();
 }
 
 void TestingProfile::Builder::AddTestingFactory(
     BrowserContextKeyedServiceFactory* service_factory,
     BrowserContextKeyedServiceFactory::TestingFactoryFunction callback) {
   testing_factories_.push_back(std::make_pair(service_factory, callback));
 }
 
 scoped_ptr<TestingProfile> TestingProfile::Builder::Build() {
   DCHECK(!build_called_);
   build_called_ = true;
 
-  return scoped_ptr<TestingProfile>(new TestingProfile(
-      path_,
-      delegate_,
+  return scoped_ptr<TestingProfile>(new TestingProfile(path_,
+                                                       delegate_,
 #if defined(ENABLE_EXTENSIONS)
-      extension_policy_,
+                                                       extension_policy_,
 #endif
-      pref_service_.Pass(),
-      incognito_,
-      guest_session_,
-      supervised_user_id_,
-      policy_service_.Pass(),
-      testing_factories_));
+                                                       pref_service_.Pass(),
+                                                       NULL,
+                                                       guest_session_,
+                                                       supervised_user_id_,
+                                                       policy_service_.Pass(),
+                                                       testing_factories_));
 }
+
+TestingProfile* TestingProfile::Builder::BuildIncognito(
+    TestingProfile* original_profile) {
+  DCHECK(!build_called_);
+  DCHECK(original_profile);
+  build_called_ = true;
+
+  // Note: Owned by |original_profile|.
+  return new TestingProfile(path_,
+                            delegate_,
+#if defined(ENABLE_EXTENSIONS)
+                            extension_policy_,
+#endif
+                            pref_service_.Pass(),
+                            original_profile,
+                            guest_session_,
+                            supervised_user_id_,
+                            policy_service_.Pass(),
+                            testing_factories_);
+}