Drive: Removes unused cache files after the initial feed fetch.

chrome/browser/chromeos/gdata/drive_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_api_parser.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata_test_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/mock_directory_change_observer.h"
 #include "chrome/browser/chromeos/gdata/mock_drive_cache_observer.h"
 #include "chrome/browser/chromeos/gdata/mock_drive_service.h"
+#include "chrome/browser/chromeos/gdata/mock_drive_web_apps_registry.h"
+#include "chrome/browser/chromeos/gdata/mock_free_disk_space_getter.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AtLeast;
 using ::testing::Eq;
 using ::testing::NotNull;
@@ skipping 58 matching lines @@
 }
 
 // Action used to set mock expectations for
 // DriveFileSystem::CopyDocument().
 ACTION_P2(MockCopyDocument, status, value) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(arg2, status, base::Passed(value)));
 }
 
-// Returns the absolute path for a test file stored under
-// chrome/test/data/chromeos/gdata.
-FilePath GetTestFilePath(const FilePath::StringType& base_name) {
-  FilePath path;
-  std::string error;
-  PathService::Get(chrome::DIR_TEST_DATA, &path);
-  path = path.AppendASCII("chromeos")
-      .AppendASCII("gdata")
-      .AppendASCII(base_name.c_str());
-  EXPECT_TRUE(file_util::PathExists(path)) <<
-      "Couldn't find " << path.value();
-  return path;
-}
-
-// Loads a test JSON file as a base::Value.
-base::Value* LoadJSONFile(const std::string& base_name) {
-  FilePath path = GetTestFilePath(base_name);
-
-  std::string error;
-  JSONFileValueSerializer serializer(path);
-  base::Value* value = serializer.Deserialize(NULL, &error);
-  EXPECT_TRUE(value) <<
-      "Parse error " << path.value() << ": " << error;
-  return value;
-}
-
 // Counts the number of files (not directories) in |entries|.
 int CountFiles(const DriveEntryProtoVector& entries) {
   int num_files = 0;
   for (size_t i = 0; i < entries.size(); ++i) {
     if (!entries[i].file_info().is_directory())
       ++num_files;
   }
   return num_files;
 }
 
 }  // namespace
 
-class MockFreeDiskSpaceGetter : public FreeDiskSpaceGetterInterface {
- public:
-  virtual ~MockFreeDiskSpaceGetter() {}
-  MOCK_CONST_METHOD0(AmountOfFreeDiskSpace, int64());
-};
-
 class MockGDataUploader : public GDataUploaderInterface {
  public:
   virtual ~MockGDataUploader() {}
   // This function is not mockable by gmock.
   virtual int UploadNewFile(
       scoped_ptr<UploadFileInfo> upload_file_info) OVERRIDE {
     // Set a document entry for an uploaded file.
     // Used for TransferFileFromLocalToRemote_RegularFile test.
-    scoped_ptr<base::Value> value(LoadJSONFile("uploaded_file.json"));
+    scoped_ptr<base::Value> value(
+        test_util::LoadJSONFile("uploaded_file.json"));
     scoped_ptr<DocumentEntry> document_entry(
         DocumentEntry::ExtractAndParse(*value));
     upload_file_info->entry = document_entry.Pass();
 
     // Run the completion callback.
     const UploadFileInfo::UploadCompletionCallback callback =
         upload_file_info->completion_callback;
     if (!callback.is_null())
       callback.Run(DRIVE_FILE_OK, upload_file_info.Pass());
 
@@ skipping 11 matching lines @@
                const FilePath& local_file_path,
                int64 file_size,
                const std::string& content_type,
                const UploadFileInfo::UploadCompletionCallback& callback));
 
   MOCK_METHOD2(UpdateUpload, void(int upload_id,
                                   content::DownloadItem* download));
   MOCK_CONST_METHOD1(GetUploadedBytes, int64(int upload_id));
 };
 
