drive: DriveIntegrationService owns ResourceMetadataStorage

chrome/browser/chromeos/drive/drive_integration_service.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/drive_integration_service.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/prefs/pref_service.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/debug_info_collector.h"
 #include "chrome/browser/chromeos/drive/download_handler.h"
 #include "chrome/browser/chromeos/drive/drive_app_registry.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system.h"
 #include "chrome/browser/chromeos/drive/file_system_proxy.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/file_write_helper.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/logging.h"
+#include "chrome/browser/chromeos/drive/resource_metadata.h"
+#include "chrome/browser/chromeos/drive/resource_metadata_storage.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/drive/drive_api_service.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/drive/drive_notification_manager.h"
 #include "chrome/browser/drive/drive_notification_manager_factory.h"
 #include "chrome/browser/drive/gdata_wapi_service.h"
 #include "chrome/browser/google_apis/auth_service.h"
 #include "chrome/browser/google_apis/gdata_wapi_url_generator.h"
@@ skipping 52 matching lines @@
   // (see https://developers.google.com/drive/performance)
   return base::StringPrintf("%s-%s %s (%s) (gzip)",
                             kDriveClientName,
                             version.c_str(),
                             kLibraryInfo,
                             os_cpu_info.c_str());
 }
 
 // Initializes FileCache and ResourceMetadata.
 // Must be run on the same task runner used by |cache| and |resource_metadata|.
-FileError InitializeMetadata(const base::FilePath& cache_root_directory,
-                             internal::FileCache* cache,
-                             internal::ResourceMetadata* resource_metadata) {
+FileError InitializeMetadata(
+    const base::FilePath& cache_root_directory,
+    internal::ResourceMetadataStorage* metadata_storage,
+    internal::FileCache* cache,
+    internal::ResourceMetadata* resource_metadata) {
   if (!file_util::CreateDirectory(cache_root_directory.Append(
           util::kMetadataDirectory)) ||
       !file_util::CreateDirectory(cache_root_directory.Append(
           util::kCacheFileDirectory)) ||
       !file_util::CreateDirectory(cache_root_directory.Append(
           util::kTemporaryFileDirectory))) {
     LOG(WARNING) << "Failed to create directories.";
     return FILE_ERROR_FAILED;
   }
 
   // Change permissions of cache file directory to u+rwx,og+x (711) in order to
   // allow archive files in that directory to be mounted by cros-disks.
   file_util::SetPosixFilePermissions(
       cache_root_directory.Append(util::kCacheFileDirectory),
       file_util::FILE_PERMISSION_USER_MASK |
       file_util::FILE_PERMISSION_EXECUTE_BY_GROUP |
       file_util::FILE_PERMISSION_EXECUTE_BY_OTHERS);
 
   util::MigrateCacheFilesFromOldDirectories(cache_root_directory);
 
   if (!cache->Initialize()) {
     LOG(WARNING) << "Failed to initialize the cache.";
     return FILE_ERROR_FAILED;
   }
 
+  if (!metadata_storage->Initialize()) {
+    LOG(WARNING) << "Failed to initialize the metadata storage.";
+    return FILE_ERROR_FAILED;
+  }
+
   FileError error = resource_metadata->Initialize();
   LOG_IF(WARNING, error != FILE_ERROR_OK)
       << "Failed to initialize resource metadata. " << FileErrorToString(error);
   return error;
 }
 
 }  // namespace
 
 DriveIntegrationService::DriveIntegrationService(
     Profile* profile,
@@ skipping 18 matching lines @@
         g_browser_process->system_request_context(),
         GURL(google_apis::DriveApiUrlGenerator::kBaseUrlForProduction),
         GetDriveUserAgent()));
   } else {
     drive_service_.reset(new GDataWapiService(
         g_browser_process->system_request_context(),
         GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
         GetDriveUserAgent()));
   }
   scheduler_.reset(new JobScheduler(profile_, drive_service_.get()));
+  metadata_storage_.reset(new internal::ResourceMetadataStorage(
+      cache_root_directory_.Append(util::kMetadataDirectory),
+      blocking_task_runner_.get()));
   cache_.reset(new internal::FileCache(
       cache_root_directory_.Append(util::kMetadataDirectory),
       cache_root_directory_.Append(util::kCacheFileDirectory),
       blocking_task_runner_.get(),
       NULL /* free_disk_space_getter */));
   drive_app_registry_.reset(new DriveAppRegistry(scheduler_.get()));
 
   resource_metadata_.reset(new internal::ResourceMetadata(
-      cache_root_directory_.Append(util::kMetadataDirectory),
-      blocking_task_runner_));
+      metadata_storage_.get(), blocking_task_runner_));
 
   file_system_.reset(
       test_file_system ? test_file_system : new FileSystem(
           profile_,
           cache_.get(),
           drive_service_.get(),
           scheduler_.get(),
           resource_metadata_.get(),
           blocking_task_runner_.get(),
           cache_root_directory_.Append(util::kTemporaryFileDirectory)));
@@ skipping 11 matching lines @@
 void DriveIntegrationService::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   drive_service_->Initialize(profile_);
   file_system_->Initialize();
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&InitializeMetadata,
                  cache_root_directory_,
+                 metadata_storage_.get(),
                  cache_.get(),
                  resource_metadata_.get()),
       base::Bind(&DriveIntegrationService::InitializeAfterMetadataInitialized,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveIntegrationService::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveNotificationManager* drive_notification_manager =
@@ skipping 244 matching lines @@
         profile, NULL, base::FilePath(), NULL);
   } else {
     service = factory_for_test_.Run(profile);
   }
 
   service->Initialize();
   return service;
 }
 
 }  // namespace drive