Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_cache_metadata.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 "chrome/browser/chromeos/gdata/gdata_cache_metadata.h"
 
 #include <leveldb/db.h>
 
 #include "base/file_util.h"
 #include "base/sequenced_task_runner.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 
 namespace gdata {
 
 namespace {
 
 // A map table of resource ID to file path.
 typedef std::map<std::string, FilePath> ResourceIdToFilePathMap;
 
 const FilePath::CharType kGDataCacheMetadataDBPath[] =
@@ skipping 48 matching lines @@
     GDataCacheMetadata::CacheMap* cache_map) {
   for (ResourceIdToFilePathMap::const_iterator iter =
            persistent_file_map.begin();
        iter != persistent_file_map.end(); ++iter) {
     const std::string& resource_id = iter->first;
     const FilePath& file_path = iter->second;
 
     GDataCacheMetadata::CacheMap::iterator cache_map_iter =
         cache_map->find(resource_id);
     if (cache_map_iter != cache_map->end()) {
-      const GDataCacheEntry& cache_entry = cache_map_iter->second;
+      const DriveCacheEntry& cache_entry = cache_map_iter->second;
       // If the file is dirty but not committed, remove it.
       if (cache_entry.is_dirty() &&
           outgoing_file_map.count(resource_id) == 0) {
         LOG(WARNING) << "Removing dirty-but-not-committed file: "
                      << file_path.value();
         file_util::Delete(file_path, false);
         cache_map->erase(cache_map_iter);
       } else if (!cache_entry.is_dirty() &&
                  !cache_entry.is_pinned()) {
         // If the file is neither dirty nor pinned, remove it.
@@ skipping 26 matching lines @@
       util::kWildCard);
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     // Extract resource_id and md5 from filename.
     std::string resource_id;
     std::string md5;
     std::string extra_extension;
     util::ParseCacheFilePath(current, &resource_id, &md5, &extra_extension);
 
     // Determine cache state.
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     cache_entry.set_md5(md5);
     // If we're scanning pinned directory and if entry already exists, just
     // update its pinned state.
     if (sub_dir_type == GDataCache::CACHE_TYPE_PINNED) {
       std::string reason;
       if (!IsValidSymbolicLink(current, sub_dir_type, cache_paths, &reason)) {
         LOG(WARNING) << "Removing an invalid symlink: " << current.value()
                      << ": " << reason;
         file_util::Delete(current, false);
         continue;
@@ skipping 117 matching lines @@
   RemoveInvalidFilesFromPersistentDirectory(persistent_file_map,
                                             outgoing_file_map,
                                             cache_map);
   DVLOG(1) << "Directory scan finished";
 }
 
 // Returns true if |md5| matches the one in |cache_entry| with some
 // exceptions. See the function definition for details.
 bool CheckIfMd5Matches(
     const std::string& md5,
-    const GDataCacheEntry& cache_entry) {
+    const DriveCacheEntry& cache_entry) {
   if (cache_entry.is_dirty()) {
     // If the entry is dirty, its MD5 may have been replaced by "local"
     // during cache initialization, so we don't compare MD5.
     return true;
   } else if (cache_entry.is_pinned() && cache_entry.md5().empty()) {
     // If the entry is pinned, it's ok for the entry to have an empty
     // MD5. This can happen if the pinned file is not fetched. MD5 for pinned
     // files are collected from files in "persistent" directory, but the
     // persistent files do not exisit if these are not fetched yet.
     return true;
@@ skipping 16 matching lines @@
   explicit FakeGDataCacheMetadata(
       base::SequencedTaskRunner* blocking_task_runner);
 
  private:
   virtual ~FakeGDataCacheMetadata();
 
   // GDataCacheMetadata overrides:
   virtual void Initialize(const std::vector<FilePath>& cache_paths) OVERRIDE;
   virtual void AddOrUpdateCacheEntry(
       const std::string& resource_id,
-      const GDataCacheEntry& cache_entry) OVERRIDE;
+      const DriveCacheEntry& cache_entry) OVERRIDE;
   virtual void RemoveCacheEntry(const std::string& resource_id) OVERRIDE;
   virtual bool GetCacheEntry(const std::string& resource_id,
                              const std::string& md5,
-                             GDataCacheEntry* cache_entry) OVERRIDE;
+                             DriveCacheEntry* cache_entry) OVERRIDE;
   virtual void RemoveTemporaryFiles() OVERRIDE;
   virtual void Iterate(const IterateCallback& callback) OVERRIDE;
   virtual void ForceRescanForTesting(
       const std::vector<FilePath>& cache_paths) OVERRIDE;
 
   CacheMap cache_map_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeGDataCacheMetadata);
 };
 
 FakeGDataCacheMetadata::FakeGDataCacheMetadata(
     base::SequencedTaskRunner* blocking_task_runner)
     : GDataCacheMetadata(blocking_task_runner) {
   AssertOnSequencedWorkerPool();
 }
 
 FakeGDataCacheMetadata::~FakeGDataCacheMetadata() {
   AssertOnSequencedWorkerPool();
 }
 
 void FakeGDataCacheMetadata::Initialize(
     const std::vector<FilePath>& cache_paths) {
   AssertOnSequencedWorkerPool();
 
   ScanCachePaths(cache_paths, &cache_map_);
 }
 
 void FakeGDataCacheMetadata::AddOrUpdateCacheEntry(
     const std::string& resource_id,
-    const GDataCacheEntry& cache_entry) {
+    const DriveCacheEntry& cache_entry) {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter == cache_map_.end()) {  // New resource, create new entry.
     cache_map_.insert(std::make_pair(resource_id, cache_entry));
   } else {  // Resource exists.
     cache_map_[resource_id] = cache_entry;
   }
 }
 
 void FakeGDataCacheMetadata::RemoveCacheEntry(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter != cache_map_.end()) {
     // Delete the CacheEntry and remove it from the map.
     cache_map_.erase(iter);
   }
 }
 
 bool FakeGDataCacheMetadata::GetCacheEntry(const std::string& resource_id,
                                           const std::string& md5,
-                                          GDataCacheEntry* entry) {
+                                          DriveCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter == cache_map_.end()) {
     DVLOG(1) << "Can't find " << resource_id << " in cache map";
     return false;
   }
 
-  const GDataCacheEntry& cache_entry = iter->second;
+  const DriveCacheEntry& cache_entry = iter->second;
 
   if (!CheckIfMd5Matches(md5, cache_entry)) {
     return false;
   }
 
   *entry = cache_entry;
   return true;
 }
 
 void FakeGDataCacheMetadata::RemoveTemporaryFiles() {
@@ skipping 34 matching lines @@
   explicit GDataCacheMetadataDB(
       base::SequencedTaskRunner* blocking_task_runner);
 
  private:
   virtual ~GDataCacheMetadataDB();
 
   // GDataCacheMetadata overrides:
   virtual void Initialize(const std::vector<FilePath>& cache_paths) OVERRIDE;
   virtual void AddOrUpdateCacheEntry(
       const std::string& resource_id,
-      const GDataCacheEntry& cache_entry) OVERRIDE;
+      const DriveCacheEntry& cache_entry) OVERRIDE;
   virtual void RemoveCacheEntry(const std::string& resource_id) OVERRIDE;
   virtual bool GetCacheEntry(const std::string& resource_id,
                              const std::string& md5,
-                             GDataCacheEntry* cache_entry) OVERRIDE;
+                             DriveCacheEntry* cache_entry) OVERRIDE;
   virtual void RemoveTemporaryFiles() OVERRIDE;
   virtual void Iterate(const IterateCallback& callback) OVERRIDE;
   virtual void ForceRescanForTesting(
       const std::vector<FilePath>& cache_paths) OVERRIDE;
 
   // Helper function to insert |cache_map| entries into the database.
   void InsertMapIntoDB(const CacheMap& cache_map);
 
   scoped_ptr<leveldb::DB> level_db_;
 
