gdata: Support mounting archive files in GData cache.

chrome/browser/chromeos/gdata/gdata_file_system_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 <errno.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system.h"
 #include "chrome/browser/chromeos/gdata/gdata_parser.h"
+#include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/mock_directory_change_observer.h"
 #include "chrome/browser/chromeos/gdata/mock_gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/mock_gdata_sync_client.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/test/test_browser_thread.h"
 #include "content/public/browser/browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::Eq;
 using ::testing::IsNull;
 using ::testing::Ne;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnNull;
 using ::testing::_;
 
 using base::Value;
 using base::DictionaryValue;
 using base::ListValue;
 using content::BrowserThread;
 
 namespace {
 
-const char kSlash[] = "/";
-const char kEscapedSlash[] = "\xE2\x88\x95";
 const char kSymLinkToDevNull[] = "/dev/null";
 
 struct InitialCacheResource {
   const char* source_file;              // Source file to be used for cache.
   const char* resource_id;              // Resource id of cache file.
   const char* md5;                      // MD5 of cache file.
   int cache_state;                      // Cache state of cache file.
   const char* expected_file_extension;  // Expected extension of cached file.
   // Expected CacheSubDirectoryType of cached file.
   gdata::GDataRootDirectory::CacheSubDirectoryType expected_sub_dir_type;
@@ skipping 249 matching lines @@
         GDataRootDirectory::CACHE_TYPE_TMP,
         GDataFileSystem::CACHED_FILE_FROM_SERVER);
     FilePath expected_path =
         file_system_->cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP];
     expected_path = expected_path.Append(expected_filename);
     EXPECT_EQ(expected_path, actual_path);
 
     FilePath base_name = actual_path.BaseName();
 
     // FilePath::Extension returns ".", so strip it.
