gdata: Move ownership of GDataCache to GDataSystemService

chrome/browser/chromeos/gdata/gdata_file_system.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_file_system.h"
 
 #include <errno.h>
 #include <sys/stat.h>
 
 #include <set>
@@ skipping 899 matching lines @@
       mime_type(mime_type),
       get_file_callback(get_file_callback),
       get_download_data_callback(get_download_data_callback) {
 }
 
 GDataFileSystem::GetFileFromCacheParams::~GetFileFromCacheParams() {
 }
 
 // GDataFileSystem class implementation.
 
-GDataFileSystem::GDataFileSystem(Profile* profile,
-                                 DocumentsServiceInterface* documents_service)
+GDataFileSystem::GDataFileSystem(
+    Profile* profile,
+    GDataCache* cache,
+    DocumentsServiceInterface* documents_service,
+    const base::SequencedWorkerPool::SequenceToken& sequence_token)
     : profile_(profile),
+      cache_(cache),
       documents_service_(documents_service),
       on_io_completed_(new base::WaitableEvent(
           true /* manual reset */, true /* initially signaled */)),
       num_pending_tasks_(0),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
       hide_hosted_docs_(false),
       ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(
           new base::WeakPtrFactory<GDataFileSystem>(this))),
       ui_weak_ptr_(ui_weak_ptr_factory_->GetWeakPtr()),
-      sequence_token_(BrowserThread::GetBlockingPool()->GetSequenceToken()) {
+      sequence_token_(sequence_token) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->Initialize(profile_);
 
   root_.reset(new GDataRootDirectory);
-  const FilePath cache_root_path = GDataCache::GetCacheRootPath(profile_);
-  cache_ = GDataCache::CreateGDataCache(cache_root_path,
-                                        BrowserThread::GetBlockingPool(),
-                                        sequence_token_).Pass();
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 
   PostBlockingPoolSequencedTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::InitializeCacheOnBlockingPool,
                  base::Unretained(this)));
@@ skipping 49 matching lines @@
   // other threads, we are safe to destroy the data members.
 
   // Cancel all the in-flight operations.
   // This asynchronously cancels the URL fetch operations.
   documents_service_->CancelAll();
   documents_service_ = NULL;
 
   // Lock to let root destroy cache map and resource map.
   base::AutoLock lock(lock_);
   root_.reset();
-  // TODO(satorux): Should not delete this on UI thread. crbug.com/131826.
-  cache_.reset();
 
   // Let's make sure that num_pending_tasks_lock_ has been released on all
   // other threads.
   base::AutoLock tasks_lock(num_pending_tasks_lock_);
 }
 
 void GDataFileSystem::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
@@ skipping 1001 matching lines @@
   // document.
   if (file_proto->is_hosted_document()) {
     base::PlatformFileError* error =
         new base::PlatformFileError(base::PLATFORM_FILE_OK);
     FilePath* temp_file_path = new FilePath;
     std::string* mime_type = new std::string;
     GDataFileType* file_type = new GDataFileType(REGULAR_FILE);
     PostBlockingPoolSequencedTaskAndReply(
         FROM_HERE,
         base::Bind(&CreateDocumentJsonFileOnBlockingPool,
-                   GetCacheDirectoryPath(
+                   cache_->GetCacheDirectoryPath(
                        GDataCache::CACHE_TYPE_TMP_DOCUMENTS),
                    GURL(file_proto->alternate_url()),
                    file_proto->gdata_entry().resource_id(),
                    error,
                    temp_file_path,
                    mime_type,
                    file_type),
         base::Bind(&RunGetFileCallbackHelper,
                    get_file_callback,
                    base::Owned(error),
@@ skipping 179 matching lines @@
   *has_enough_space = HasEnoughSpaceFor(num_bytes);
   if (*has_enough_space)
     return;
 
   // Otherwise, try to free up the disk space.
   DVLOG(1) << "Freeing up disk space for " << num_bytes;
   base::AutoLock lock(lock_);  // For cache access.
   // First remove temporary files from the cache map.
   cache_->RemoveTemporaryFiles();
   // Then remove all files under "tmp" directory.
-  RemoveAllFiles(GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP));
+  RemoveAllFiles(cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP));
 
   // Check the disk space again.
   *has_enough_space = HasEnoughSpaceFor(num_bytes);
 }
 
 void GDataFileSystem::FreeDiskSpaceIfNeeded(bool* has_enough_space) {
   FreeDiskSpaceIfNeededFor(0, has_enough_space);
 }
 
 void GDataFileSystem::StartDownloadFileIfEnoughSpace(
@@ skipping 700 matching lines @@
   const bool has_next_feed_url = current_feed->GetNextFeedURL(&next_feed_url);
 
 #ifndef NDEBUG
   // Save initial root feed for analysis.
   std::string file_name =
       base::StringPrintf("DEBUG_feed_%d.json",
                          params->start_changestamp);
   PostBlockingPoolSequencedTask(
       FROM_HERE,
       base::Bind(&SaveFeedOnBlockingPoolForDebugging,
-                 GetCacheDirectoryPath(
+                 cache_->GetCacheDirectoryPath(
                      GDataCache::CACHE_TYPE_META).Append(file_name),
                  base::Passed(&data)));
 #endif
 
   // Add the current feed to the list of collected feeds for this directory.
   params->feed_list->push_back(current_feed.release());
 
   // Compute and notify the number of entries fetched so far.
   int num_accumulated_entries = 0;
   for (size_t i = 0; i < params->feed_list->size(); ++i)
@@ skipping 30 matching lines @@
     callback.Run(params, error);
 }
 
 void GDataFileSystem::LoadRootFeedFromCache(
     bool should_load_from_server,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const FilePath path =
-      GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
+      cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
           kFilesystemProtoFile);
   LoadRootFeedParams* params = new LoadRootFeedParams(search_file_path,
                                                       should_load_from_server,
                                                       callback);
   BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
       base::Bind(&LoadProtoOnBlockingPool, path, params),
       base::Bind(&GDataFileSystem::OnProtoLoaded,
                  ui_weak_ptr_,
                  base::Owned(params)));
 }
