gdata: Remove use of FindEntryByPathAsync() from gdata_file_system_proxy.cc

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 257 matching lines @@
     EXPECT_EQ(entry->GetFilePath(), file_path);
   }
 
   GDataEntry* FindEntryByResourceId(const std::string& resource_id) {
     ReadOnlyFindEntryDelegate search_delegate;
     file_system_->FindEntryByResourceIdSync(resource_id,
                                             &search_delegate);
     return search_delegate.entry();
   }
 
+  // Gets the entry info for |file_path| and compares the contents against
+  // |entry|. Returns true if the entry info matches |entry|.
+  bool GetEntryInfoAndCompare(const FilePath& file_path,
+                              GDataEntry* entry) {
+    file_system_->GetEntryInfoByPathAsync(
+        file_path,
+        base::Bind(&CallbackHelper::GetEntryInfoCallback,
+                   callback_helper_.get()));
+    message_loop_.RunAllPending();
+
+    if (entry == NULL) {
+      // Entry info is expected not to be found.
+      return (callback_helper_->last_error_ ==
+              base::PLATFORM_FILE_ERROR_NOT_FOUND &&
+              callback_helper_->entry_proto_ == NULL);
+    }
+
+    if (callback_helper_->last_error_ != base::PLATFORM_FILE_OK)
+      return false;
+
+    scoped_ptr<GDataEntryProto> entry_proto =
+        callback_helper_->entry_proto_.Pass();
+    return (entry->resource_id() == entry_proto->resource_id());
+  }
+
   // Gets the file info for |file_path| and compares the contents against
   // |file|. Returns true if the file info matches |file|.
   bool GetFileInfoAndCompare(const FilePath& file_path,
                              GDataFile* file) {
     file_system_->GetFileInfoByPathAsync(
         file_path,
         base::Bind(&CallbackHelper::GetFileInfoCallback,
                    callback_helper_.get()));
     message_loop_.RunAllPending();
 
@@ skipping 734 matching lines @@
     }
 
     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 GetEntryInfoCallback(
+        base::PlatformFileError error,
+        scoped_ptr<GDataEntryProto> entry_proto) {
+      last_error_ = error;
+      entry_proto_ = entry_proto.Pass();
+    }
+
     virtual void GetFileInfoCallback(
         base::PlatformFileError error,
         scoped_ptr<GDataFileProto> file_proto) {
       last_error_ = error;
       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<GDataEntryProto> entry_proto_;
     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_;
@@ skipping 50 matching lines @@
   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(GetEntryInfoAndCompare(kFilePath, entry));
   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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(kFilePath, 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);
+  EXPECT_TRUE(GetEntryInfoAndCompare(kFilePath1, NULL));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath1, NULL));
 
   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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(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);
+  EXPECT_TRUE(GetEntryInfoAndCompare(kFilePath1, NULL));
+  EXPECT_TRUE(GetFileInfoAndCompare(kFilePath1, NULL));
 
   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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(kFilePath, entry));
   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(GetEntryInfoAndCompare(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(GetEntryInfoAndCompare(kFilePath, entry));
   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 1826 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