Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_cache_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 <algorithm>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_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/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 227 matching lines @@
           test_util::ToCacheEntry(resource.cache_state).is_present() ?
           GDATA_FILE_OK :
           GDATA_FILE_ERROR_NOT_FOUND,
           resource.expected_file_extension);
       EXPECT_EQ(1, num_callback_invocations_);
 
       // Verify cache state.
       std::string md5;
       if (test_util::ToCacheEntry(resource.cache_state).is_present())
          md5 = resource.md5;
-      GDataCacheEntry cache_entry;
+      DriveCacheEntry cache_entry;
       ASSERT_TRUE(GetCacheEntryFromOriginThread(
           resource.resource_id, md5, &cache_entry));
       EXPECT_TRUE(test_util::CacheStatesEqual(
           test_util::ToCacheEntry(resource.cache_state),
           cache_entry));
       EXPECT_EQ(resource.expected_sub_dir_type,
                 GDataCache::GetSubDirectoryType(cache_entry));
     }
   }
 
@@ skipping 68 matching lines @@
   }
 
   void VerifyRemoveFromCache(GDataFileError error,
                              const std::string& resource_id,
                              const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     const bool cache_entry_found =
         GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
     if (cache_entry_found)
       EXPECT_TRUE(cache_entry.is_dirty());
 
     // If entry doesn't exist, verify that:
     // - no files with "<resource_id>.* exists in persistent and tmp dirs
     // - no "<resource_id>" symlink exists in pinned and outgoing dirs.
     std::vector<PathToVerify> paths_to_verify;
     paths_to_verify.push_back(  // Index 0: CACHE_TYPE_TMP.
@@ skipping 220 matching lines @@
   }
 
   void VerifyCacheFileState(GDataFileError error,
                             const std::string& resource_id,
                             const std::string& md5) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     const bool cache_entry_found =
         GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
     if (test_util::ToCacheEntry(expected_cache_state_).is_present() ||
         test_util::ToCacheEntry(expected_cache_state_).is_pinned()) {
       ASSERT_TRUE(cache_entry_found);
       EXPECT_TRUE(test_util::CacheStatesEqual(
           test_util::ToCacheEntry(expected_cache_state_),
           cache_entry));
       EXPECT_EQ(expected_sub_dir_type_,
                 GDataCache::GetSubDirectoryType(cache_entry));
@@ skipping 63 matching lines @@
                             const std::string& md5,
                             GDataCache::CacheSubDirectoryType sub_dir_type,
                             GDataCache::CachedFileOrigin file_origin) {
     return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
                                     file_origin);
   }
 
   // Helper function to call GetCacheEntry from origin thread.
   bool GetCacheEntryFromOriginThread(const std::string& resource_id,
                                      const std::string& md5,
-                                     GDataCacheEntry* cache_entry) {
+                                     DriveCacheEntry* cache_entry) {
     bool result = false;
     blocking_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GDataCacheTest::GetCacheEntryFromOriginThreadInternal,
                    base::Unretained(this),
                    resource_id,
                    md5,
                    cache_entry,
                    &result));
     test_util::RunBlockingPoolTask();
     return result;
   }
 
   // Used to implement GetCacheEntry.
   void GetCacheEntryFromOriginThreadInternal(
       const std::string& resource_id,
       const std::string& md5,
-      GDataCacheEntry* cache_entry,
+      DriveCacheEntry* cache_entry,
       bool* result) {
     *result = cache_->GetCacheEntry(resource_id, md5, cache_entry);
   }
 
   // Returns true if the cache entry exists for the given resource ID and MD5.
   bool CacheEntryExists(const std::string& resource_id,
                         const std::string& md5) {
-    GDataCacheEntry cache_entry;
+    DriveCacheEntry cache_entry;
     return GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
   }
 
   void TestGetCacheFilePath(const std::string& resource_id,
                             const std::string& md5,
                             const std::string& expected_filename) {
     FilePath actual_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::CACHE_TYPE_TMP,
@@ skipping 847 matching lines @@
                    test_util::TEST_CACHE_STATE_NONE,
                    GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Verify that there's no files added.
   EXPECT_EQ(0U, CountCacheFiles(resource_id, md5));
 }
 
 
 }   // namespace gdata