ProfileManager doesn't depend on "--login-profile" switch.

chrome/browser/chromeos/file_system_provider/service_unittest.cc

 // Copyright 2014 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/browser/chromeos/file_system_provider/service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 
 namespace chromeos {
 namespace file_system_provider {
@@ skipping 84 matching lines @@
   file_systems->SetWithoutPathExpansion(kFileSystemId, file_system);
   extensions.SetWithoutPathExpansion(kExtensionId, file_systems);
 
   pref_service->Set(prefs::kFileSystemProviderMounted, extensions);
 }
 
 }  // namespace
 
 class FileSystemProviderServiceTest : public testing::Test {
  protected:
-  FileSystemProviderServiceTest() {}
+  FileSystemProviderServiceTest() : profile_(NULL) {}
+
   virtual ~FileSystemProviderServiceTest() {}
 
   virtual void SetUp() OVERRIDE {
-    profile_.reset(new TestingProfile);
+    profile_manager_.reset(
+        new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
+    ASSERT_TRUE(profile_manager_->SetUp());
+    profile_ = profile_manager_->CreateTestingProfile("test-user@example.com");
     user_manager_ = new FakeUserManager();
     user_manager_->AddUser(profile_->GetProfileName());
     user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_));
-    extension_registry_.reset(
-        new extensions::ExtensionRegistry(profile_.get()));
-    service_.reset(new Service(profile_.get(), extension_registry_.get()));
+    extension_registry_.reset(new extensions::ExtensionRegistry(profile_));
+    service_.reset(new Service(profile_, extension_registry_.get()));
     service_->SetFileSystemFactoryForTesting(
         base::Bind(&FakeProvidedFileSystem::Create));
     extension_ = createFakeExtension(kExtensionId);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_ptr<TestingProfile> profile_;
+  scoped_ptr<TestingProfileManager> profile_manager_;
+  TestingProfile* profile_;
   FakeUserManager* user_manager_;
   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
   scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
   scoped_ptr<Service> service_;
   scoped_refptr<extensions::Extension> extension_;
 };
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   EXPECT_TRUE(service_->MountFileSystem(
       kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
 
   ASSERT_EQ(1u, observer.mounts.size());
   EXPECT_EQ(kExtensionId, observer.mounts[0].file_system_info().extension_id());
   EXPECT_EQ(kFileSystemId,
             observer.mounts[0].file_system_info().file_system_id());
   base::FilePath expected_mount_path =
-      util::GetMountPath(profile_.get(), kExtensionId, kFileSystemId);
+      util::GetMountPath(profile_, kExtensionId, kFileSystemId);
   EXPECT_EQ(expected_mount_path.AsUTF8Unsafe(),
             observer.mounts[0].file_system_info().mount_path().AsUTF8Unsafe());
   EXPECT_EQ(kDisplayName, observer.mounts[0].file_system_info().display_name());
   EXPECT_FALSE(observer.mounts[0].file_system_info().writable());
   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
   ASSERT_EQ(0u, observer.unmounts.size());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
@@ skipping 94 matching lines @@
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_OnExtensionUnload) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   EXPECT_TRUE(service_->MountFileSystem(
       kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
   ASSERT_EQ(1u, observer.mounts.size());
 
   // Directly call the observer's method.
   service_->OnExtensionUnloaded(
-      profile_.get(),
+      profile_,
       extension_.get(),
       extensions::UnloadedExtensionInfo::REASON_DISABLE);
 
   ASSERT_EQ(1u, observer.unmounts.size());
   EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
 
   EXPECT_EQ(kExtensionId,
             observer.unmounts[0].file_system_info().extension_id());
   EXPECT_EQ(kFileSystemId,
             observer.unmounts[0].file_system_info().file_system_id());
@@ skipping 24 matching lines @@
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, RestoreFileSystem_OnExtensionLoad) {
   // Create a fake entry in the preferences.
-  RememberFakeFileSystem(profile_.get(),
-                         kExtensionId,
-                         kFileSystemId,
-                         kDisplayName,
-                         true /* writable */);
+  RememberFakeFileSystem(
+      profile_, kExtensionId, kFileSystemId, kDisplayName, true /* writable */);
 
   // Create a new service instance in order to load remembered file systems
   // from preferences.
   scoped_ptr<Service> new_service(
-      new Service(profile_.get(), extension_registry_.get()));
+      new Service(profile_, extension_registry_.get()));
   LoggingObserver observer;
   new_service->AddObserver(&observer);
 
   new_service->SetFileSystemFactoryForTesting(
       base::Bind(&FakeProvidedFileSystem::Create));
 
   EXPECT_EQ(0u, observer.mounts.size());
 
   // Directly call the observer's method.
-  new_service->OnExtensionLoaded(profile_.get(), extension_.get());
+  new_service->OnExtensionLoaded(profile_, extension_.get());
 
   ASSERT_EQ(1u, observer.mounts.size());
   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
 
   EXPECT_EQ(kExtensionId, observer.mounts[0].file_system_info().extension_id());
   EXPECT_EQ(kFileSystemId,
             observer.mounts[0].file_system_info().file_system_id());
   EXPECT_TRUE(observer.mounts[0].file_system_info().writable());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
@@ skipping 122 matching lines @@
     const base::DictionaryValue* file_systems = NULL;
     EXPECT_FALSE(extensions->GetDictionaryWithoutPathExpansion(kExtensionId,
                                                                &file_systems));
   }
 
   service_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos