gdata: Simplify semantics of sub_dir_type in CacheEntry.

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 "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
@@ skipping 40 matching lines @@
   // 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",
     GDataCache::CACHE_STATE_PRESENT |
     GDataCache::CACHE_STATE_PINNED,
     "md5_pinned_existing", GDataCache::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",
     GDataCache::CACHE_STATE_PINNED,
-    "md5_pinned_non_existent", GDataCache::CACHE_TYPE_PINNED },
+    "md5_pinned_non_existent", GDataCache::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",
     GDataCache::CACHE_STATE_PRESENT |
     GDataCache::CACHE_STATE_DIRTY,
      "local", GDataCache::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",
     "md5_dirty_and_pinned_existing",
@@ skipping 352 matching lines @@
     // - 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.
         PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
                      GDataCache::CACHE_TYPE_TMP,
                      GDataCache::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()));
-    paths_to_verify.push_back(  // Index 2: CACHE_TYPE_PINNED.
+    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()));
     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()));
     if (!cache_entry.get()) {
       for (size_t i = 0; i < paths_to_verify.size(); ++i) {
         file_util::FileEnumerator enumerator(
@@ skipping 19 matching lines @@
                            GDataCache::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);
 
       if (cache_entry->IsPinned()) {
-         // Change expected_existing_path of CACHE_TYPE_PINNED (index 2).
+         // Change expected_existing_path of CACHE_TYPE_TMP but STATE_PINNED
+         // (index 2).
          paths_to_verify[2].expected_existing_path =
              GetCacheFilePath(resource_id,
                               std::string(),
                               GDataCache::CACHE_TYPE_PINNED,
                               GDataCache::CACHED_FILE_FROM_SERVER);
       }
 
       for (size_t i = 0; i < paths_to_verify.size(); ++i) {
         const struct PathToVerify& verify = paths_to_verify[i];
         file_util::FileEnumerator enumerator(
@@ skipping 612 matching lines @@
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Pin a non-existent file in cache.
   resource_id = "document:1a2b";
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
   EXPECT_CALL(*mock_sync_client_, OnCacheUnpinned(resource_id, md5)).Times(1);
 
   num_callback_invocations_ = 0;
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
           GDataCache::CACHE_STATE_PINNED,
-          GDataCache::CACHE_TYPE_PINNED);
+          GDataCache::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, base::PLATFORM_FILE_OK,
             GDataCache::CACHE_STATE_NONE,
-            GDataCache::CACHE_TYPE_PINNED);
+            GDataCache::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
   // has zero knowledge of the file.
   resource_id = "not-in-cache:1a2b";
   // Because unpinning will fail, OnCacheUnpinned() won't be run.
   EXPECT_CALL(*mock_sync_client_, OnCacheUnpinned(resource_id, md5)).Times(0);
 
   num_callback_invocations_ = 0;
   TestUnpin(resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND,
             GDataCache::CACHE_STATE_NONE,
-            GDataCache::CACHE_TYPE_PINNED /* non-applicable */);
+            GDataCache::CACHE_TYPE_TMP /* non-applicable */);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, StoreToCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
           GDataCache::CACHE_STATE_PINNED,
-          GDataCache::CACHE_TYPE_PINNED);
+          GDataCache::CACHE_TYPE_TMP);
 
   // Store an existing file to a previously pinned file.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    base::PLATFORM_FILE_OK,
                    GDataCache::CACHE_STATE_PRESENT |
                    GDataCache::CACHE_STATE_PINNED,
                    GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store a non-existent file to a previously pinned and stored file.
   num_callback_invocations_ = 0;
   TestStoreToCache(resource_id, md5, FilePath("./non_existent.json"),
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    GDataCache::CACHE_STATE_PRESENT |
                    GDataCache::CACHE_STATE_PINNED,
                    GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 TEST_F(GDataCacheTest, GetFromCachePinned) {
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
   // Pin a non-existent file.
   TestPin(resource_id, md5, base::PLATFORM_FILE_OK,
           GDataCache::CACHE_STATE_PINNED,
-          GDataCache::CACHE_TYPE_PINNED);
+          GDataCache::CACHE_TYPE_TMP);
 
   // Get the non-existent pinned file from cache.
   num_callback_invocations_ = 0;
   TestGetFileFromCacheByResourceIdAndMd5(
       resource_id, md5, base::PLATFORM_FILE_ERROR_NOT_FOUND, md5);
   EXPECT_EQ(1, num_callback_invocations_);
 
   // Store an existing file to the previously pinned non-existent file.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    base::PLATFORM_FILE_OK,
@@ skipping 424 matching lines @@
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Try to remove the file.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
   EXPECT_EQ(1, num_callback_invocations_);
 }
 
 }   // namespace gdata