[fsp] Add support for reading directories.

chrome/browser/chromeos/file_system_provider/operations/read_directory_unittest.cc

Index: chrome/browser/chromeos/file_system_provider/operations/read_directory_unittest.cc
diff --git a/chrome/browser/chromeos/file_system_provider/operations/get_metadata_unittest.cc b/chrome/browser/chromeos/file_system_provider/operations/read_directory_unittest.cc
similarity index 60%
copy from chrome/browser/chromeos/file_system_provider/operations/get_metadata_unittest.cc
copy to chrome/browser/chromeos/file_system_provider/operations/read_directory_unittest.cc
index 4b091ac3a0d97f680cc2b6bbd57eac8eeecc6cdb..1158ddf129118bba5ac6513a2352bf52579676f9 100644
--- a/chrome/browser/chromeos/file_system_provider/operations/get_metadata_unittest.cc
+++ b/chrome/browser/chromeos/file_system_provider/operations/read_directory_unittest.cc
@@ -9,7 +9,7 @@
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
-#include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h"
+#include "chrome/browser/chromeos/file_system_provider/operations/read_directory.h"
 #include "chrome/common/extensions/api/file_system_provider.h"
 #include "chrome/common/extensions/api/file_system_provider_internal.h"
 #include "extensions/browser/event_router.h"
