Wired GDataFileSystem::GetFile() method with internal cache.

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 147 matching lines @@
     GURL unused;
     return file_system_->UpdateDirectoryWithDocumentFeed(
         list, FROM_SERVER) == base::PLATFORM_FILE_OK;
   }
 
   bool RemoveFile(const FilePath& file_path) {
     return file_system_->RemoveFileFromFileSystem(file_path) ==
         base::PLATFORM_FILE_OK;
   }
 
+  FilePath GetCachePathForFile(GDataFile* file) {
+    return file_system_->GetCacheFilePath(
+        file->resource_id(),
+        file->file_md5(),
+        GDataFileSystem::CACHE_TYPE_TMP,
+        GDataFileSystem::CACHED_FILE_FROM_SERVER);
+  }
+
   GDataFileBase* FindFile(const FilePath& file_path) {
     ReadOnlyFindFileDelegate search_delegate;
     file_system_->FindFileByPathSync(file_path, &search_delegate);
     return search_delegate.file();
   }
 
   void FindAndTestFilePath(const FilePath& file_path) {
     GDataFileBase* file = FindFile(file_path);
     ASSERT_TRUE(file) << "File can't be found " << file_path.value();
     EXPECT_EQ(file->GetFilePath(), file_path);
   }
 
   GDataFileBase* FindFileByResource(const std::string& resource) {
     return file_system_->root_->GetFileByResource(resource);
   }
 
   void TestGetCacheFilePath(const std::string& res_id, const std::string& md5,
                             const std::string& expected_filename) {
     FilePath actual_path = file_system_->GetCacheFilePath(
         res_id,
         md5,
         GDataFileSystem::CACHE_TYPE_TMP,
-        false  /* is_local */);
+        GDataFileSystem::CACHED_FILE_FROM_SERVER);
     FilePath expected_path =
         file_system_->cache_paths_[GDataFileSystem::CACHE_TYPE_TMP];
     expected_path = expected_path.Append(expected_filename);
     EXPECT_EQ(expected_path, actual_path);
 
     FilePath base_name = actual_path.BaseName();
 
     // FilePath::Extension returns ".", so strip it.
     std::string unescaped_md5 = GDataFileBase::UnescapeUtf8FileName(
         base_name.Extension().substr(1));
@@ skipping 97 matching lines @@
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     EXPECT_FALSE(file_system_->root_->CacheFileExists(res_id, md5));
 
     // Verify that no files with $res_id.* exist in dir.
     FilePath path = file_system_->GetCacheFilePath(
         res_id,
         "*",
         GDataFileSystem::CACHE_TYPE_TMP,
-        false  /* is_local*/);
+        GDataFileSystem::CACHED_FILE_FROM_SERVER);
     std::string all_res_id = res_id + FilePath::kExtensionSeparator + "*";
     file_util::FileEnumerator traversal(path.DirName(), false,
                                         file_util::FileEnumerator::FILES,
                                         all_res_id);
     EXPECT_TRUE(traversal.Next().empty());
   }
 
   void TestPin(const std::string& res_id, const std::string& md5,
                base::PlatformFileError expected_error) {
     expected_error_ = expected_error;
@@ skipping 79 matching lines @@
     // Determine gdata cache blobs absolute path.
     // Copy files from data dir to cache dir to act as cached files.
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(init_cache_table); ++i) {
       // Copy file from data dir to cache dir, naming it per cache files
       // convention.
       FilePath source_path = GetTestFilePath(init_cache_table[i].source);
       FilePath dest_path = file_system_->GetCacheFilePath(
           init_cache_table[i].resource,
           init_cache_table[i].md5,
           GDataFileSystem::CACHE_TYPE_TMP,
-          false  /* is_local */);
+          GDataFileSystem::CACHED_FILE_FROM_SERVER);
       ASSERT_TRUE(file_util::CopyFile(source_path, dest_path));
 
       // Change mode of cached file.
       struct stat64 stat_buf;
       ASSERT_FALSE(stat64(dest_path.value().c_str(), &stat_buf));
       ASSERT_FALSE(chmod(dest_path.value().c_str(),
                          stat_buf.st_mode |
                              init_cache_table[i].mode_bits_to_enable));
     }
   }