@@ skipping 65 matching lines @@
 void GDataFileSystem::SaveFileSystemAsProto() {
   DVLOG(1) << "SaveFileSystemAsProto";
   base::AutoLock lock(lock_);  // To access root_.
 
   if (!ShouldSerializeFileSystemNow(root_->serialized_size(),
                                     root_->last_serialized())) {
     return;
   }
 
   const FilePath path =
-      GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
+      cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
           kFilesystemProtoFile);
   scoped_ptr<std::string> serialized_proto(new std::string());
   root_->SerializeToString(serialized_proto.get());
   root_->set_last_serialized(base::Time::Now());
   root_->set_serialized_size(serialized_proto->size());
   PostBlockingPoolSequencedTask(
       FROM_HERE,
       base::Bind(&SaveProtoOnBlockingPool, path,
                  base::Passed(serialized_proto.Pass())));
 }
@@ skipping 840 matching lines @@
     hide_hosted_docs_ = hide;
     root_path = root_->GetFilePath();
   }
 
   // Kick of directory refresh when this setting changes.
   NotifyDirectoryChanged(root_path);
 }
 
 //===================== GDataFileSystem: Cache entry points ====================
 
-bool GDataFileSystem::IsUnderGDataCacheDirectory(const FilePath& path) const {
-  return cache_->IsUnderGDataCacheDirectory(path);
-}
-
-FilePath GDataFileSystem::GetCacheDirectoryPath(
-    GDataCache::CacheSubDirectoryType sub_dir_type) const {
-  return cache_->GetCacheDirectoryPath(sub_dir_type);
-}
-
-FilePath GDataFileSystem::GetCacheFilePath(
-    const std::string& resource_id,
-    const std::string& md5,
-    GDataCache::CacheSubDirectoryType sub_dir_type,
-    GDataCache::CachedFileOrigin file_origin) const {
-  return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type, file_origin);
-}
-
 void GDataFileSystem::StoreToCache(const std::string& resource_id,
                                    const std::string& md5,
                                    const FilePath& source_path,
                                    FileOperationType file_operation_type,
                                    const CacheOperationCallback& callback) {
   base::PlatformFileError* error =
       new base::PlatformFileError(base::PLATFORM_FILE_OK);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataFileSystem::StoreToCacheOnBlockingPool,
@@ skipping 160 matching lines @@
 void GDataFileSystem::InitializeCacheOnBlockingPool() {
   DCHECK(IsRunningSequenceOnCurrentThread(sequence_token_));
 
   base::PlatformFileError error = CreateCacheDirectories(cache_->cache_paths());
   if (error != base::PLATFORM_FILE_OK)
     return;
 
   // Change permissions of cache persistent directory to u+rwx,og+x in order to
   // allow archive files in that directory to be mounted by cros-disks.
   error = ChangeFilePermissions(
-      GetCacheDirectoryPath(GDataCache::CACHE_TYPE_PERSISTENT),
+      cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_PERSISTENT),
       S_IRWXU | S_IXGRP | S_IXOTH);
   if (error != base::PLATFORM_FILE_OK)
     return;
 
   DVLOG(1) << "Scanning directories";
 
   // Scan cache persistent and tmp directories to enumerate all files and create
   // corresponding entries for cache map.
   GDataCache::CacheMap cache_map;
   ScanCacheDirectory(GDataCache::CACHE_TYPE_PERSISTENT, &cache_map);
@@ skipping 723 matching lines @@
                  base::Unretained(this),
                  base::Owned(has_enough_space)));
 }
 
 //============= GDataFileSystem: internal helper functions =====================
 
 void GDataFileSystem::ScanCacheDirectory(
     GDataCache::CacheSubDirectoryType sub_dir_type,
     GDataCache::CacheMap* cache_map) {
   file_util::FileEnumerator enumerator(
-      GetCacheDirectoryPath(sub_dir_type),
+      cache_->GetCacheDirectoryPath(sub_dir_type),
       false,  // not recursive
       static_cast<file_util::FileEnumerator::FileType>(
           file_util::FileEnumerator::FILES |
           file_util::FileEnumerator::SHOW_SYM_LINKS),
       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;
@@ skipping 293 matching lines @@
     base::PlatformFileError error,
     const std::string& resource_id,
     const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!callback.is_null())
     callback.Run(error);
 }
 
 }  // namespace gdata