Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(14)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/chromeos/gdata/drive_cache_unittest.cc

Issue 10877005: Rename GDataCache* to DriveCache* (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebase. Created 8 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/chromeos/gdata/drive_cache_metadata_unittest.cc ('k') | chrome/browser/chromeos/gdata/drive_resource_metadata_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/chromeos/gdata/drive_cache_unittest.cc
diff --git a/chrome/browser/chromeos/gdata/gdata_cache_unittest.cc b/chrome/browser/chromeos/gdata/drive_cache_unittest.cc
similarity index 85%
rename from chrome/browser/chromeos/gdata/gdata_cache_unittest.cc
rename to chrome/browser/chromeos/gdata/drive_cache_unittest.cc
index c56b69bf7594ea3b239b83e5e00f338c22fffbf0..841e07ede700edef03b5005526d0dc5b66aed23f 100644
--- a/chrome/browser/chromeos/gdata/gdata_cache_unittest.cc
+++ b/chrome/browser/chromeos/gdata/drive_cache_unittest.cc
@@ -10,11 +10,11 @@
#include "base/path_service.h"
#include "base/threading/sequenced_worker_pool.h"
#include "chrome/browser/chromeos/gdata/drive.pb.h"
-#include "chrome/browser/chromeos/gdata/gdata_cache.h"
+#include "chrome/browser/chromeos/gdata/drive_cache.h"
#include "chrome/browser/chromeos/gdata/gdata_file_system.h"
#include "chrome/browser/chromeos/gdata/gdata_test_util.h"
#include "chrome/browser/chromeos/gdata/gdata_util.h"
-#include "chrome/browser/chromeos/gdata/mock_gdata_cache_observer.h"
+#include "chrome/browser/chromeos/gdata/mock_drive_cache_observer.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/test/base/testing_profile.h"
#include "content/public/test/test_browser_thread.h"
@@ -37,38 +37,38 @@ struct InitialCacheResource {
int cache_state; // Cache state of cache file.
const char* expected_file_extension; // Expected extension of cached file.
// Expected CacheSubDirectoryType of cached file.
- GDataCache::CacheSubDirectoryType expected_sub_dir_type;
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type;
} const initial_cache_resources[] = {
// Cache resource in tmp dir, i.e. not pinned or dirty.
{ "root_feed.json", "tmp:resource_id", "md5_tmp_alphanumeric",
test_util::TEST_CACHE_STATE_PRESENT,
- "md5_tmp_alphanumeric", GDataCache::CACHE_TYPE_TMP },
+ "md5_tmp_alphanumeric", DriveCache::CACHE_TYPE_TMP },
// Cache resource in tmp dir, i.e. not pinned or dirty, with resource_id
// containing non-alphanumeric characters, to test resource_id is escaped and
// unescaped correctly.
{ "subdir_feed.json", "tmp:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?",
"md5_tmp_non_alphanumeric",
test_util::TEST_CACHE_STATE_PRESENT,
- "md5_tmp_non_alphanumeric", GDataCache::CACHE_TYPE_TMP },
+ "md5_tmp_non_alphanumeric", DriveCache::CACHE_TYPE_TMP },
// Cache resource that is pinned, to test a pinned file is in persistent dir
// with a symlink in pinned dir referencing it.
{ "directory_entry_atom.json", "pinned:existing", "md5_pinned_existing",
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- "md5_pinned_existing", GDataCache::CACHE_TYPE_PERSISTENT },
+ "md5_pinned_existing", DriveCache::CACHE_TYPE_PERSISTENT },
// Cache resource with a non-existent source file that is pinned, to test that
// a pinned file can reference a non-existent file.
{ "", "pinned:non-existent", "md5_pinned_non_existent",
test_util::TEST_CACHE_STATE_PINNED,
- "md5_pinned_non_existent", GDataCache::CACHE_TYPE_TMP },
+ "md5_pinned_non_existent", DriveCache::CACHE_TYPE_TMP },
// Cache resource that is dirty, to test a dirty file is in persistent dir
// with a symlink in outgoing dir referencing it.
{ "account_metadata.json", "dirty:existing", "md5_dirty_existing",
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- "local", GDataCache::CACHE_TYPE_PERSISTENT },
+ "local", DriveCache::CACHE_TYPE_PERSISTENT },
// Cache resource that is pinned and dirty, to test a dirty pinned file is in
// persistent dir with symlink in pinned and outgoing dirs referencing it.
{ "basic_feed.json", "dirty_and_pinned:existing",
@@ -77,7 +77,7 @@ struct InitialCacheResource {
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- "local", GDataCache::CACHE_TYPE_PERSISTENT },
+ "local", DriveCache::CACHE_TYPE_PERSISTENT },
};
const int64 kLotsOfSpace = kMinFreeSpace * 10;
@@ -125,16 +125,16 @@ void OnClearAll(GDataFileError* out_error,
} // namespace
-class GDataCacheTest : public testing::Test {
+class DriveCacheTest : public testing::Test {
protected:
- GDataCacheTest()
+ DriveCacheTest()
: ui_thread_(content::BrowserThread::UI, &message_loop_),
io_thread_(content::BrowserThread::IO),
cache_(NULL),
num_callback_invocations_(0),
expected_error_(GDATA_FILE_OK),
expected_cache_state_(0),
- expected_sub_dir_type_(GDataCache::CACHE_TYPE_META),
+ expected_sub_dir_type_(DriveCache::CACHE_TYPE_META),
expected_success_(true),
expect_outgoing_symlink_(false),
root_feed_changestamp_(0) {
@@ -152,10 +152,10 @@ class GDataCacheTest : public testing::Test {
content::BrowserThread::GetBlockingPool();
blocking_task_runner_ =
pool->GetSequencedTaskRunner(pool->GetSequenceToken());
- cache_ = GDataCache::CreateGDataCacheOnUIThread(
- GDataCache::GetCacheRootPath(profile_.get()), blocking_task_runner_);
+ cache_ = DriveCache::CreateDriveCacheOnUIThread(
+ DriveCache::GetCacheRootPath(profile_.get()), blocking_task_runner_);
- mock_cache_observer_.reset(new StrictMock<MockGDataCacheObserver>);
+ mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
cache_->AddObserver(mock_cache_observer_.get());
cache_->RequestInitializeOnUIThread();
@@ -175,13 +175,13 @@ class GDataCacheTest : public testing::Test {
DVLOG(1) << "PrepareForInitCacheTest start";
// Create gdata cache sub directories.
ASSERT_TRUE(file_util::CreateDirectory(
- cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_PERSISTENT)));
+ cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_PERSISTENT)));
ASSERT_TRUE(file_util::CreateDirectory(
- cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP)));
+ cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_TMP)));
ASSERT_TRUE(file_util::CreateDirectory(
- cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_PINNED)));
+ cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_PINNED)));
ASSERT_TRUE(file_util::CreateDirectory(
- cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_OUTGOING)));
+ cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_OUTGOING)));
// Dump some files into cache dirs so that
// GDataFileSystem::InitializeCacheOnBlockingPool would scan through them
@@ -196,11 +196,11 @@ class GDataCacheTest : public testing::Test {
resource.md5,
test_util::ToCacheEntry(resource.cache_state).is_pinned() ||
test_util::ToCacheEntry(resource.cache_state).is_dirty() ?
- GDataCache::CACHE_TYPE_PERSISTENT :
- GDataCache::CACHE_TYPE_TMP,
+ DriveCache::CACHE_TYPE_PERSISTENT :
+ DriveCache::CACHE_TYPE_TMP,
test_util::ToCacheEntry(resource.cache_state).is_dirty() ?
- GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHED_FILE_LOCALLY_MODIFIED :
+ DriveCache::CACHED_FILE_FROM_SERVER);
// Copy file from data dir to cache subdir, naming it per cache files
// convention.
@@ -217,8 +217,8 @@ class GDataCacheTest : public testing::Test {
FilePath link_path = cache_->GetCacheFilePath(
resource.resource_id,
"",
- GDataCache::CACHE_TYPE_PINNED,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_PINNED,
+ DriveCache::CACHED_FILE_FROM_SERVER);
ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
}
@@ -228,8 +228,8 @@ class GDataCacheTest : public testing::Test {
FilePath link_path = cache_->GetCacheFilePath(
resource.resource_id,
"",
- GDataCache::CACHE_TYPE_OUTGOING,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_OUTGOING,
+ DriveCache::CACHED_FILE_FROM_SERVER);
ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
}
}
@@ -264,7 +264,7 @@ class GDataCacheTest : public testing::Test {
test_util::ToCacheEntry(resource.cache_state),
cache_entry));
EXPECT_EQ(resource.expected_sub_dir_type,
- GDataCache::GetSubDirectoryType(cache_entry));
+ DriveCache::GetSubDirectoryType(cache_entry));
}
}
@@ -278,7 +278,7 @@ class GDataCacheTest : public testing::Test {
cache_->GetFileOnUIThread(
resource_id, md5,
- base::Bind(&GDataCacheTest::VerifyGetFromCache,
+ base::Bind(&DriveCacheTest::VerifyGetFromCache,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -290,15 +290,15 @@ class GDataCacheTest : public testing::Test {
const FilePath& source_path,
GDataFileError expected_error,
int expected_cache_state,
- GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
expected_error_ = expected_error;
expected_cache_state_ = expected_cache_state;
expected_sub_dir_type_ = expected_sub_dir_type;
cache_->StoreOnUIThread(
resource_id, md5, source_path,
- GDataCache::FILE_OPERATION_COPY,
- base::Bind(&GDataCacheTest::VerifyCacheFileState,
+ DriveCache::FILE_OPERATION_COPY,
+ base::Bind(&DriveCacheTest::VerifyCacheFileState,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -332,7 +332,7 @@ class GDataCacheTest : public testing::Test {
cache_->RemoveOnUIThread(
resource_id,
- base::Bind(&GDataCacheTest::VerifyRemoveFromCache,
+ base::Bind(&DriveCacheTest::VerifyRemoveFromCache,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -358,20 +358,20 @@ class GDataCacheTest : public testing::Test {
std::vector<PathToVerify> paths_to_verify;
paths_to_verify.push_back( // Index 0: CACHE_TYPE_TMP.
PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
- GDataCache::CACHE_TYPE_TMP,
- GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
+ DriveCache::CACHE_TYPE_TMP,
+ DriveCache::CACHED_FILE_FROM_SERVER), FilePath()));
paths_to_verify.push_back( // Index 1: CACHE_TYPE_PERSISTENT.
PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
- GDataCache::CACHE_TYPE_PERSISTENT,
- GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
+ DriveCache::CACHE_TYPE_PERSISTENT,
+ DriveCache::CACHED_FILE_FROM_SERVER), FilePath()));
paths_to_verify.push_back( // Index 2: CACHE_TYPE_TMP, but STATE_PINNED.
PathToVerify(cache_->GetCacheFilePath(resource_id, "",
- GDataCache::CACHE_TYPE_PINNED,
- GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
+ DriveCache::CACHE_TYPE_PINNED,
+ DriveCache::CACHED_FILE_FROM_SERVER), FilePath()));
paths_to_verify.push_back( // Index 3: CACHE_TYPE_OUTGOING.
PathToVerify(cache_->GetCacheFilePath(resource_id, "",
- GDataCache::CACHE_TYPE_OUTGOING,
- GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
+ DriveCache::CACHE_TYPE_OUTGOING,
+ DriveCache::CACHED_FILE_FROM_SERVER), FilePath()));
if (!cache_entry_found) {
for (size_t i = 0; i < paths_to_verify.size(); ++i) {
file_util::FileEnumerator enumerator(
@@ -392,15 +392,15 @@ class GDataCacheTest : public testing::Test {
paths_to_verify[1].expected_existing_path =
GetCacheFilePath(resource_id,
std::string(),
- GDataCache::CACHE_TYPE_PERSISTENT,
- GDataCache::CACHED_FILE_LOCALLY_MODIFIED);
+ DriveCache::CACHE_TYPE_PERSISTENT,
+ DriveCache::CACHED_FILE_LOCALLY_MODIFIED);
// Change expected_existing_path of CACHE_TYPE_OUTGOING (index 3).
paths_to_verify[3].expected_existing_path =
GetCacheFilePath(resource_id,
std::string(),
- GDataCache::CACHE_TYPE_OUTGOING,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_OUTGOING,
+ DriveCache::CACHED_FILE_FROM_SERVER);
if (cache_entry.is_pinned()) {
// Change expected_existing_path of CACHE_TYPE_TMP but STATE_PINNED
@@ -408,8 +408,8 @@ class GDataCacheTest : public testing::Test {
paths_to_verify[2].expected_existing_path =
GetCacheFilePath(resource_id,
std::string(),
- GDataCache::CACHE_TYPE_PINNED,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_PINNED,
+ DriveCache::CACHED_FILE_FROM_SERVER);
}
for (size_t i = 0; i < paths_to_verify.size(); ++i) {
@@ -438,14 +438,14 @@ class GDataCacheTest : public testing::Test {
const std::string& md5,
GDataFileError expected_error,
int expected_cache_state,
- GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
expected_error_ = expected_error;
expected_cache_state_ = expected_cache_state;
expected_sub_dir_type_ = expected_sub_dir_type;
cache_->PinOnUIThread(
resource_id, md5,
- base::Bind(&GDataCacheTest::VerifyCacheFileState,
+ base::Bind(&DriveCacheTest::VerifyCacheFileState,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -456,14 +456,14 @@ class GDataCacheTest : public testing::Test {
const std::string& md5,
GDataFileError expected_error,
int expected_cache_state,
- GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
expected_error_ = expected_error;
expected_cache_state_ = expected_cache_state;
expected_sub_dir_type_ = expected_sub_dir_type;
cache_->UnpinOnUIThread(
resource_id, md5,
- base::Bind(&GDataCacheTest::VerifyCacheFileState,
+ base::Bind(&DriveCacheTest::VerifyCacheFileState,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -474,7 +474,7 @@ class GDataCacheTest : public testing::Test {
const std::string& md5,
GDataFileError expected_error,
int expected_cache_state,
- GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
expected_error_ = expected_error;
expected_cache_state_ = expected_cache_state;
expected_sub_dir_type_ = expected_sub_dir_type;
@@ -482,7 +482,7 @@ class GDataCacheTest : public testing::Test {
cache_->MarkDirtyOnUIThread(
resource_id, md5,
- base::Bind(&GDataCacheTest::VerifyMarkDirty,
+ base::Bind(&DriveCacheTest::VerifyMarkDirty,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -511,7 +511,7 @@ class GDataCacheTest : public testing::Test {
const std::string& md5,
GDataFileError expected_error,
int expected_cache_state,
- GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
expected_error_ = expected_error;
expected_cache_state_ = expected_cache_state;
expected_sub_dir_type_ = expected_sub_dir_type;
@@ -519,7 +519,7 @@ class GDataCacheTest : public testing::Test {
cache_->CommitDirtyOnUIThread(
resource_id, md5,
- base::Bind(&GDataCacheTest::VerifyCacheFileState,
+ base::Bind(&DriveCacheTest::VerifyCacheFileState,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -530,14 +530,14 @@ class GDataCacheTest : public testing::Test {
const std::string& md5,
GDataFileError expected_error,
int expected_cache_state,
- GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
expected_error_ = expected_error;
expected_cache_state_ = expected_cache_state;
expected_sub_dir_type_ = expected_sub_dir_type;
expect_outgoing_symlink_ = false;
cache_->ClearDirtyOnUIThread(resource_id, md5,
- base::Bind(&GDataCacheTest::VerifyCacheFileState,
+ base::Bind(&DriveCacheTest::VerifyCacheFileState,
base::Unretained(this)));
test_util::RunBlockingPoolTask();
@@ -550,14 +550,14 @@ class GDataCacheTest : public testing::Test {
bool to_mount,
GDataFileError expected_error,
int expected_cache_state,
- GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type) {
expected_error_ = expected_error;
expected_cache_state_ = expected_cache_state;
expected_sub_dir_type_ = expected_sub_dir_type;
expect_outgoing_symlink_ = false;
cache_->SetMountedStateOnUIThread(file_path, to_mount,
- base::Bind(&GDataCacheTest::VerifySetMountedState,
+ base::Bind(&DriveCacheTest::VerifySetMountedState,
base::Unretained(this), resource_id, md5, to_mount));
test_util::RunBlockingPoolTask();
@@ -575,8 +575,8 @@ class GDataCacheTest : public testing::Test {
md5,
expected_sub_dir_type_,
to_mount ?
- GDataCache::CACHED_FILE_MOUNTED :
- GDataCache::CACHED_FILE_FROM_SERVER));
+ DriveCache::CACHED_FILE_MOUNTED :
+ DriveCache::CACHED_FILE_FROM_SERVER));
}
void VerifyCacheFileState(GDataFileError error,
@@ -597,7 +597,7 @@ class GDataCacheTest : public testing::Test {
test_util::ToCacheEntry(expected_cache_state_),
cache_entry));
EXPECT_EQ(expected_sub_dir_type_,
- GDataCache::GetSubDirectoryType(cache_entry));
+ DriveCache::GetSubDirectoryType(cache_entry));
} else {
EXPECT_FALSE(cache_entry_found);
}
@@ -608,11 +608,11 @@ class GDataCacheTest : public testing::Test {
md5,
test_util::ToCacheEntry(expected_cache_state_).is_pinned() ||
test_util::ToCacheEntry(expected_cache_state_).is_dirty() ?
- GDataCache::CACHE_TYPE_PERSISTENT :
- GDataCache::CACHE_TYPE_TMP,
+ DriveCache::CACHE_TYPE_PERSISTENT :
+ DriveCache::CACHE_TYPE_TMP,
test_util::ToCacheEntry(expected_cache_state_).is_dirty() ?
- GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHED_FILE_LOCALLY_MODIFIED :
+ DriveCache::CACHED_FILE_FROM_SERVER);
bool exists = file_util::PathExists(dest_path);
if (test_util::ToCacheEntry(expected_cache_state_).is_present())
EXPECT_TRUE(exists);
@@ -623,8 +623,8 @@ class GDataCacheTest : public testing::Test {
FilePath symlink_path = cache_->GetCacheFilePath(
resource_id,
std::string(),
- GDataCache::CACHE_TYPE_PINNED,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_PINNED,
+ DriveCache::CACHED_FILE_FROM_SERVER);
// Check that pin symlink exists, without deferencing to target path.
exists = file_util::IsLink(symlink_path);
if (test_util::ToCacheEntry(expected_cache_state_).is_pinned()) {
@@ -643,8 +643,8 @@ class GDataCacheTest : public testing::Test {
symlink_path = cache_->GetCacheFilePath(
resource_id,
std::string(),
- GDataCache::CACHE_TYPE_OUTGOING,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_OUTGOING,
+ DriveCache::CACHED_FILE_FROM_SERVER);
// Check that outgoing symlink exists, without deferencing to target path.
exists = file_util::IsLink(symlink_path);
if (expect_outgoing_symlink_ &&
@@ -662,8 +662,8 @@ class GDataCacheTest : public testing::Test {
FilePath GetCacheFilePath(const std::string& resource_id,
const std::string& md5,
- GDataCache::CacheSubDirectoryType sub_dir_type,
- GDataCache::CachedFileOrigin file_origin) {
+ DriveCache::CacheSubDirectoryType sub_dir_type,
+ DriveCache::CachedFileOrigin file_origin) {
return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
file_origin);
}
@@ -675,7 +675,7 @@ class GDataCacheTest : public testing::Test {
bool result = false;
blocking_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&GDataCacheTest::GetCacheEntryFromOriginThreadInternal,
+ base::Bind(&DriveCacheTest::GetCacheEntryFromOriginThreadInternal,
base::Unretained(this),
resource_id,
md5,
@@ -707,10 +707,10 @@ class GDataCacheTest : public testing::Test {
FilePath actual_path = cache_->GetCacheFilePath(
resource_id,
md5,
- GDataCache::CACHE_TYPE_TMP,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_TMP,
+ DriveCache::CACHED_FILE_FROM_SERVER);
FilePath expected_path =
- cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP);
+ cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_TMP);
expected_path = expected_path.Append(expected_filename);
EXPECT_EQ(expected_path, actual_path);
@@ -732,9 +732,9 @@ class GDataCacheTest : public testing::Test {
FilePath path = GetCacheFilePath(
resource_id, "*",
(test_util::ToCacheEntry(expected_cache_state_).is_pinned() ?
- GDataCache::CACHE_TYPE_PERSISTENT :
- GDataCache::CACHE_TYPE_TMP),
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_PERSISTENT :
+ DriveCache::CACHE_TYPE_TMP),
+ DriveCache::CACHED_FILE_FROM_SERVER);
file_util::FileEnumerator enumerator(path.DirName(), false,
file_util::FileEnumerator::FILES,
path.BaseName().value());
@@ -769,26 +769,26 @@ class GDataCacheTest : public testing::Test {
content::TestBrowserThread io_thread_;
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
scoped_ptr<TestingProfile> profile_;
- GDataCache* cache_;
+ DriveCache* cache_;
MockFreeDiskSpaceGetter* mock_free_disk_space_checker_;
- scoped_ptr<StrictMock<MockGDataCacheObserver> > mock_cache_observer_;
+ scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_observer_;
int num_callback_invocations_;
GDataFileError expected_error_;
int expected_cache_state_;
- GDataCache::CacheSubDirectoryType expected_sub_dir_type_;
+ DriveCache::CacheSubDirectoryType expected_sub_dir_type_;
bool expected_success_;
bool expect_outgoing_symlink_;
std::string expected_file_extension_;
int root_feed_changestamp_;
};
-TEST_F(GDataCacheTest, InitializeCache) {
+TEST_F(DriveCacheTest, InitializeCache) {
PrepareForInitCacheTest();
TestInitializeCache();
}
-TEST_F(GDataCacheTest, GetCacheFilePath) {
+TEST_F(DriveCacheTest, GetCacheFilePath) {
// Use alphanumeric characters for resource id.
std::string resource_id("pdf:1a2b");
std::string md5("abcdef0123456789");
@@ -809,7 +809,7 @@ TEST_F(GDataCacheTest, GetCacheFilePath) {
EXPECT_EQ(0, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, StoreToCacheSimple) {
+TEST_F(DriveCacheTest, StoreToCacheSimple) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -819,7 +819,7 @@ TEST_F(GDataCacheTest, StoreToCacheSimple) {
// Store an existing file.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Store a non-existent file to the same |resource_id| and |md5|.
@@ -827,7 +827,7 @@ TEST_F(GDataCacheTest, StoreToCacheSimple) {
TestStoreToCache(resource_id, md5, FilePath("./non_existent.json"),
GDATA_FILE_ERROR_FAILED,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Store a different existing file to the same |resource_id| but different
@@ -836,7 +836,7 @@ TEST_F(GDataCacheTest, StoreToCacheSimple) {
num_callback_invocations_ = 0;
TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Verify that there's only one file with name <resource_id>, i.e. previously
@@ -844,7 +844,7 @@ TEST_F(GDataCacheTest, StoreToCacheSimple) {
EXPECT_EQ(1U, CountCacheFiles(resource_id, md5));
}
-TEST_F(GDataCacheTest, GetFromCacheSimple) {
+TEST_F(DriveCacheTest, GetFromCacheSimple) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -853,7 +853,7 @@ TEST_F(GDataCacheTest, GetFromCacheSimple) {
// First store a file to cache.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Then try to get the existing file from cache.
num_callback_invocations_ = 0;
@@ -877,7 +877,7 @@ TEST_F(GDataCacheTest, GetFromCacheSimple) {
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, RemoveFromCacheSimple) {
+TEST_F(DriveCacheTest, RemoveFromCacheSimple) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -887,7 +887,7 @@ TEST_F(GDataCacheTest, RemoveFromCacheSimple) {
// First store a file to cache.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Then try to remove existing file from cache.
num_callback_invocations_ = 0;
@@ -899,14 +899,14 @@ TEST_F(GDataCacheTest, RemoveFromCacheSimple) {
resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
num_callback_invocations_ = 0;
TestRemoveFromCache(resource_id, GDATA_FILE_OK);
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, PinAndUnpin) {
+TEST_F(DriveCacheTest, PinAndUnpin) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -919,7 +919,7 @@ TEST_F(GDataCacheTest, PinAndUnpin) {
// First store a file to cache.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Pin the existing file in cache.
num_callback_invocations_ = 0;
@@ -927,14 +927,14 @@ TEST_F(GDataCacheTest, PinAndUnpin) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Unpin the existing file in cache.
num_callback_invocations_ = 0;
TestUnpin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Pin back the same existing file in cache.
@@ -943,7 +943,7 @@ TEST_F(GDataCacheTest, PinAndUnpin) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Pin a non-existent file in cache.
@@ -955,14 +955,14 @@ TEST_F(GDataCacheTest, PinAndUnpin) {
num_callback_invocations_ = 0;
TestPin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PINNED,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Unpin the previously pinned non-existent file in cache.
num_callback_invocations_ = 0;
TestUnpin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_NONE,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Unpin a file that doesn't exist in cache and is not pinned, i.e. cache
@@ -975,11 +975,11 @@ TEST_F(GDataCacheTest, PinAndUnpin) {
num_callback_invocations_ = 0;
TestUnpin(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
test_util::TEST_CACHE_STATE_NONE,
- GDataCache::CACHE_TYPE_TMP /* non-applicable */);
+ DriveCache::CACHE_TYPE_TMP /* non-applicable */);
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, StoreToCachePinned) {
+TEST_F(DriveCacheTest, StoreToCachePinned) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -990,7 +990,7 @@ TEST_F(GDataCacheTest, StoreToCachePinned) {
// Pin a non-existent file.
TestPin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PINNED,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Store an existing file to a previously pinned file.
num_callback_invocations_ = 0;
@@ -999,7 +999,7 @@ TEST_F(GDataCacheTest, StoreToCachePinned) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Store a non-existent file to a previously pinned and stored file.
@@ -1009,11 +1009,11 @@ TEST_F(GDataCacheTest, StoreToCachePinned) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, GetFromCachePinned) {
+TEST_F(DriveCacheTest, GetFromCachePinned) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1024,7 +1024,7 @@ TEST_F(GDataCacheTest, GetFromCachePinned) {
// Pin a non-existent file.
TestPin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PINNED,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Get the non-existent pinned file from cache.
num_callback_invocations_ = 0;
@@ -1038,7 +1038,7 @@ TEST_F(GDataCacheTest, GetFromCachePinned) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
// Get the previously pinned and stored file from cache.
num_callback_invocations_ = 0;
@@ -1047,7 +1047,7 @@ TEST_F(GDataCacheTest, GetFromCachePinned) {
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, RemoveFromCachePinned) {
+TEST_F(DriveCacheTest, RemoveFromCachePinned) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1059,12 +1059,12 @@ TEST_F(GDataCacheTest, RemoveFromCachePinned) {
// Store a file to cache, and pin it.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
TestPin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
// Remove |resource_id| from cache.
num_callback_invocations_ = 0;
@@ -1078,19 +1078,19 @@ TEST_F(GDataCacheTest, RemoveFromCachePinned) {
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
TestPin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
num_callback_invocations_ = 0;
TestRemoveFromCache(resource_id, GDATA_FILE_OK);
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, DirtyCacheSimple) {
+TEST_F(DriveCacheTest, DirtyCacheSimple) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1101,7 +1101,7 @@ TEST_F(GDataCacheTest, DirtyCacheSimple) {
// First store a file to cache.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Mark the file dirty.
num_callback_invocations_ = 0;
@@ -1109,7 +1109,7 @@ TEST_F(GDataCacheTest, DirtyCacheSimple) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Commit the file dirty.
@@ -1118,18 +1118,18 @@ TEST_F(GDataCacheTest, DirtyCacheSimple) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Clear dirty state of the file.
num_callback_invocations_ = 0;
TestClearDirty(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, DirtyCachePinned) {
+TEST_F(DriveCacheTest, DirtyCachePinned) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1141,12 +1141,12 @@ TEST_F(GDataCacheTest, DirtyCachePinned) {
// First store a file to cache and pin it.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
TestPin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
// Mark the file dirty.
num_callback_invocations_ = 0;
@@ -1155,7 +1155,7 @@ TEST_F(GDataCacheTest, DirtyCachePinned) {
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Commit the file dirty.
@@ -1165,7 +1165,7 @@ TEST_F(GDataCacheTest, DirtyCachePinned) {
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Clear dirty state of the file.
@@ -1174,12 +1174,12 @@ TEST_F(GDataCacheTest, DirtyCachePinned) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
}
// Test is disabled because it is flaky (http://crbug.com/134146)
-TEST_F(GDataCacheTest, PinAndUnpinDirtyCache) {
+TEST_F(DriveCacheTest, PinAndUnpinDirtyCache) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1192,19 +1192,19 @@ TEST_F(GDataCacheTest, PinAndUnpinDirtyCache) {
// First store a file to cache and mark it as dirty.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
// Verifies dirty file exists.
FilePath dirty_path = GetCacheFilePath(
resource_id,
md5,
- GDataCache::CACHE_TYPE_PERSISTENT,
- GDataCache::CACHED_FILE_LOCALLY_MODIFIED);
+ DriveCache::CACHE_TYPE_PERSISTENT,
+ DriveCache::CACHED_FILE_LOCALLY_MODIFIED);
EXPECT_TRUE(file_util::PathExists(dirty_path));
// Pin the dirty file.
@@ -1213,7 +1213,7 @@ TEST_F(GDataCacheTest, PinAndUnpinDirtyCache) {
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
// Verify dirty file still exist at the same pathname.
EXPECT_TRUE(file_util::PathExists(dirty_path));
@@ -1223,13 +1223,13 @@ TEST_F(GDataCacheTest, PinAndUnpinDirtyCache) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
// Verify dirty file still exist at the same pathname.
EXPECT_TRUE(file_util::PathExists(dirty_path));
}
-TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
+TEST_F(DriveCacheTest, DirtyCacheRepetitive) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1240,7 +1240,7 @@ TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
// First store a file to cache.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Mark the file dirty.
num_callback_invocations_ = 0;
@@ -1248,7 +1248,7 @@ TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Again, mark the file dirty. Nothing should change.
@@ -1257,7 +1257,7 @@ TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Commit the file dirty. Outgoing symlink should be created.
@@ -1266,7 +1266,7 @@ TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Again, commit the file dirty. Nothing should change.
@@ -1275,7 +1275,7 @@ TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Mark the file dirty agian after it's being committed. Outgoing symlink
@@ -1285,7 +1285,7 @@ TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Commit the file dirty. Outgoing symlink should be created again.
@@ -1294,25 +1294,25 @@ TEST_F(GDataCacheTest, DirtyCacheRepetitive) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
// Clear dirty state of the file.
num_callback_invocations_ = 0;
TestClearDirty(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Again, clear dirty state of the file, which is no longer dirty.
num_callback_invocations_ = 0;
TestClearDirty(resource_id, md5, GDATA_FILE_ERROR_INVALID_OPERATION,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, DirtyCacheInvalid) {
+TEST_F(DriveCacheTest, DirtyCacheInvalid) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1323,40 +1323,40 @@ TEST_F(GDataCacheTest, DirtyCacheInvalid) {
num_callback_invocations_ = 0;
TestMarkDirty(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
test_util::TEST_CACHE_STATE_NONE,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Commit a non-existent file dirty.
num_callback_invocations_ = 0;
TestCommitDirty(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
test_util::TEST_CACHE_STATE_NONE,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Clear dirty state of a non-existent file.
num_callback_invocations_ = 0;
TestClearDirty(resource_id, md5, GDATA_FILE_ERROR_NOT_FOUND,
test_util::TEST_CACHE_STATE_NONE,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Store a file to cache.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Commit a non-dirty existing file dirty.
num_callback_invocations_ = 0;
TestCommitDirty(resource_id, md5, GDATA_FILE_ERROR_INVALID_OPERATION,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Clear dirty state of a non-dirty existing file.
num_callback_invocations_ = 0;
TestClearDirty(resource_id, md5, GDATA_FILE_ERROR_INVALID_OPERATION,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Mark an existing file dirty, then store a new file to the same resource id
@@ -1365,7 +1365,7 @@ TEST_F(GDataCacheTest, DirtyCacheInvalid) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
num_callback_invocations_ = 0;
md5 = "new_md5";
TestStoreToCache(resource_id, md5, GetTestFilePath("subdir_feed.json"),
@@ -1373,11 +1373,11 @@ TEST_F(GDataCacheTest, DirtyCacheInvalid) {
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, RemoveFromDirtyCache) {
+TEST_F(DriveCacheTest, RemoveFromDirtyCache) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1389,24 +1389,24 @@ TEST_F(GDataCacheTest, RemoveFromDirtyCache) {
// Store a file to cache, pin it, mark it dirty and commit it.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
TestPin(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
TestMarkDirty(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
TestCommitDirty(resource_id, md5, GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_PINNED |
test_util::TEST_CACHE_STATE_DIRTY |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
// Try to remove the file. Since file is dirty, it and the corresponding
// pinned and outgoing symlinks should not be removed.
@@ -1415,7 +1415,7 @@ TEST_F(GDataCacheTest, RemoveFromDirtyCache) {
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, MountUnmount) {
+TEST_F(DriveCacheTest, MountUnmount) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(kLotsOfSpace));
@@ -1426,19 +1426,19 @@ TEST_F(GDataCacheTest, MountUnmount) {
// First store a file to cache in the tmp subdir.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
// Mark the file mounted.
num_callback_invocations_ = 0;
file_path = cache_->GetCacheFilePath(resource_id, md5,
- GDataCache::CACHE_TYPE_TMP,
- GDataCache::CACHED_FILE_FROM_SERVER);
+ DriveCache::CACHE_TYPE_TMP,
+ DriveCache::CACHED_FILE_FROM_SERVER);
TestSetMountedState(resource_id, md5, file_path, true,
GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT |
test_util::TEST_CACHE_STATE_MOUNTED |
test_util::TEST_CACHE_STATE_PERSISTENT,
- GDataCache::CACHE_TYPE_PERSISTENT);
+ DriveCache::CACHE_TYPE_PERSISTENT);
EXPECT_EQ(1, num_callback_invocations_);
EXPECT_TRUE(CacheEntryExists(resource_id, md5));
@@ -1446,12 +1446,12 @@ TEST_F(GDataCacheTest, MountUnmount) {
num_callback_invocations_ = 0;
file_path = cache_->GetCacheFilePath(resource_id,
md5,
- GDataCache::CACHE_TYPE_PERSISTENT,
- GDataCache::CACHED_FILE_MOUNTED);
+ DriveCache::CACHE_TYPE_PERSISTENT,
+ DriveCache::CACHED_FILE_MOUNTED);
TestSetMountedState(resource_id, md5, file_path, false,
GDATA_FILE_OK,
test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
EXPECT_TRUE(CacheEntryExists(resource_id, md5));
@@ -1461,7 +1461,7 @@ TEST_F(GDataCacheTest, MountUnmount) {
EXPECT_EQ(1, num_callback_invocations_);
}
-TEST_F(GDataCacheTest, GetResourceIdsOfBacklogOnUIThread) {
+TEST_F(DriveCacheTest, GetResourceIdsOfBacklogOnUIThread) {
PrepareForInitCacheTest();
std::vector<std::string> to_fetch;
@@ -1480,7 +1480,7 @@ TEST_F(GDataCacheTest, GetResourceIdsOfBacklogOnUIThread) {
EXPECT_EQ("dirty_and_pinned:existing", to_upload[1]);
}
-TEST_F(GDataCacheTest, GetResourceIdsOfExistingPinnedFilesOnUIThread) {
+TEST_F(DriveCacheTest, GetResourceIdsOfExistingPinnedFilesOnUIThread) {
PrepareForInitCacheTest();
std::vector<std::string> resource_ids;
@@ -1494,7 +1494,7 @@ TEST_F(GDataCacheTest, GetResourceIdsOfExistingPinnedFilesOnUIThread) {
EXPECT_EQ("pinned:existing", resource_ids[1]);
}
-TEST_F(GDataCacheTest, GetResourceIdsOfAllFilesOnUIThread) {
+TEST_F(DriveCacheTest, GetResourceIdsOfAllFilesOnUIThread) {
PrepareForInitCacheTest();
std::vector<std::string> resource_ids;
@@ -1513,7 +1513,7 @@ TEST_F(GDataCacheTest, GetResourceIdsOfAllFilesOnUIThread) {
}
-TEST_F(GDataCacheTest, ClearAllOnUIThread) {
+TEST_F(DriveCacheTest, ClearAllOnUIThread) {
PrepareForInitCacheTest();
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
@@ -1525,7 +1525,7 @@ TEST_F(GDataCacheTest, ClearAllOnUIThread) {
// Store an existing file.
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_OK, test_util::TEST_CACHE_STATE_PRESENT,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Verify that there's only one cached file.
@@ -1545,7 +1545,7 @@ TEST_F(GDataCacheTest, ClearAllOnUIThread) {
EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
}
-TEST_F(GDataCacheTest, StoreToCacheNoSpace) {
+TEST_F(DriveCacheTest, StoreToCacheNoSpace) {
EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
.Times(AtLeast(1)).WillRepeatedly(Return(0));
@@ -1556,7 +1556,7 @@ TEST_F(GDataCacheTest, StoreToCacheNoSpace) {
TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
GDATA_FILE_ERROR_NO_SPACE,
test_util::TEST_CACHE_STATE_NONE,
- GDataCache::CACHE_TYPE_TMP);
+ DriveCache::CACHE_TYPE_TMP);
EXPECT_EQ(1, num_callback_invocations_);
// Verify that there's no files added.
« no previous file with comments | « chrome/browser/chromeos/gdata/drive_cache_metadata_unittest.cc ('k') | chrome/browser/chromeos/gdata/drive_resource_metadata_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698