@@ skipping 20 matching lines @@
     // Verify cache map.
     EXPECT_TRUE(file_system_->root_->CacheFileExists(res_id, md5));
     EXPECT_EQ(expected_status_flags,
               file_system_->root_->GetCacheState(res_id, md5));
 
     // Verify file attributes of actual cache file.
     FilePath path = file_system_->GetCacheFilePath(
         res_id,
         md5,
         GDataFileSystem::CACHE_TYPE_TMP,
-        false  /* is_local */);
+        GDataFileSystem::CACHED_FILE_FROM_SERVER);
     struct stat64 stat_buf;
     EXPECT_EQ(0, stat64(path.value().c_str(), &stat_buf));
     EXPECT_TRUE(stat_buf.st_mode & expected_mode_bits);
   }
 
   void RunAllPendingForCache() {
     // Let cache operations run on IO blocking pool.
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     // Let callbacks for cache operations run on UI thread.
     message_loop_.RunAllPending();
@@ skipping 1032 matching lines @@
       false,  // is_exclusive
       true,  // is_recursive
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get()));
   message_loop_.RunAllPending();  // Wait to get our result.
   // TODO(gspencer): Uncomment this when we get a blob that
   // works that can be returned from the mock.
   // EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
 }
 
-TEST_F(GDataFileSystemTest, GetFile) {
+TEST_F(GDataFileSystemTest, GetFileFromDownloads) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
+  FilePath file_in_root(FILE_PATH_LITERAL("gdata/File 1.txt"));
+  GDataFileBase* file_base = FindFile(file_in_root);
+  GDataFile* file = file_base->AsGDataFile();
+  FilePath downloaded_file = GetCachePathForFile(file);
+
   EXPECT_CALL(*mock_doc_service_,
-              DownloadFile(_, GURL("https://file_content_url/"), _));
+              DownloadFile(file_in_root,
+                           downloaded_file,
+                           GURL("https://file_content_url/"),
+                           _))
+      .Times(1);
 
-  FilePath file_in_root(FILE_PATH_LITERAL("gdata/File 1.txt"));
   file_system_->GetFile(file_in_root, callback);
-  message_loop_.RunAllPending();  // Wait to get our result.
+  RunAllPendingForCache();
+
   EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
-  EXPECT_STREQ("file_content_url/",
+  EXPECT_STREQ(downloaded_file.value().c_str(),
                callback_helper_->download_path_.value().c_str());
 }
 
+TEST_F(GDataFileSystemTest, GetFileFromCache) {
+  LoadRootFeedDocument("root_feed.json");
+
+  GetFileCallback callback =
+      base::Bind(&CallbackHelper::GetFileCallback,
+                 callback_helper_.get());
+
+  FilePath file_in_root(FILE_PATH_LITERAL("gdata/File 1.txt"));
+  GDataFileBase* file_base = FindFile(file_in_root);
+  GDataFile* file = file_base->AsGDataFile();
+  FilePath downloaded_file = GetCachePathForFile(file);
+
+  // Store something as cached version of this file.
+  TestStoreToCache(file->resource_id(),
+                   file->file_md5(),
+                   GetTestFilePath("root_feed.json"),
+                   base::PLATFORM_FILE_OK);
+
+  // Make sure we don't call downloads at all.
+  EXPECT_CALL(*mock_doc_service_,
+              DownloadFile(file_in_root,
+                           downloaded_file,
+                           GURL("https://file_content_url/"),
+                           _))
+      .Times(0);
+
+  file_system_->GetFile(file_in_root, callback);
+  RunAllPendingForCache();
+
+  EXPECT_EQ(REGULAR_FILE, callback_helper_->file_type_);
+  EXPECT_STREQ(downloaded_file.value().c_str(),
+               callback_helper_->download_path_.value().c_str());
+}
+
 TEST_F(GDataFileSystemTest, GetFileForHostedDocument) {
   LoadRootFeedDocument("root_feed.json");
 
   GetFileCallback callback =
       base::Bind(&CallbackHelper::GetFileCallback,
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("gdata/Document 1.gdoc"));
   GDataFileBase* file = NULL;
   EXPECT_TRUE((file = FindFile(file_in_root)) != NULL);
@@ skipping 28 matching lines @@
 
   EXPECT_CALL(*mock_doc_service_, GetAccountMetadata(_));
 
   file_system_->GetAvailableSpace(callback);
   message_loop_.RunAllPending();  // Wait to get our result.
   EXPECT_EQ(1234, callback_helper_->quota_bytes_used_);
   EXPECT_EQ(12345, callback_helper_->quota_bytes_total_);
 }
 
 }   // namespace gdata