gdata: Add GDataFileSystem::ReadDirectoryByPathAsync()

chrome/browser/chromeos/gdata/gdata_file_system_unittest.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 <errno.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 258 matching lines @@
   }
 
   GDataEntry* FindEntryByResourceId(const std::string& resource_id) {
     ReadOnlyFindEntryDelegate search_delegate;
     file_system_->FindEntryByResourceIdSync(resource_id,
                                             &search_delegate);
     return search_delegate.entry();
   }
 
   // Gets the file info for |file_path| and compares the contents against
-  // |entry|. Returns true if the file info matches |entry|.
+  // |file|. Returns true if the file info matches |file|.
   bool GetFileInfoAndCompare(const FilePath& file_path,
-                             GDataEntry* entry) {
+                             GDataFile* file) {
     file_system_->GetFileInfoByPathAsync(
         file_path,
         base::Bind(&CallbackHelper::GetFileInfoCallback,
                    callback_helper_.get()));
     message_loop_.RunAllPending();
 
-    if (entry == NULL) {
+    if (file == NULL) {
       // File info is expected not to be found.
-      return callback_helper_->file_info_ == NULL;
+      return (callback_helper_->last_error_ ==
+              base::PLATFORM_FILE_ERROR_NOT_FOUND &&
+              callback_helper_->file_proto_ == NULL);
     }
 
-    scoped_ptr<GDataFileProto> file_info =
-        callback_helper_->file_info_.Pass();
-    return (entry->resource_id() == file_info->gdata_entry().resource_id());
+    if (callback_helper_->last_error_ != base::PLATFORM_FILE_OK)
+      return false;
+
+    scoped_ptr<GDataFileProto> file_proto =
+        callback_helper_->file_proto_.Pass();
+    return (file->resource_id() == file_proto->gdata_entry().resource_id());
+  }
+
+  // Reads the directory at |file_path| and compares the contents against
+  // |directory|. Returns true if the file info matches |directory|.
+  bool ReadDirectoryAndCompare(const FilePath& file_path,
+                               GDataDirectory* directory) {
+    file_system_->ReadDirectoryByPathAsync(
+        file_path,
+        base::Bind(&CallbackHelper::ReadDirectoryCallback,
+                   callback_helper_.get()));
+    message_loop_.RunAllPending();
+
+    if (directory == NULL) {
+      // Directory is expected not to be found.
+      return (callback_helper_->last_error_ ==
+              base::PLATFORM_FILE_ERROR_NOT_FOUND &&
+              callback_helper_->directory_proto_ == NULL);
+    }
+
+    if (callback_helper_->last_error_ != base::PLATFORM_FILE_OK)
+      return false;
+
+    scoped_ptr<GDataDirectoryProto> directory_proto =
+        callback_helper_->directory_proto_.Pass();
+    return (directory->resource_id() ==
+            directory_proto->gdata_entry().resource_id());
   }
 
   FilePath GetCacheFilePath(
       const std::string& resource_id,
       const std::string& md5,
       GDataRootDirectory::CacheSubDirectoryType sub_dir_type,
       GDataFileSystem::CachedFileOrigin file_origin) {
     return file_system_->GetCacheFilePath(resource_id, md5, sub_dir_type,
                                           file_origin);
   }
@@ skipping 658 matching lines @@
   // This is used as a helper for registering callbacks that need to be
   // RefCountedThreadSafe, and a place where we can fetch results from various
   // operations.
   class CallbackHelper
     : public base::RefCountedThreadSafe<CallbackHelper> {
    public:
     CallbackHelper()
         : last_error_(base::PLATFORM_FILE_OK),
           quota_bytes_total_(0),
           quota_bytes_used_(0),
-          file_info_(NULL) {}
+          file_proto_(NULL) {}
     virtual ~CallbackHelper() {}
+
     virtual void GetFileCallback(base::PlatformFileError error,
                                  const FilePath& file_path,
                                  const std::string& mime_type,
                                  GDataFileType file_type) {
       last_error_ = error;
       download_path_ = file_path;
       mime_type_ = mime_type;
       file_type_ = file_type;
     }
+
     virtual void FileOperationCallback(base::PlatformFileError error) {
       DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
       last_error_ = error;
     }
+
     virtual void GetAvailableSpaceCallback(base::PlatformFileError error,
                                            int64 bytes_total,
                                            int64 bytes_used) {
       last_error_ = error;
       quota_bytes_total_ = bytes_total;
       quota_bytes_used_ = bytes_used;
     }
+
     virtual void GetFileInfoCallback(
         base::PlatformFileError error,
-        scoped_ptr<GDataFileProto> file_info) {
+        scoped_ptr<GDataFileProto> file_proto) {
       last_error_ = error;
-      file_info_ = file_info.Pass();
+      file_proto_ = file_proto.Pass();
+    }
+
+    virtual void ReadDirectoryCallback(
+        base::PlatformFileError error,
+        scoped_ptr<GDataDirectoryProto> directory_proto) {
+      last_error_ = error;
+      directory_proto_ = directory_proto.Pass();
     }
 
     base::PlatformFileError last_error_;
     FilePath download_path_;
     std::string mime_type_;
     GDataFileType file_type_;
     int64 quota_bytes_total_;
     int64 quota_bytes_used_;
-    scoped_ptr<GDataFileProto> file_info_;
+    scoped_ptr<GDataFileProto> file_proto_;
+    scoped_ptr<GDataDirectoryProto> directory_proto_;
   };
 
   MessageLoopForUI message_loop_;
   // The order of the test threads is important, do not change the order.
   // See also content/browser/browser_thread_imple.cc.
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
   scoped_ptr<TestingProfile> profile_;
   scoped_refptr<CallbackHelper> callback_helper_;
   GDataFileSystem* file_system_;
@@ skipping 42 matching lines @@
 
   file_system_->FindEntryByPathAsync(
       FilePath(FILE_PATH_LITERAL("gdata")), callback);
   file_system_->FindEntryByPathAsync(
       FilePath(FILE_PATH_LITERAL("gdata")), callback);
   message_loop_.Run();  // Wait to get our result
   EXPECT_EQ(2, counter);
 }
 
 TEST_F(GDataFileSystemTest, SearchRootDirectory) {
+  LoadRootFeedDocument("root_feed.json");
+
   const FilePath kFilePath = FilePath(FILE_PATH_LITERAL("gdata"));
   GDataEntry* entry = FindEntry(FilePath(FILE_PATH_LITERAL(kFilePath)));
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath, entry->GetFilePath());
+  EXPECT_TRUE(ReadDirectoryAndCompare(kFilePath, entry->AsGDataDirectory()));
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingFile) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("gdata/File 1.txt"));
   GDataEntry* entry = FindEntry(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath, entry->AsGDataFile()));
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("gdata/Document 1.gdoc"));
   GDataEntry* entry = FindEntry(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath, entry->AsGDataFile()));
 }
 
 TEST_F(GDataFileSystemTest, SearchNonExistingFile) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("gdata/nonexisting.file"));
   GDataEntry* entry = FindEntry(kFilePath);
   ASSERT_FALSE(entry);
   EXPECT_TRUE(GetFileInfoAndCompare(kFilePath, NULL));
 }
 
 TEST_F(GDataFileSystemTest, SearchEncodedFileNames) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("gdata/Slash / in file 1.txt"));
   GDataEntry* entry = FindEntry(kFilePath1);
   ASSERT_FALSE(entry);
 
   const FilePath kFilePath2 = FilePath::FromUTF8Unsafe(
       "gdata/Slash \xE2\x88\x95 in file 1.txt");
   entry = FindEntry(kFilePath2);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath2, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath2, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath2, entry->AsGDataFile()));
 
   const FilePath kFilePath3 = FilePath::FromUTF8Unsafe(
       "gdata/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = FindEntry(kFilePath3);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath3, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath3, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath3, entry->AsGDataFile()));
 }
 
 TEST_F(GDataFileSystemTest, SearchEncodedFileNamesLoadingRoot) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("gdata/Slash / in file 1.txt"));
   GDataEntry* entry = FindEntry(kFilePath1);
   ASSERT_FALSE(entry);
 
   const FilePath kFilePath2 = FilePath::FromUTF8Unsafe(
       "gdata/Slash \xE2\x88\x95 in file 1.txt");
   entry = FindEntry(kFilePath2);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath2, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath2, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath2, entry->AsGDataFile()));
 
   const FilePath kFilePath3 = FilePath::FromUTF8Unsafe(
       "gdata/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = FindEntry(kFilePath3);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath3, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath3, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath3, entry->AsGDataFile()));
 }
 
 TEST_F(GDataFileSystemTest, SearchDuplicateNames) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath1 = FilePath(
       FILE_PATH_LITERAL("gdata/Duplicate Name.txt"));
   GDataEntry* entry = FindEntry(kFilePath1);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath1, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath1, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath1, entry->AsGDataFile()));
 
   const FilePath kFilePath2 = FilePath(
       FILE_PATH_LITERAL("gdata/Duplicate Name (2).txt"));
   entry = FindEntry(kFilePath2);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath2, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath2, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath2, entry->AsGDataFile()));
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingDirectory) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("gdata/Directory 1"));
   GDataEntry* entry = FindEntry(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath, entry->GetFilePath());
+  EXPECT_TRUE(ReadDirectoryAndCompare(kFilePath, entry->AsGDataDirectory()));
 }
 
 TEST_F(GDataFileSystemTest, SearchInSubdir) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt"));
   GDataEntry* entry = FindEntry(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath, entry->GetFilePath());
-  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath, entry));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath, entry->AsGDataFile()));
 }
 
 // Check the reconstruction of the directory structure from only the root feed.
 TEST_F(GDataFileSystemTest, SearchInSubSubdir) {
   LoadRootFeedDocument("root_feed.json");
 
   const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("gdata/Directory 1/Sub Directory Folder/"
                         "Sub Sub Directory Folder"));
   GDataEntry* entry = FindEntry(kFilePath);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kFilePath, entry->GetFilePath());
+  EXPECT_TRUE(ReadDirectoryAndCompare(kFilePath, entry->AsGDataDirectory()));
 }
 
 TEST_F(GDataFileSystemTest, FilePathTests) {
   LoadRootFeedDocument("root_feed.json");
 
   FindAndTestFilePath(FilePath(FILE_PATH_LITERAL("gdata/File 1.txt")));
   FindAndTestFilePath(FilePath(FILE_PATH_LITERAL("gdata/Directory 1")));
   FindAndTestFilePath(
       FilePath(FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt")));
 }
@@ skipping 1825 matching lines @@
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Try to remove the file.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 }   // namespace gdata