[fsp] Add the getMetadata operation.

chrome/browser/chromeos/file_system_provider/fileapi/provider_async_file_util_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 <string>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/platform_file.h"
+#include "base/run_loop.h"
+#include "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/fileapi/provider_async_file_util.h"
-#include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
+#include "chrome/browser/chromeos/file_system_provider/service.h"
+#include "chrome/browser/chromeos/file_system_provider/service_factory.h"
+#include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_file_system_context.h"
+#include "extensions/browser/extension_registry.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/async_file_util.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
-const int kFileSystemId = 1;
 
 // Logs callbacks invocations on the tested operations.
 // TODO(mtomasz): Store and verify more arguments, once the operations return
 // anything else than just an error.
 class EventLogger {
  public:
   EventLogger() : weak_ptr_factory_(this) {}
   virtual ~EventLogger() {}
 
   void OnStatus(base::File::Error error) {
@@ skipping 37 matching lines @@
 
   base::File::Error* error() { return error_.get(); }
 
  private:
   scoped_ptr<base::File::Error> error_;
   base::WeakPtrFactory<EventLogger> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(EventLogger);
 };
 
-// Registers an external mount point, and removes it once the object gets out
-// of scope. To ensure that creating the mount point succeeded, call is_valid().
-class ScopedExternalMountPoint {
- public:
-  ScopedExternalMountPoint(const std::string& mount_point_name,
-                           const base::FilePath& mount_path,
-                           fileapi::FileSystemType type)
-      : mount_point_name_(mount_point_name) {
-    fileapi::ExternalMountPoints* const mount_points =
-        fileapi::ExternalMountPoints::GetSystemInstance();
-    DCHECK(mount_points);
-    is_valid_ =
-        mount_points->RegisterFileSystem(mount_point_name,
-                                         fileapi::kFileSystemTypeProvided,
-                                         fileapi::FileSystemMountOption(),
-                                         mount_path);
-  }
-
-  virtual ~ScopedExternalMountPoint() {
-    if (!is_valid_)
-      return;
-
-    // If successfully registered in the constructor, then unregister.
-    fileapi::ExternalMountPoints* const mount_points =
-        fileapi::ExternalMountPoints::GetSystemInstance();
-    DCHECK(mount_points);
-    mount_points->RevokeFileSystem(mount_point_name_);
-  }
-
-  bool is_valid() { return is_valid_; }
-
- private:
-  const std::string mount_point_name_;
-  bool is_valid_;
-};
-
 // Creates a cracked FileSystemURL for tests.
 fileapi::FileSystemURL CreateFileSystemURL(const std::string& mount_point_name,
                                            const base::FilePath& file_path) {
   const std::string origin = std::string("chrome-extension://") + kExtensionId;
   const fileapi::ExternalMountPoints* const mount_points =
       fileapi::ExternalMountPoints::GetSystemInstance();
   return mount_points->CreateCrackedFileSystemURL(
       GURL(origin),
       fileapi::kFileSystemTypeExternal,
       base::FilePath::FromUTF8Unsafe(mount_point_name).Append(file_path));
 }
 
+// Creates a Service instance. Used to be able to destroy the service in
+// TearDown().
+KeyedService* CreateService(content::BrowserContext* context) {
+  return new Service(Profile::FromBrowserContext(context),
+                     extensions::ExtensionRegistry::Get(context));
+}
+
 }  // namespace
 
 // Tests in this file are very lightweight and just test integration between
 // AsyncFileUtil and ProvideFileSystemInterface. Currently it tests if not
 // implemented operations return a correct error code. For not allowed
 // operations it is FILE_ERROR_SECURITY, and for not implemented the error is
 // FILE_ERROR_NOT_FOUND.
 class FileSystemProviderProviderAsyncFileUtilTest : public testing::Test {
  protected:
   FileSystemProviderProviderAsyncFileUtilTest() {}
   virtual ~FileSystemProviderProviderAsyncFileUtilTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
-    profile_.reset(new TestingProfile);
+    profile_manager_.reset(
+        new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
+    ASSERT_TRUE(profile_manager_->SetUp());
+    profile_ = profile_manager_->CreateTestingProfile("testing-profile");
     async_file_util_.reset(new internal::ProviderAsyncFileUtil);
-    const base::FilePath mount_path =
-        util::GetMountPath(profile_.get(), kExtensionId, kFileSystemId);
+
     file_system_context_ =
         content::CreateFileSystemContextForTesting(NULL, data_dir_.path());
 
-    const std::string mount_point_name = mount_path.BaseName().AsUTF8Unsafe();
-    mount_point_.reset(new ScopedExternalMountPoint(
-        mount_point_name, mount_path, fileapi::kFileSystemTypeProvided));
-    ASSERT_TRUE(mount_point_->is_valid());
+    ServiceFactory::GetInstance()->SetTestingFactory(profile_, &CreateService);
+    Service* service = Service::Get(profile_);  // Owned by its factory.
+    service->SetFileSystemFactoryForTests(
+        base::Bind(&FakeProvidedFileSystem::Create));
+
+    const int file_system_id =
+        service->MountFileSystem(kExtensionId, "testing-file-system");
+    ASSERT_LT(0, file_system_id);
+    const ProvidedFileSystemInfo& file_system_info =
+        service->GetProvidedFileSystem(kExtensionId, file_system_id)
+            ->GetFileSystemInfo();
+    const std::string mount_point_name =
+        file_system_info.mount_path().BaseName().AsUTF8Unsafe();
 
     file_url_ = CreateFileSystemURL(
         mount_point_name, base::FilePath::FromUTF8Unsafe("hello/world.txt"));
     ASSERT_TRUE(file_url_.is_valid());
     directory_url_ = CreateFileSystemURL(
         mount_point_name, base::FilePath::FromUTF8Unsafe("hello"));
     ASSERT_TRUE(directory_url_.is_valid());
     root_url_ = CreateFileSystemURL(mount_point_name, base::FilePath());
     ASSERT_TRUE(root_url_.is_valid());
   }
 
+  virtual void TearDown() OVERRIDE {
+    // Setting the testing factory to NULL will destroy the created service
+    // associated with the testing profile.
+    ServiceFactory::GetInstance()->SetTestingFactory(profile_, NULL);
+  }
+
   scoped_ptr<fileapi::FileSystemOperationContext> CreateOperationContext() {
     return make_scoped_ptr(
         new fileapi::FileSystemOperationContext(file_system_context_.get()));
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir data_dir_;
-  scoped_ptr<TestingProfile> profile_;
+  scoped_ptr<TestingProfileManager> profile_manager_;
+  TestingProfile* profile_;  // Owned by TestingProfileManager.
   scoped_ptr<fileapi::AsyncFileUtil> async_file_util_;
   scoped_refptr<fileapi::FileSystemContext> file_system_context_;
-  scoped_ptr<ScopedExternalMountPoint> mount_point_;
   fileapi::FileSystemURL file_url_;
   fileapi::FileSystemURL directory_url_;
   fileapi::FileSystemURL root_url_;
 };
 
 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, CreateOrOpen_Create) {
   EventLogger logger;
 
   async_file_util_->CreateOrOpen(
       CreateOperationContext(),
@@ skipping 82 matching lines @@
 
   ASSERT_TRUE(logger.error());
   EXPECT_EQ(base::File::FILE_ERROR_SECURITY, *logger.error());
 }
 
 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, GetFileInfo) {
   EventLogger logger;
 
   async_file_util_->GetFileInfo(
       CreateOperationContext(),
-      file_url_,
+      root_url_,
       base::Bind(&EventLogger::OnGetFileInfo, logger.GetWeakPtr()));
+  base::RunLoop().RunUntilIdle();
 
   ASSERT_TRUE(logger.error());
-  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error());
+  EXPECT_EQ(base::File::FILE_OK, *logger.error());
 }
 
 TEST_F(FileSystemProviderProviderAsyncFileUtilTest, ReadDirectory) {
   EventLogger logger;
 
   async_file_util_->ReadDirectory(
       CreateOperationContext(),
       root_url_,
       base::Bind(&EventLogger::OnReadDirectory, logger.GetWeakPtr()));
 
@@ skipping 113 matching lines @@
       CreateOperationContext(),
       file_url_,
       base::Bind(&EventLogger::OnCreateSnapshotFile, logger.GetWeakPtr()));
 
   ASSERT_TRUE(logger.error());
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, *logger.error());
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos