gdata: Move ownership of GDataCache to GDataSystemService

chrome/browser/chromeos/gdata/gdata_util.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_util.h"
 
 #include <string>
 #include <vector>
 #include <utility>
 
@@ skipping 45 matching lines @@
                                      base::PLATFORM_FILE_READ |
                                      base::PLATFORM_FILE_EXCLUSIVE_READ |
                                      base::PLATFORM_FILE_ASYNC;
 
 GDataFileSystem* GetGDataFileSystem(Profile* profile) {
   GDataSystemService* system_service =
       GDataSystemServiceFactory::GetForProfile(profile);
   return system_service ? system_service->file_system() : NULL;
 }
 
+GDataCache* GetGDataCache(Profile* profile) {
+  GDataSystemService* system_service =
+      GDataSystemServiceFactory::GetForProfile(profile);
+  return system_service ? system_service->cache() : NULL;
+}
+
 void GetHostedDocumentURLBlockingThread(const FilePath& gdata_cache_path,
                                         GURL* url) {
   std::string json;
   if (!file_util::ReadFileToString(gdata_cache_path, &json)) {
     NOTREACHED() << "Unable to read file " << gdata_cache_path.value();
     return;
   }
   DVLOG(1) << "Hosted doc content " << json;
   scoped_ptr<base::Value> val(base::JSONReader::Read(json));
   base::DictionaryValue* dict_val;
@@ skipping 23 matching lines @@
 void OnGetFileInfoForInsertGDataCachePathsPermissions(
     Profile* profile,
     std::vector<std::pair<FilePath, int> >* cache_paths,
     const base::Closure& callback,
     base::PlatformFileError error,
     scoped_ptr<GDataFileProto> file_info) {
   DCHECK(profile);
   DCHECK(cache_paths);
   DCHECK(!callback.is_null());
 
-  GDataFileSystem* file_system = GetGDataFileSystem(profile);
-  if (!file_system || error != base::PLATFORM_FILE_OK) {
+  GDataCache* cache = GetGDataCache(profile);
+  if (!cache || error != base::PLATFORM_FILE_OK) {
     callback.Run();
     return;
   }
 
   DCHECK(file_info.get());
   std::string resource_id = file_info->gdata_entry().resource_id();
   std::string file_md5 = file_info->file_md5();
 
   // We check permissions for raw cache file paths only for read-only
   // operations (when fileEntry.file() is called), so read only permissions
   // should be sufficient for all cache paths. For the rest of supported
   // operations the file access check is done for drive/ paths.
   cache_paths->push_back(std::make_pair(
-      file_system->GetCacheFilePath(resource_id, file_md5,
+      cache->GetCacheFilePath(resource_id, file_md5,
           GDataCache::CACHE_TYPE_PERSISTENT,
           GDataCache::CACHED_FILE_FROM_SERVER),
       kReadOnlyFilePermissions));
   // TODO(tbarzic): When we start supporting openFile operation, we may have to
   // change permission for localy modified files to match handler's permissions.
   cache_paths->push_back(std::make_pair(
-      file_system->GetCacheFilePath(resource_id, file_md5,
+      cache->GetCacheFilePath(resource_id, file_md5,
           GDataCache::CACHE_TYPE_PERSISTENT,
           GDataCache::CACHED_FILE_LOCALLY_MODIFIED),
      kReadOnlyFilePermissions));
   cache_paths->push_back(std::make_pair(
-      file_system->GetCacheFilePath(resource_id, file_md5,
+      cache->GetCacheFilePath(resource_id, file_md5,
           GDataCache::CACHE_TYPE_PERSISTENT,
           GDataCache::CACHED_FILE_MOUNTED),
      kReadOnlyFilePermissions));
   cache_paths->push_back(std::make_pair(
-      file_system->GetCacheFilePath(resource_id, file_md5,
+      cache->GetCacheFilePath(resource_id, file_md5,
           GDataCache::CACHE_TYPE_TMP,
           GDataCache::CACHED_FILE_FROM_SERVER),
       kReadOnlyFilePermissions));
 
   callback.Run();
 }
 
 }  // namespace
 
 const FilePath& GetGDataMountPointPath() {
@@ skipping 22 matching lines @@
       net::EscapePath(resource_id).c_str()));
   return GURL(url);
 }
 
 void ModifyGDataFileResourceUrl(Profile* profile,
                                 const FilePath& gdata_cache_path,
                                 GURL* url) {
   GDataFileSystem* file_system = GetGDataFileSystem(profile);
   if (!file_system)
     return;
+  GDataCache* cache = GetGDataCache(profile);
+  if (!cache)
+    return;
 
   // Handle hosted documents. The edit url is in the temporary file, so we
   // read it on a blocking thread.
-  if (file_system->GetCacheDirectoryPath(
+  if (cache->GetCacheDirectoryPath(
           GDataCache::CACHE_TYPE_TMP_DOCUMENTS).IsParent(
       gdata_cache_path)) {
     GURL* edit_url = new GURL();
     content::BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
         base::Bind(&GetHostedDocumentURLBlockingThread,
                    gdata_cache_path, edit_url),
         base::Bind(&OpenEditURLUIThread, profile, base::Owned(edit_url)));
     *url = GURL();
     return;
   }
 
   // Handle all other gdata files.
-  if (file_system->GetCacheDirectoryPath(
+  if (cache->GetCacheDirectoryPath(
           GDataCache::CACHE_TYPE_TMP).IsParent(gdata_cache_path)) {
     const std::string resource_id =
         gdata_cache_path.BaseName().RemoveExtension().AsUTF8Unsafe();
     GDataEntry* entry = NULL;
     file_system->FindEntryByResourceIdSync(
         resource_id, base::Bind(&ReadOnlyFindEntryCallback, &entry));
 
     std::string file_name;
     if (entry && entry->AsGDataFile())
       file_name = entry->AsGDataFile()->file_name();
@@ skipping 186 matching lines @@
   // Assign the extracted extensions to md5 and extra_extension.
   int extension_count = extensions.size();
   *md5 = (extension_count > 0) ? extensions[extension_count - 1] :
                                  std::string();
   *extra_extension = (extension_count > 1) ? extensions[extension_count - 2] :
                                              std::string();
 }
 
 }  // namespace util
 }  // namespace gdata