@@ skipping 47 matching lines @@
 void GDataCacheMetadataDB::InsertMapIntoDB(const CacheMap& cache_map) {
   DVLOG(1) << "InsertMapIntoDB";
   for (CacheMap::const_iterator it = cache_map.begin();
        it != cache_map.end(); ++it) {
     AddOrUpdateCacheEntry(it->first, it->second);
   }
 }
 
 void GDataCacheMetadataDB::AddOrUpdateCacheEntry(
     const std::string& resource_id,
-    const GDataCacheEntry& cache_entry) {
+    const DriveCacheEntry& cache_entry) {
   AssertOnSequencedWorkerPool();
 
   DVLOG(1) << "AddOrUpdateCacheEntry, resource_id=" << resource_id;
   std::string serialized;
   const bool ok = cache_entry.SerializeToString(&serialized);
   if (ok)
     level_db_->Put(leveldb::WriteOptions(),
                    leveldb::Slice(resource_id),
                    leveldb::Slice(serialized));
 }
 
 void GDataCacheMetadataDB::RemoveCacheEntry(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   DVLOG(1) << "RemoveCacheEntry, resource_id=" << resource_id;
   level_db_->Delete(leveldb::WriteOptions(), leveldb::Slice(resource_id));
 }
 
 bool GDataCacheMetadataDB::GetCacheEntry(const std::string& resource_id,
                                           const std::string& md5,
-                                          GDataCacheEntry* entry) {
+                                          DriveCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
 
   std::string serialized;
   const leveldb::Status status = level_db_->Get(leveldb::ReadOptions(),
       leveldb::Slice(resource_id), &serialized);
   if (!status.ok()) {
     DVLOG(1) << "Can't find " << resource_id << " in cache db";
     return false;
   }
 
-  GDataCacheEntry cache_entry;
+  DriveCacheEntry cache_entry;
   const bool ok = cache_entry.ParseFromString(serialized);
   if (!ok) {
     LOG(ERROR) << "Failed to parse " << serialized;
     return false;
   }
 
   if (!CheckIfMd5Matches(md5, cache_entry)) {
     return false;
   }
 
   *entry = cache_entry;
   return true;
 }
 
 void GDataCacheMetadataDB::RemoveTemporaryFiles() {
   AssertOnSequencedWorkerPool();
 
   scoped_ptr<leveldb::Iterator> iter(level_db_->NewIterator(
         leveldb::ReadOptions()));
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     const bool ok = cache_entry.ParseFromString(iter->value().ToString());
     if (ok && !cache_entry.is_persistent())
       level_db_->Delete(leveldb::WriteOptions(), iter->key());
   }
 }
 
 void GDataCacheMetadataDB::Iterate(const IterateCallback& callback) {
   AssertOnSequencedWorkerPool();
 
   scoped_ptr<leveldb::Iterator> iter(level_db_->NewIterator(
         leveldb::ReadOptions()));
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     const bool ok = cache_entry.ParseFromString(iter->value().ToString());
     if (ok)
       callback.Run(iter->key().ToString(), cache_entry);
   }
 }
 
 void GDataCacheMetadataDB::ForceRescanForTesting(
     const std::vector<FilePath>& cache_paths) {
   AssertOnSequencedWorkerPool();
 
@@ skipping 28 matching lines @@
   return scoped_ptr<GDataCacheMetadata>(
       new FakeGDataCacheMetadata(blocking_task_runner));
 }
 
 void GDataCacheMetadata::AssertOnSequencedWorkerPool() {
   DCHECK(!blocking_task_runner_ ||
          blocking_task_runner_->RunsTasksOnCurrentThread());
 }
 
 }  // namespace gdata