-    std::string unescaped_md5 = GDataEntry::UnescapeUtf8FileName(
+    std::string unescaped_md5 = util::UnescapeCacheFileName(
         base_name.Extension().substr(1));
     EXPECT_EQ(md5, unescaped_md5);
-    std::string unescaped_resource_id = GDataEntry::UnescapeUtf8FileName(
+    std::string unescaped_resource_id = util::UnescapeCacheFileName(
         base_name.RemoveExtension().value());
     EXPECT_EQ(resource_id, unescaped_resource_id);
   }
 
   void TestStoreToCache(
       const std::string& resource_id,
       const std::string& md5,
       const FilePath& source_path,
       base::PlatformFileError expected_error,
       int expected_cache_state,
@@ skipping 30 matching lines @@
                           const std::string& md5,
                           const FilePath& gdata_file_path,
                           const FilePath& cache_file_path) {
     ++num_callback_invocations_;
 
     EXPECT_EQ(expected_error_, error);
 
     if (error == base::PLATFORM_FILE_OK) {
       // Verify filename of |cache_file_path|.
       FilePath base_name = cache_file_path.BaseName();
-      EXPECT_EQ(GDataEntry::EscapeUtf8FileName(resource_id) +
+      EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
                 FilePath::kExtensionSeparator +
-                GDataEntry::EscapeUtf8FileName(
+                util::EscapeCacheFileName(
                     expected_file_extension_.empty() ?
                     md5 : expected_file_extension_),
                 base_name.value());
     } else {
       EXPECT_TRUE(cache_file_path.empty());
     }
   }
 
   void TestRemoveFromCache(const std::string& resource_id,
                            base::PlatformFileError expected_error) {
@@ skipping 183 matching lines @@
   void VerifyMarkDirty(base::PlatformFileError error,
                        const std::string& resource_id,
                        const std::string& md5,
                        const FilePath& gdata_file_path,
                        const FilePath& cache_file_path) {
     VerifyCacheFileState(error, resource_id, md5);
 
     // Verify filename of |cache_file_path|.
     if (error == base::PLATFORM_FILE_OK) {
       FilePath base_name = cache_file_path.BaseName();
-      EXPECT_EQ(GDataEntry::EscapeUtf8FileName(resource_id) +
+      EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
                 FilePath::kExtensionSeparator +
                 "local",
                 base_name.value());
     } else {
       EXPECT_TRUE(cache_file_path.empty());
     }
   }
 
   void TestCommitDirty(
       const std::string& resource_id,
@@ skipping 24 matching lines @@
     expected_sub_dir_type_ = expected_sub_dir_type;
     expect_outgoing_symlink_ = false;
 
     file_system_->ClearDirtyInCache(resource_id, md5,
         base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     RunAllPendingForIO();
   }
 
+  void VerifySetMountedState(const std::string& resource_id,
+                             const std::string& md5,
+                             bool to_mount,
+                             base::PlatformFileError error,
+                             const FilePath& file_path) {
+    ++num_callback_invocations_;
+    EXPECT_TRUE(file_util::PathExists(file_path));
+    EXPECT_TRUE(file_path == file_system_->GetCacheFilePath(
+        resource_id,
+        md5,
+        expected_sub_dir_type_,
+        to_mount ?
+            GDataFileSystemInterface::CACHED_FILE_MOUNTED :
+            GDataFileSystemInterface::CACHED_FILE_FROM_SERVER));
+  }
+
+  void TestSetMountedState(
+      const std::string& resource_id,
+      const std::string& md5,
+      const FilePath& file_path,
+      bool to_mount,
+      base::PlatformFileError expected_error,
+      int expected_cache_state,
+      GDataRootDirectory::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;
+
+    file_system_->SetMountedState(file_path, to_mount,
+        base::Bind(&GDataFileSystemTest::VerifySetMountedState,
+                   base::Unretained(this), resource_id, md5, to_mount));
+
+    RunAllPendingForIO();
+  }
+
   void PrepareForInitCacheTest() {
     // Create gdata cache sub directories.
     ASSERT_TRUE(file_util::CreateDirectory(
         file_system_->cache_paths_[GDataRootDirectory::CACHE_TYPE_PERSISTENT]));
     ASSERT_TRUE(file_util::CreateDirectory(
         file_system_->cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP]));
     ASSERT_TRUE(file_util::CreateDirectory(
         file_system_->cache_paths_[GDataRootDirectory::CACHE_TYPE_PINNED]));
     ASSERT_TRUE(file_util::CreateDirectory(
         file_system_->cache_paths_[GDataRootDirectory::CACHE_TYPE_OUTGOING]));
@@ skipping 1307 matching lines @@
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
   TestGetCacheFilePath(resource_id, md5,
                        resource_id + FilePath::kExtensionSeparator + md5);
   EXPECT_EQ(0, num_callback_invocations_);
 
   // Use non-alphanumeric characters for resource id, including '.' which is an
   // extension separator, to test that the characters are escaped and unescaped
   // correctly, and '.' doesn't mess up the filename format and operations.
   resource_id = "pdf:`~!@#$%^&*()-_=+[{|]}\\;',<.>/?";
-  std::string escaped_resource_id;
-  ReplaceChars(resource_id, kSlash, std::string(kEscapedSlash),
-               &escaped_resource_id);
-  std::string escaped_md5;
-  ReplaceChars(md5, kSlash, std::string(kEscapedSlash), &escaped_md5);
+  std::string escaped_resource_id = util::EscapeCacheFileName(resource_id);
+  std::string escaped_md5 = util::EscapeCacheFileName(md5);
   num_callback_invocations_ = 0;
   TestGetCacheFilePath(resource_id, md5,
                        escaped_resource_id + FilePath::kExtensionSeparator +
                        escaped_md5);
   EXPECT_EQ(0, num_callback_invocations_);
 }
 
 TEST_F(GDataFileSystemTest, StoreToCacheSimple) {
   EXPECT_CALL(*mock_sync_client_, OnCacheInitialized()).Times(1);
 
@@ skipping 30 matching lines @@
           GDataRootDirectory::CACHE_TYPE_PERSISTENT :
           GDataRootDirectory::CACHE_TYPE_TMP,
       GDataFileSystem::CACHED_FILE_FROM_SERVER);
   file_util::FileEnumerator enumerator(path.DirName(), false,
                                        file_util::FileEnumerator::FILES,
                                        path.BaseName().value());
   size_t num_files_found = 0;
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     ++num_files_found;
-    EXPECT_EQ(GDataEntry::EscapeUtf8FileName(resource_id) +
+    EXPECT_EQ(util::EscapeCacheFileName(resource_id) +
               FilePath::kExtensionSeparator +
-              GDataEntry::EscapeUtf8FileName(md5),
+              util::EscapeCacheFileName(md5),
               current.BaseName().value());
   }
   EXPECT_EQ(1U, num_files_found);
 }
 
 TEST_F(GDataFileSystemTest, GetFromCacheSimple) {
   EXPECT_CALL(*mock_sync_client_, OnCacheInitialized()).Times(1);
 
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
@@ skipping 942 matching lines @@
   EXPECT_EQ(12345, callback_helper_->quota_bytes_total_);
 
   // Verify account meta feed is saved to cache.
   RunAllPendingForIO();
   FilePath path = file_system_->cache_paths_[
       GDataRootDirectory::CACHE_TYPE_META].Append(
           FILE_PATH_LITERAL("account_metadata.json"));
   EXPECT_TRUE(file_util::PathExists(path));
 }
 
+TEST_F(GDataFileSystemTest, MountUnmount) {
+  EXPECT_CALL(*mock_sync_client_, OnCacheInitialized()).Times(1);
+
+  FilePath file_path;
+  std::string resource_id("pdf:1a2b");
+  std::string md5("abcdef0123456789");
+
+  // First store a file to cache in the tmp subdir.
+  TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
+                   base::PLATFORM_FILE_OK, GDataFile::CACHE_STATE_PRESENT,
+                   GDataRootDirectory::CACHE_TYPE_TMP);
+
+  // Mark the file mounted.
+  num_callback_invocations_ = 0;
+  file_path = file_system_->GetCacheFilePath(
+      resource_id, md5,
+      GDataRootDirectory::CACHE_TYPE_TMP,
+      GDataFileSystemInterface::CACHED_FILE_FROM_SERVER);
+  TestSetMountedState(resource_id, md5, file_path, true,
+                      base::PLATFORM_FILE_OK,
+                      GDataFile::CACHE_STATE_PRESENT |
+                      GDataFile::CACHE_STATE_MOUNTED,
+                      GDataRootDirectory::CACHE_TYPE_PERSISTENT);
+  EXPECT_EQ(1, num_callback_invocations_);
+  EXPECT_TRUE(CacheEntryExists(resource_id, md5));
+
+  // Clear mounted state of the file.
+  num_callback_invocations_ = 0;
+  file_path = file_system_->GetCacheFilePath(
+      resource_id,
+      md5,
+      GDataRootDirectory::CACHE_TYPE_PERSISTENT,
+      GDataFileSystemInterface::CACHED_FILE_MOUNTED);
+  TestSetMountedState(resource_id, md5, file_path, false,
+                      base::PLATFORM_FILE_OK,
+                      GDataFile::CACHE_STATE_PRESENT,
+                      GDataRootDirectory::CACHE_TYPE_TMP);
+  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