Add oem mount point to cros_mount_provider.

chrome/browser/chromeos/extensions/external_filesystem_apitest.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 "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
@@ skipping 25 matching lines @@
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 
 using ::testing::_;
 using ::testing::Return;
 using content::BrowserContext;
 
 namespace {
 
 // These should match the counterparts in remote.js.
 // Also, the size of the file in |kTestRootFeed| has to be set to
-// |size(kTestFileContents)|.
-const char kTestFileContents[] = "hello, world";
+// length of kTestFileContent string.
+const char kTestFileContent[] = "hello, world!";
 
 // Contains a folder entry for the folder 'Folder' that will be 'created'.
 const char kTestDirectory[] = "new_folder_entry.json";
 
 // Contains a folder named Folder that has a file File.aBc inside of it.
 const char kTestRootFeed[] = "remote_file_system_apitest_root_feed.json";
 
 // Contains metadata of the  document that will be "downloaded" in test.
 const char kTestDocumentToDownloadEntry[] =
     "remote_file_system_apitest_document_to_download.json";
@@ skipping 71 matching lines @@
       base::Bind(arg4, status, base::Passed(value)));
 }
 
 // Action used to mock expectations fo GetDocumentEntry.
 ACTION_P2(MockGetDocumentEntryCallback, status, value) {
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg1, status, base::Passed(value)));
 }
 
 // Creates a cache representation of the test file with predetermined content.
-void CreateDownloadFile(const FilePath& path) {
-  int file_content_size = static_cast<int>(sizeof(kTestFileContents));
-  ASSERT_EQ(file_content_size,
-            file_util::WriteFile(path, kTestFileContents, file_content_size));
+void CreateFileWithContent(const FilePath& path, const std::string& content) {
+  int content_size = static_cast<int>(content.length());
+  ASSERT_EQ(content_size,
+            file_util::WriteFile(path, content.c_str(), content_size));
 }
 
 // Action used to set mock expectations for DownloadFile().
 ACTION_P(MockDownloadFileCallback, status) {
   ASSERT_TRUE(content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::FILE,
       FROM_HERE,
-      base::Bind(&CreateDownloadFile, arg1),
+      base::Bind(&CreateFileWithContent, arg1, kTestFileContent),
       base::Bind(arg3, status, arg2, arg1)));
 }
 
 }  // namespace
 
 class FileSystemExtensionApiTest : public ExtensionApiTest {
  public:
   FileSystemExtensionApiTest() : test_mount_point_("/tmp") {
   }
 
@@ skipping 21 matching lines @@
     const extensions::Extension* extension = LoadExtension(extdir);
     if (extension)
       page_complete.WaitUntilClosed();
     return extension;
   }
 
  private:
   FilePath test_mount_point_;
 };
 
+class RestrictedFileSystemExtensionApiTest : public ExtensionApiTest {
+ public:
+  RestrictedFileSystemExtensionApiTest() {}
+
+  virtual ~RestrictedFileSystemExtensionApiTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    FilePath tmp_path;
+    PathService::Get(base::DIR_TEMP, &tmp_path);
+    ASSERT_TRUE(tmp_dir_.CreateUniqueTempDirUnderPath(tmp_path));
+    mount_point_dir_ = tmp_dir_.path().Append("mount");
+    // Create the mount point.
+    file_util::CreateDirectory(mount_point_dir_);
+
+    FilePath test_dir = mount_point_dir_.Append("test_dir");
+    file_util::CreateDirectory(test_dir);
+
+    FilePath test_file = test_dir.AppendASCII("test_file.foo");
+    CreateFileWithContent(test_file, kTestFileContent);
+
+    test_file = test_dir.AppendASCII("mutable_test_file.foo");
+    CreateFileWithContent(test_file, kTestFileContent);
+
+    test_file = test_dir.AppendASCII("test_file_to_delete.foo");
+    CreateFileWithContent(test_file, kTestFileContent);
+
+    test_file = test_dir.AppendASCII("test_file_to_move.foo");
+    CreateFileWithContent(test_file, kTestFileContent);
+
+    // Create test files.
+    ExtensionApiTest::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    ExtensionApiTest::TearDown();
+  }
+
+  void AddRestrictedMountPoint() {
+    fileapi::ExternalFileSystemMountPointProvider* provider =
+        BrowserContext::GetDefaultStoragePartition(
+            browser()->profile())->GetFileSystemContext()->external_provider();
+    provider->AddRestrictedLocalMountPoint(mount_point_dir_);
+  }
+
+ protected:
+  ScopedTempDir tmp_dir_;
+  FilePath mount_point_dir_;
+};
+
+
 class RemoteFileSystemExtensionApiTest : public ExtensionApiTest {
  public:
   RemoteFileSystemExtensionApiTest() {}
 
   virtual ~RemoteFileSystemExtensionApiTest() {}
 
   virtual void SetUp() OVERRIDE {
     // Set up cache root and documents service to be used when creating gdata
     // system service. This has to be done early on (before the browser is
     // created) because the system service instance is initialized very early
@@ skipping 47 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(FileSystemExtensionApiTest, FileBrowserWebIntentTest) {
   AddTmpMountPoint();
 
   ResultCatcher catcher;
   ScopedTempDir tmp_dir;
   ASSERT_TRUE(tmp_dir.CreateUniqueTempDir());
 
   // Create a test file inside the ScopedTempDir.
   FilePath test_file = tmp_dir.path().AppendASCII("text_file.xul");
-  CreateDownloadFile(test_file);
+  CreateFileWithContent(test_file, kTestFileContent);
 
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("webintent_handler"))) << message_;
 
   // Load the source component, with the fileUrl within the virtual mount
   // point.
   const extensions::Extension* extension = LoadExtensionAsComponent(
       test_data_dir_.AppendASCII("filebrowser_component"));
   ASSERT_TRUE(extension) << message_;
   std::string path = "filesystem:chrome-extension://" + extension->id() +
@@ skipping 23 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(FileSystemExtensionApiTest,
                        FileBrowserTestWriteComponent) {
   AddTmpMountPoint();
   ASSERT_TRUE(RunComponentExtensionTest("filesystem_handler_write"))
       << message_;
   ASSERT_TRUE(RunExtensionSubtest(
       "filebrowser_component", "write.html", kComponentFlags)) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(RestrictedFileSystemExtensionApiTest, Basic) {
+  AddRestrictedMountPoint();
+  ASSERT_TRUE(RunExtensionSubtest(
+      "filebrowser_component", "restricted.html", kComponentFlags)) << message_;
+}
+
 IN_PROC_BROWSER_TEST_F(RemoteFileSystemExtensionApiTest,
                        RemoteMountPoint) {
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
 
   // First, file browser will try to create new directory.
   scoped_ptr<base::Value> dir_value(LoadJSONFile(kTestDirectory));
   EXPECT_CALL(*mock_drive_service_,
               CreateDirectory(_, _, _))
       .WillOnce(MockCreateDirectoryCallback(gdata::HTTP_SUCCESS, &dir_value));
 
@@ skipping 67 matching lines @@
                            _, _))
       .WillOnce(MockDownloadFileCallback(gdata::HTTP_SUCCESS));
 
   // On exit, all operations in progress should be cancelled.
   EXPECT_CALL(*mock_drive_service_, CancelAll());
 
   // All is set... RUN THE TEST.
   EXPECT_TRUE(RunExtensionSubtest("filebrowser_component", "remote_search.html",
       kComponentFlags)) << message_;
 }