-class MockDriveWebAppsRegistry : public DriveWebAppsRegistryInterface {
- public:
-  virtual ~MockDriveWebAppsRegistry() {}
-
-  MOCK_METHOD3(GetWebAppsForFile, void(const FilePath& file,
-                                       const std::string& mime_type,
-                                       ScopedVector<DriveWebAppInfo>* apps));
-  MOCK_METHOD1(GetExtensionsForWebStoreApp,
-               std::set<std::string>(const std::string& web_store_id));
-  MOCK_METHOD1(UpdateFromFeed, void(const AccountMetadataFeed& metadata));
-  MOCK_METHOD1(UpdateFromApplicationList, void(const AppList& applist));
-};
-
 class DriveFileSystemTest : public testing::Test {
  protected:
   DriveFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         cache_(NULL),
         file_system_(NULL),
         mock_drive_service_(NULL),
         mock_webapps_registry_(NULL),
         num_callback_invocations_(0),
@@ skipping 69 matching lines @@
     chromeos::CrosLibrary::Shutdown();
   }
 
   // Loads test json file as root ("/drive") element.
   void LoadRootFeedDocument(const std::string& filename) {
     LoadChangeFeed(filename, 0);
   }
 
   void LoadChangeFeed(const std::string& filename,
                       int largest_changestamp) {
-    std::string error;
-    scoped_ptr<Value> document(LoadJSONFile(filename));
-    ASSERT_TRUE(document.get());
-    ASSERT_TRUE(document->GetType() == Value::TYPE_DICTIONARY);
-    scoped_ptr<DocumentFeed> document_feed(
-        DocumentFeed::ExtractAndParse(*document));
-    ASSERT_TRUE(document_feed.get());
-    std::vector<DocumentFeed*> feed_list;
-    feed_list.push_back(document_feed.get());
-    ASSERT_TRUE(UpdateContent(feed_list, largest_changestamp));
+    test_util::LoadChangeFeed(filename,
+                              file_system_,
+                              largest_changestamp,
+                              root_feed_changestamp_++);

[satorux1, 2012/08/30 04:38:15]

looks tricky. please increment outside the function call.

[yoshiki, 2012/08/30 15:23:45]

Done.
https://chromiumcodereview.appspot.com/10905016/diff2/1:4001/chrome/browser/c...

   }
 
   void AddDirectoryFromFile(const FilePath& directory_path,
                             const std::string& filename) {
-    scoped_ptr<Value> atom(LoadJSONFile(filename));
+    scoped_ptr<Value> atom(test_util::LoadJSONFile(filename));
     ASSERT_TRUE(atom.get());
     ASSERT_TRUE(atom->GetType() == Value::TYPE_DICTIONARY);
 
     DictionaryValue* dict_value = NULL;
     Value* entry_value = NULL;
     ASSERT_TRUE(atom->GetAsDictionary(&dict_value));
     ASSERT_TRUE(dict_value->Get("entry", &entry_value));
 
     DictionaryValue* entry_dict = NULL;
     ASSERT_TRUE(entry_value->GetAsDictionary(&entry_dict));
 
     // Tweak entry title to match the last segment of the directory path
     // (new directory name).
     std::vector<FilePath::StringType> dir_parts;
     directory_path.GetComponents(&dir_parts);
     entry_dict->SetString("title.$t", dir_parts[dir_parts.size() - 1]);
 
     DriveFileError error;
     DriveFileSystem::CreateDirectoryParams params(directory_path,
                                                   directory_path,
                                                   false,  // is_exclusive
                                                   false,  // is_recursive
         base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
     file_system_->AddNewDirectory(params, HTTP_SUCCESS, atom.Pass());
     test_util::RunBlockingPoolTask();
     EXPECT_EQ(DRIVE_FILE_OK, error);
   }
 
-  // Updates the content of directory under |directory_path| with parsed feed
-  // |value|.
-  bool UpdateContent(const std::vector<DocumentFeed*>& list,
-                     int largest_changestamp) {
-    GURL unused;
-    return file_system_->UpdateFromFeedForTesting(
-        list,
-        largest_changestamp,
-        root_feed_changestamp_++) == DRIVE_FILE_OK;
-  }
-
   bool RemoveEntry(const FilePath& file_path) {
     file_system_->GetEntryInfoByPath(
         file_path,
         base::Bind(&CallbackHelper::GetEntryInfoCallback,
                    callback_helper_.get()));
     test_util::RunBlockingPoolTask();
 
     if (callback_helper_->last_error_ != DRIVE_FILE_OK)
       return false;
 
@@ skipping 886 matching lines @@
   EXPECT_TRUE(EntryExists(
       FilePath(FILE_PATH_LITERAL("drive/Dir1/SubDir2/File3"))));
 }
 
 TEST_F(DriveFileSystemTest, CachedFeadLoadingThenServerFeedLoading) {
   SaveTestFileSystem();
 
   // SaveTestFileSystem and "account_metadata.json" have the same changestamp,
   // so no request for new feeds (i.e., call to GetDocuments) should happen.
   mock_drive_service_->set_account_metadata(
-      LoadJSONFile("account_metadata.json"));
+      test_util::LoadJSONFile("account_metadata.json"));
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
   EXPECT_CALL(*mock_drive_service_, GetDocuments(_, _, _, _, _)).Times(0);
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(EntryExists(FilePath(FILE_PATH_LITERAL("drive/File1"))));
 
   // Since the file system has verified that it holds the latest snapshot,
   // it should change its state to FROM_SERVER, which admits periodic refresh.
   // To test it, call CheckForUpdates and verify it does try to check updates.
   mock_drive_service_->set_account_metadata(
-      LoadJSONFile("account_metadata.json"));
+      test_util::LoadJSONFile("account_metadata.json"));
   EXPECT_CALL(*mock_drive_service_, GetAccountMetadata(_)).Times(1);
   EXPECT_CALL(*mock_webapps_registry_, UpdateFromFeed(_)).Times(1);
 
   file_system_->CheckForUpdates();
   test_util::RunBlockingPoolTask();
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ skipping 50 matching lines @@
   const FilePath remote_dest_file_path(
       FILE_PATH_LITERAL("drive/Directory 1/Document 1.gdoc"));
   EXPECT_FALSE(EntryExists(remote_dest_file_path));
 
   // We'll add a file to "Directory 1" directory on Drive.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
       Eq(FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
 
   // We'll copy a hosted document using CopyDocument.
   // ".gdoc" suffix should be stripped when copying.
-  scoped_ptr<base::Value> document(LoadJSONFile("uploaded_document.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("uploaded_document.json"));
   EXPECT_CALL(*mock_drive_service_,
               CopyDocument(kResourceId,
                            FILE_PATH_LITERAL("Document 1"),
                            _))
       .WillOnce(MockCopyDocument(gdata::HTTP_SUCCESS, &document));
   // We'll then add the hosted document to the destination directory.
   EXPECT_CALL(*mock_drive_service_,
               AddResourceToDirectory(_, _, _)).Times(1);
 
   FileOperationCallback callback =
@@ skipping 32 matching lines @@
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   const std::string remote_src_file_data = "Test file data";
   mock_drive_service_->set_file_data(new std::string(remote_src_file_data));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
-  scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(remote_src_file_path,
                            cache_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
@@ skipping 593 matching lines @@
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
   const int64 file_size = entry_proto->file_info().size();
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
-  scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
@@ skipping 19 matching lines @@
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Pretend we have no space at all.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(0));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
-  scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is not obtained with the mock DriveService, because of no space.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(0);
 
@@ skipping 24 matching lines @@
   // the disk space was freed up by removing temporary files.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .WillOnce(Return(file_size + kMinFreeSpace))
       .WillOnce(Return(0))
       .WillOnce(Return(file_size + kMinFreeSpace))
       .WillOnce(Return(file_size + kMinFreeSpace));
 
   // Store something in the temporary cache directory.
   TestStoreToCache("<resource_id>",
                    "<md5>",
-                   GetTestFilePath("root_feed.json"),
+                   test_util::GetTestFilePath("root_feed.json"),
                    DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
   ASSERT_TRUE(CacheEntryExists("<resource_id>", "<md5>"));
   ASSERT_TRUE(CacheFileExists("<resource_id>", "<md5>"));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
-  scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService, because of we freed up the
   // space.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
@@ skipping 31 matching lines @@
   // but then start reporting we have not enough space. This is to emulate that
   // the disk space becomes full after the file is downloaded for some reason
   // (ex. the actual file was larger than the expected size).
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .WillOnce(Return(file_size + kMinFreeSpace))
       .WillOnce(Return(kMinFreeSpace - 1))
       .WillOnce(Return(kMinFreeSpace - 1));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
-  scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
@@ skipping 17 matching lines @@
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
-                   GetTestFilePath("root_feed.json"),
+                   test_util::GetTestFilePath("root_feed.json"),
                    DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // Make sure we don't fetch metadata for downloading file.
   EXPECT_CALL(*mock_drive_service_, GetDocumentEntry(_, _)).Times(0);
 
   // Make sure we don't call downloads at all.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
@@ skipping 46 matching lines @@
                  callback_helper_.get());
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
-  scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService, because it's not stored in
   // the cache.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(file_in_root,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
@@ skipping 20 matching lines @@
 
   FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
 
   // Store something as cached version of this file.
   TestStoreToCache(entry_proto->resource_id(),
                    entry_proto->file_specific_info().file_md5(),
-                   GetTestFilePath("root_feed.json"),
+                   test_util::GetTestFilePath("root_feed.json"),
                    DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT,
                    DriveCache::CACHE_TYPE_TMP);
 
   // The file is obtained from the cache.
   // Make sure we don't call downloads at all.
   EXPECT_CALL(*mock_drive_service_, DownloadFile(_, _, _, _, _))
       .Times(0);
 
   file_system_->GetFileByResourceId(entry_proto->resource_id(),
@@ skipping 26 matching lines @@
           DriveCache::CACHE_TYPE_TMP);
 
   // First store a file to cache. A cache file will be created at:
   // GCache/v1/persistent/<kResourceId>.<kMd5>
   const FilePath original_cache_file_path =
       DriveCache::GetCacheRootPath(profile_.get())
       .AppendASCII("persistent")
       .AppendASCII(kResourceId + "." + kMd5);
   TestStoreToCache(kResourceId,
                    kMd5,
-                   GetTestFilePath("root_feed.json"),  // Anything works.
+                   // Anything works.
+                   test_util::GetTestFilePath("root_feed.json"),
                    DRIVE_FILE_OK,
                    test_util::TEST_CACHE_STATE_PRESENT |
                    test_util::TEST_CACHE_STATE_PINNED |
                    test_util::TEST_CACHE_STATE_PERSISTENT,
                    DriveCache::CACHE_TYPE_PERSISTENT);
   ASSERT_TRUE(file_util::PathExists(original_cache_file_path));
 
   // Add the dirty bit. The cache file will be renamed to
   // GCache/v1/persistent/<kResourceId>.local
   TestMarkDirty(kResourceId,
@@ skipping 33 matching lines @@
       DriveCache::GetCacheRootPath(profile_.get())
       .AppendASCII("outgoing")
       .AppendASCII(kResourceId);
   ASSERT_TRUE(file_util::PathExists(dirty_cache_file_path));
   ASSERT_TRUE(file_util::PathExists(outgoing_symlink_path));
 
   // Create a DocumentEntry, which is needed to mock
   // GDataUploaderInterface::UploadExistingFile().
   // TODO(satorux): This should be cleaned up. crbug.com/134240.
   DocumentEntry* document_entry = NULL;
-  scoped_ptr<base::Value> value(LoadJSONFile("root_feed.json"));
+  scoped_ptr<base::Value> value(test_util::LoadJSONFile("root_feed.json"));
   ASSERT_TRUE(value.get());
   base::DictionaryValue* as_dict = NULL;
   base::ListValue* entry_list = NULL;
   if (value->GetAsDictionary(&as_dict) &&
       as_dict->GetList("feed.entry", &entry_list)) {
     for (size_t i = 0; i < entry_list->GetSize(); ++i) {
       base::DictionaryValue* entry = NULL;
       std::string resource_id;
       if (entry_list->GetDictionary(i, &entry) &&
           entry->GetString("gd$resourceId.$t", &resource_id) &&
@@ skipping 192 matching lines @@
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   const std::string kExpectedFileData = "test file data";
   mock_drive_service_->set_file_data(new std::string(kExpectedFileData));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
-  scoped_ptr<base::Value> document(LoadJSONFile("document_to_download.json"));
+  scoped_ptr<base::Value> document(
+      test_util::LoadJSONFile("document_to_download.json"));
   SetExpectationsForGetDocumentEntry(&document, "file:2_file_resource_id");
 
   // The file is obtained with the mock DriveService.
   EXPECT_CALL(*mock_drive_service_,
               DownloadFile(kFileInRoot,
                            downloaded_file,
                            GURL("https://file_content_url_changed/"),
                            _, _))
       .Times(1);
 
@@ skipping 37 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata