gdata: Add GDataFileSystem::GetFileInfoByPathAsync().

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 253 matching lines @@
 
   void FindAndTestFilePath(const FilePath& file_path) {
     GDataEntry* entry = FindEntry(file_path);
     ASSERT_TRUE(entry) << "Entry can't be found " << file_path.value();
     EXPECT_EQ(entry->GetFilePath(), file_path);
   }
 
   GDataEntry* FindEntryByResourceId(const std::string& resource_id) {
     ReadOnlyFindEntryDelegate search_delegate;
     file_system_->FindEntryByResourceIdSync(resource_id,
-                                           &search_delegate);
+                                            &search_delegate);
     return search_delegate.entry();
   }
 
+  // Gets the file info for |file_path| and compare the contents against

[Ben Chan, 2012/04/30 18:00:42]

nit: compare -> compares

[satorux1, 2012/04/30 19:47:25]

Done.

+  // |entry|. Returns true if the file info matches |entry|.
+  bool GetFileInfoAndCompare(const FilePath& file_path,
+                             GDataEntry* entry) {
+    file_system_->GetFileInfoByPathAsync(
+        file_path,
+        base::Bind(&CallbackHelper::GetFileInfoCallback,
+                   callback_helper_.get()));
+    message_loop_.RunAllPending();
+
+    if (entry == NULL) {
+      // File info is expected not to be found.
+      return callback_helper_->file_info_ == NULL;
+    }
+
+    scoped_ptr<GDataFileProto> file_info =
+        callback_helper_->file_info_.Pass();
+    return (entry->resource_id() == file_info->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);
   }
 
   // Returns true if the cache entry exists for the given resource ID and MD5.
@@ skipping 655 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) {}
+          quota_bytes_used_(0),
+          file_info_(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) {
+      last_error_ = error;
+      file_info_ = file_info.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_;
   };
 
   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) {
-  EXPECT_TRUE(FindEntry(FilePath(FILE_PATH_LITERAL("gdata"))));
+  const FilePath kFilePath = FilePath(FILE_PATH_LITERAL("gdata"));
+  GDataEntry* entry = FindEntry(FilePath(FILE_PATH_LITERAL(kFilePath)));
+  ASSERT_TRUE(entry);
+  EXPECT_EQ(kFilePath, entry->GetFilePath());
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingFile) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_TRUE(FindEntry(FilePath(FILE_PATH_LITERAL("gdata/File 1.txt"))));
+
+  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));
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingDocument) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_TRUE(FindEntry(FilePath(FILE_PATH_LITERAL("gdata/Document 1.gdoc"))));
+
+  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));
 }
 
 TEST_F(GDataFileSystemTest, SearchNonExistingFile) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_FALSE(
-      FindEntry(FilePath(FILE_PATH_LITERAL("gdata/nonexisting.file"))));
+
+  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");
 
-  EXPECT_FALSE(FindEntry(FilePath(FILE_PATH_LITERAL(
-      "gdata/Slash / in file 1.txt"))));
+  const FilePath kFilePath1 = FilePath(
+      FILE_PATH_LITERAL("gdata/Slash / in file 1.txt"));
+  GDataEntry* entry = FindEntry(kFilePath1);
+  ASSERT_FALSE(entry);
 
-  EXPECT_TRUE(FindEntry(FilePath::FromUTF8Unsafe(
-      "gdata/Slash \xE2\x88\x95 in file 1.txt")));
+  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(FindEntry(FilePath::FromUTF8Unsafe(
-      "gdata/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt")));
+  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));
 }
 
 TEST_F(GDataFileSystemTest, SearchEncodedFileNamesLoadingRoot) {
   LoadRootFeedDocument("root_feed.json");
 
-  EXPECT_FALSE(FindEntry(FilePath(FILE_PATH_LITERAL(
-      "gdata/Slash / in file 1.txt"))));
+  const FilePath kFilePath1 = FilePath(
+      FILE_PATH_LITERAL("gdata/Slash / in file 1.txt"));
+  GDataEntry* entry = FindEntry(kFilePath1);
+  ASSERT_FALSE(entry);
 
-  EXPECT_TRUE(FindEntry(FilePath::FromUTF8Unsafe(
-      "gdata/Slash \xE2\x88\x95 in file 1.txt")));
+  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(FindEntry(FilePath::FromUTF8Unsafe(
-      "gdata/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt")));
+  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));
 }
 
 TEST_F(GDataFileSystemTest, SearchDuplicateNames) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_TRUE(FindEntry(FilePath(
-      FILE_PATH_LITERAL("gdata/Duplicate Name.txt"))));
-  EXPECT_TRUE(FindEntry(FilePath(
-      FILE_PATH_LITERAL("gdata/Duplicate Name (2).txt"))));
+
+  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));
+
+  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));
 }
 
 TEST_F(GDataFileSystemTest, SearchExistingDirectory) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_TRUE(FindEntry(FilePath(
-      FILE_PATH_LITERAL("gdata/Directory 1"))));
+
+  const FilePath kFilePath = FilePath(
+      FILE_PATH_LITERAL("gdata/Directory 1"));
+  GDataEntry* entry = FindEntry(kFilePath);
+  ASSERT_TRUE(entry);
+  EXPECT_EQ(kFilePath, entry->GetFilePath());
 }
 
 TEST_F(GDataFileSystemTest, SearchInSubdir) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_TRUE(FindEntry(FilePath(
-      FILE_PATH_LITERAL("gdata/Directory 1/SubDirectory File 1.txt"))));
+
+  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));
 }
 
 // Check the reconstruction of the directory structure from only the root feed.
 TEST_F(GDataFileSystemTest, SearchInSubSubdir) {
   LoadRootFeedDocument("root_feed.json");
-  EXPECT_TRUE(FindEntry(FilePath(
+
+  const FilePath kFilePath = FilePath(
       FILE_PATH_LITERAL("gdata/Directory 1/Sub Directory Folder/"
-                        "Sub Sub Directory Folder"))));
+                        "Sub Sub Directory Folder"));
+  GDataEntry* entry = FindEntry(kFilePath);
+  ASSERT_TRUE(entry);
+  EXPECT_EQ(kFilePath, entry->GetFilePath());
 }
 
 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