@@ -53,16 +53,22 @@ class CallbackLogger {
  public:
   class Event {
    public:
-    Event(base::File::Error result, const base::File::Info& file_info)
-        : result_(result), file_info_(file_info) {}
+    Event(base::File::Error result,
+          const fileapi::AsyncFileUtil::EntryList& entry_list,
+          bool has_more)
+        : result_(result), entry_list_(entry_list), has_more_(has_more) {}
     virtual ~Event() {}
 
     base::File::Error result() { return result_; }
-    const base::File::Info& file_info() { return file_info_; }
+    const fileapi::AsyncFileUtil::EntryList& entry_list() {
+      return entry_list_;
+    }
+    bool has_more() { return has_more_; }
 
    private:
     base::File::Error result_;
-    base::File::Info file_info_;
+    fileapi::AsyncFileUtil::EntryList entry_list_;
+    bool has_more_;
 
     DISALLOW_COPY_AND_ASSIGN(Event);
   };
@@ -70,9 +76,10 @@ class CallbackLogger {
   CallbackLogger() : weak_ptr_factory_(this) {}
   virtual ~CallbackLogger() {}
 
-  void OnGetMetadata(base::File::Error result,
-                     const base::File::Info& file_info) {
-    events_.push_back(new Event(result, file_info));
+  void OnReadDirectory(base::File::Error result,
+                       const fileapi::AsyncFileUtil::EntryList& entry_list,
+                       bool has_more) {
+    events_.push_back(new Event(result, entry_list, has_more));
   }
 
   ScopedVector<Event>& events() { return events_; }
@@ -91,10 +98,10 @@ class CallbackLogger {
 
 }  // namespace
 
-class FileSystemProviderOperationsGetMetadataTest : public testing::Test {
+class FileSystemProviderOperationsReadDirectoryTest : public testing::Test {
  protected:
-  FileSystemProviderOperationsGetMetadataTest() {}
-  virtual ~FileSystemProviderOperationsGetMetadataTest() {}
+  FileSystemProviderOperationsReadDirectoryTest() {}
+  virtual ~FileSystemProviderOperationsReadDirectoryTest() {}
 
   virtual void SetUp() OVERRIDE {
     file_system_info_ =
@@ -107,26 +114,26 @@ class FileSystemProviderOperationsGetMetadataTest : public testing::Test {
   ProvidedFileSystemInfo file_system_info_;
 };
 
-TEST_F(FileSystemProviderOperationsGetMetadataTest, Execute) {
+TEST_F(FileSystemProviderOperationsReadDirectoryTest, Execute) {
   LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
   CallbackLogger callback_logger;
 
-  GetMetadata get_metadata(
-      NULL,
-      file_system_info_,
-      base::FilePath::FromUTF8Unsafe(kDirectoryPath),
-      base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr()));
-  get_metadata.SetDispatchEventImplForTesting(
+  ReadDirectory read_directory(NULL,
+                               file_system_info_,
+                               base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+                               base::Bind(&CallbackLogger::OnReadDirectory,
+                                          callback_logger.GetWeakPtr()));
+  read_directory.SetDispatchEventImplForTesting(
       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
                  base::Unretained(&dispatcher)));
 
-  EXPECT_TRUE(get_metadata.Execute(kRequestId));
+  EXPECT_TRUE(read_directory.Execute(kRequestId));
 
   ASSERT_EQ(1u, dispatcher.events().size());
   extensions::Event* event = dispatcher.events()[0];
-  EXPECT_EQ(
-      extensions::api::file_system_provider::OnGetMetadataRequested::kEventName,
-      event->event_name);
+  EXPECT_EQ(extensions::api::file_system_provider::OnReadDirectoryRequested::
+                kEventName,
+            event->event_name);
   base::ListValue* event_args = event->event_args.get();
   ASSERT_EQ(3u, event_args->GetSize());
 
@@ -143,40 +150,40 @@ TEST_F(FileSystemProviderOperationsGetMetadataTest, Execute) {
   EXPECT_EQ(kDirectoryPath, event_directory_path);
 }
 
-TEST_F(FileSystemProviderOperationsGetMetadataTest, Execute_NoListener) {
+TEST_F(FileSystemProviderOperationsReadDirectoryTest, Execute_NoListener) {
   LoggingDispatchEventImpl dispatcher(false /* dispatch_reply */);
   CallbackLogger callback_logger;
 
-  GetMetadata get_metadata(
-      NULL,
-      file_system_info_,
-      base::FilePath::FromUTF8Unsafe(kDirectoryPath),
-      base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr()));
-  get_metadata.SetDispatchEventImplForTesting(
+  ReadDirectory read_directory(NULL,
+                               file_system_info_,
+                               base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+                               base::Bind(&CallbackLogger::OnReadDirectory,
+                                          callback_logger.GetWeakPtr()));
+  read_directory.SetDispatchEventImplForTesting(
       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
                  base::Unretained(&dispatcher)));
 
-  EXPECT_FALSE(get_metadata.Execute(kRequestId));
+  EXPECT_FALSE(read_directory.Execute(kRequestId));
 }
 
-TEST_F(FileSystemProviderOperationsGetMetadataTest, OnSuccess) {
+TEST_F(FileSystemProviderOperationsReadDirectoryTest, OnSuccess) {
   using extensions::api::file_system_provider::EntryMetadata;
   using extensions::api::file_system_provider_internal::
-      GetMetadataRequestedSuccess::Params;
+      ReadDirectoryRequestedSuccess::Params;
 
   LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
   CallbackLogger callback_logger;
 
-  GetMetadata get_metadata(
-      NULL,
-      file_system_info_,
-      base::FilePath::FromUTF8Unsafe(kDirectoryPath),
-      base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr()));
-  get_metadata.SetDispatchEventImplForTesting(
+  ReadDirectory read_directory(NULL,
+                               file_system_info_,
+                               base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+                               base::Bind(&CallbackLogger::OnReadDirectory,
+                                          callback_logger.GetWeakPtr()));
+  read_directory.SetDispatchEventImplForTesting(
       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
                  base::Unretained(&dispatcher)));
 
-  EXPECT_TRUE(get_metadata.Execute(kRequestId));
+  EXPECT_TRUE(read_directory.Execute(kRequestId));
 
   // Sample input as JSON. Keep in sync with file_system_provider_api.idl.
   // As for now, it is impossible to create *::Params class directly, not from
@@ -185,14 +192,17 @@ TEST_F(FileSystemProviderOperationsGetMetadataTest, OnSuccess) {
       "[\n"
       "  1,\n"  // kFileSystemId
       "  2,\n"  // kRequestId
-      "  {\n"
-      "    \"isDirectory\": false,\n"
-      "    \"name\": \"blueberries.txt\",\n"
-      "    \"size\": 4096,\n"
-      "    \"modificationTime\": {\n"
-      "      \"value\": \"Thu Apr 24 00:46:52 UTC 2014\"\n"
+      "  [\n"
+      "    {\n"
+      "      \"isDirectory\": false,\n"
+      "      \"name\": \"blueberries.txt\",\n"
+      "      \"size\": 4096,\n"
+      "      \"modificationTime\": {\n"
+      "        \"value\": \"Thu Apr 24 00:46:52 UTC 2014\"\n"
+      "      }\n"
       "    }\n"
-      "  }\n"
+      "  ],\n"
+      "  false\n"  // has_next
       "]\n";
 
   int json_error_code;
@@ -206,49 +216,52 @@ TEST_F(FileSystemProviderOperationsGetMetadataTest, OnSuccess) {
   scoped_ptr<Params> params(Params::Create(*value_as_list));
   ASSERT_TRUE(params.get());
   scoped_ptr<RequestValue> request_value(
-      RequestValue::CreateForGetMetadataSuccess(params.Pass()));
+      RequestValue::CreateForReadDirectorySuccess(params.Pass()));
   ASSERT_TRUE(request_value.get());
 
   const bool has_next = false;
-  get_metadata.OnSuccess(kRequestId, request_value.Pass(), has_next);
+  read_directory.OnSuccess(kRequestId, request_value.Pass(), has_next);
 
   ASSERT_EQ(1u, callback_logger.events().size());
   CallbackLogger::Event* event = callback_logger.events()[0];
   EXPECT_EQ(base::File::FILE_OK, event->result());
 
-  const base::File::Info& file_info = event->file_info();
-  EXPECT_FALSE(file_info.is_directory);
-  EXPECT_EQ(4096, file_info.size);
+  ASSERT_EQ(1u, event->entry_list().size());
+  const fileapi::DirectoryEntry entry = event->entry_list()[0];
+  EXPECT_FALSE(entry.is_directory);
+  EXPECT_EQ("blueberries.txt", entry.name);
+  EXPECT_EQ(4096, entry.size);
   base::Time expected_time;
   EXPECT_TRUE(
       base::Time::FromString("Thu Apr 24 00:46:52 UTC 2014", &expected_time));
-  EXPECT_EQ(expected_time, file_info.last_modified);
+  EXPECT_EQ(expected_time, entry.last_modified_time);
 }
 
-TEST_F(FileSystemProviderOperationsGetMetadataTest, OnError) {
+TEST_F(FileSystemProviderOperationsReadDirectoryTest, OnError) {
   using extensions::api::file_system_provider::EntryMetadata;
   using extensions::api::file_system_provider_internal::
-      GetMetadataRequestedError::Params;
+      ReadDirectoryRequestedSuccess::Params;
 
   LoggingDispatchEventImpl dispatcher(true /* dispatch_reply */);
   CallbackLogger callback_logger;
 
-  GetMetadata get_metadata(
-      NULL,
-      file_system_info_,
-      base::FilePath::FromUTF8Unsafe(kDirectoryPath),
-      base::Bind(&CallbackLogger::OnGetMetadata, callback_logger.GetWeakPtr()));
-  get_metadata.SetDispatchEventImplForTesting(
+  ReadDirectory read_directory(NULL,
+                               file_system_info_,
+                               base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+                               base::Bind(&CallbackLogger::OnReadDirectory,
+                                          callback_logger.GetWeakPtr()));
+  read_directory.SetDispatchEventImplForTesting(
       base::Bind(&LoggingDispatchEventImpl::OnDispatchEventImpl,
                  base::Unretained(&dispatcher)));
 
-  EXPECT_TRUE(get_metadata.Execute(kRequestId));
+  EXPECT_TRUE(read_directory.Execute(kRequestId));
 
-  get_metadata.OnError(kRequestId, base::File::FILE_ERROR_TOO_MANY_OPENED);
+  read_directory.OnError(kRequestId, base::File::FILE_ERROR_TOO_MANY_OPENED);
 
   ASSERT_EQ(1u, callback_logger.events().size());
   CallbackLogger::Event* event = callback_logger.events()[0];
   EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, event->result());
+  ASSERT_EQ(0u, event->entry_list().size());
 }
 
 }  // namespace operations