drive: Stop using PathToVerify struct in FileCacheTest

chrome/browser/chromeos/drive/file_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 "chrome/browser/chromeos/drive/file_cache.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/mock_file_cache_observer.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/google_apis/test_util.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::StrictMock;
 
 namespace drive {
 namespace internal {
 namespace {
 
-struct PathToVerify {
-  PathToVerify(const base::FilePath& in_path_to_scan,
-               const base::FilePath& in_expected_existing_path) :
-      path_to_scan(in_path_to_scan),
-      expected_existing_path(in_expected_existing_path) {
-  }
-
-  base::FilePath path_to_scan;
-  base::FilePath expected_existing_path;
-};
-
 // Copies results from Iterate().
 void OnIterate(std::vector<std::string>* out_resource_ids,
                std::vector<FileCacheEntry>* out_cache_entries,
                const std::string& resource_id,
                const FileCacheEntry& cache_entry) {
   out_resource_ids->push_back(resource_id);
   out_cache_entries->push_back(cache_entry);
 }
 
 // Called upon completion of Iterate().
@@ skipping 111 matching lines @@
     expected_error_ = expected_error;
 
     FileError error = FILE_ERROR_OK;
     cache_->RemoveOnUIThread(
         resource_id,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     VerifyRemoveFromCache(error, resource_id, "");
   }
 
+  // Returns number of files matching to |path_pattern|.
+  int CountFilesWithPathPattern(const base::FilePath& path_pattern) {
+    int result = 0;
+    file_util::FileEnumerator enumerator(
+        path_pattern.DirName(), false /* not recursive*/,
+        file_util::FileEnumerator::FILES,
+        path_pattern.BaseName().value());
+    for (base::FilePath current = enumerator.Next(); !current.empty();
+         current = enumerator.Next())
+      ++result;
+    return result;
+  }
+
   void VerifyRemoveFromCache(FileError error,
                              const std::string& resource_id,
                              const std::string& md5) {
     EXPECT_EQ(expected_error_, error);
 
     // Verify cache map.
     FileCacheEntry 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>.*"
     // exist in persistent and tmp dirs.
-    std::vector<PathToVerify> paths_to_verify;
-    paths_to_verify.push_back(  // Index 0: CACHE_TYPE_TMP.
-        PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
-                     FileCache::CACHE_TYPE_TMP,
-                     FileCache::CACHED_FILE_FROM_SERVER), base::FilePath()));
-    paths_to_verify.push_back(  // Index 1: CACHE_TYPE_PERSISTENT.
-        PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
-                     FileCache::CACHE_TYPE_PERSISTENT,
-                     FileCache::CACHED_FILE_FROM_SERVER), base::FilePath()));
+    const base::FilePath path_pattern_tmp =
+        cache_->GetCacheFilePath(resource_id, "*",
+                                 FileCache::CACHE_TYPE_TMP,
+                                 FileCache::CACHED_FILE_FROM_SERVER);
+    const base::FilePath path_pattern_persistent =
+        cache_->GetCacheFilePath(resource_id, "*",
+                                 FileCache::CACHE_TYPE_PERSISTENT,
+                                 FileCache::CACHED_FILE_FROM_SERVER);
+
+    EXPECT_EQ(0, CountFilesWithPathPattern(path_pattern_tmp));
     if (!cache_entry_found) {
-      for (size_t i = 0; i < paths_to_verify.size(); ++i) {
-        file_util::FileEnumerator enumerator(
-            paths_to_verify[i].path_to_scan.DirName(), false /* not recursive*/,
-            file_util::FileEnumerator::FILES,
-            paths_to_verify[i].path_to_scan.BaseName().value());
-        EXPECT_TRUE(enumerator.Next().empty());
-      }
+      EXPECT_EQ(0, CountFilesWithPathPattern(path_pattern_persistent));
     } else {
-      // Entry is dirty, verify that:
-      // - no files with "<resource_id>.*" exist in tmp dir
-      // - only 1 "<resource_id>.local" exists in persistent dir
-      // - if entry is pinned, only 1 <resource_id> exists in pinned dir.
-
-      // Change expected_existing_path of CACHE_TYPE_PERSISTENT (index 1).
-      paths_to_verify[1].expected_existing_path =
+      // Entry is dirty, verify that only 1 "<resource_id>.local" exists in
+      // persistent dir.
+      EXPECT_EQ(1, CountFilesWithPathPattern(path_pattern_persistent));
+      EXPECT_TRUE(file_util::PathExists(
           GetCacheFilePath(resource_id,
                            std::string(),
                            FileCache::CACHE_TYPE_PERSISTENT,
-                           FileCache::CACHED_FILE_LOCALLY_MODIFIED);
-
-      for (size_t i = 0; i < paths_to_verify.size(); ++i) {
-        const struct PathToVerify& verify = paths_to_verify[i];
-        file_util::FileEnumerator enumerator(
-            verify.path_to_scan.DirName(), false /* not recursive */,
-            file_util::FileEnumerator::FILES,
-            verify.path_to_scan.BaseName().value());
-        size_t num_files_found = 0;
-        for (base::FilePath current = enumerator.Next(); !current.empty();
-             current = enumerator.Next()) {
-          ++num_files_found;
-          EXPECT_EQ(verify.expected_existing_path, current);
-        }
-        if (verify.expected_existing_path.empty())
-          EXPECT_EQ(0U, num_files_found);
-        else
-          EXPECT_EQ(1U, num_files_found);
-      }
+                           FileCache::CACHED_FILE_LOCALLY_MODIFIED)));
     }
   }
 
   void TestPin(
       const std::string& resource_id,
       const std::string& md5,
       FileError expected_error,
       int expected_cache_state,
       FileCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
@@ skipping 1068 matching lines @@
       google_apis::test_util::GetTestFilePath("chromeos/gdata/empty_feed.json"),
       FILE_ERROR_OK,
       test_util::TEST_CACHE_STATE_PRESENT |
       test_util::TEST_CACHE_STATE_PINNED |
       test_util::TEST_CACHE_STATE_PERSISTENT,
       FileCache::CACHE_TYPE_PERSISTENT);
 }
 
 }  // namespace internal
 }  // namespace drive