Move out Drive cache file path constants outside of file_system_util.h.

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/strings/stringprintf.h"
@@ skipping 29 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/common/user_agent/user_agent_util.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace drive {
 namespace {
 
+// Name of the directory used to store metadata.
+const base::FilePath::CharType kMetadataDirectory[] = FILE_PATH_LITERAL("meta");
+
+// Name of the directory used to store cached files.
+const base::FilePath::CharType kCacheFileDirectory[] =
+    FILE_PATH_LITERAL("files");
+
+// Name of the directory used to store temporary files.
+const base::FilePath::CharType kTemporaryFileDirectory[] =
+    FILE_PATH_LITERAL("tmp");
+
 // Returns a user agent string used for communicating with the Drive backend,
 // both WAPI and Drive API.  The user agent looks like:
 //
 // chromedrive-<VERSION> chrome-cc/none (<OS_CPU_INFO>)
 // chromedrive-24.0.1274.0 chrome-cc/none (CrOS x86_64 0.4.0)
 //
 // TODO(satorux): Move this function to somewhere else: crbug.com/151605
 std::string GetDriveUserAgent() {
   const char kDriveClientName[] = "chromedrive";
 
@@ skipping 17 matching lines @@
 }
 
 // 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::ResourceMetadataStorage* metadata_storage,
     internal::FileCache* cache,
     internal::ResourceMetadata* resource_metadata) {
   if (!file_util::CreateDirectory(cache_root_directory.Append(
-          util::kMetadataDirectory)) ||
+          kMetadataDirectory)) ||
       !file_util::CreateDirectory(cache_root_directory.Append(
-          util::kCacheFileDirectory)) ||
+          kCacheFileDirectory)) ||
       !file_util::CreateDirectory(cache_root_directory.Append(
-          util::kTemporaryFileDirectory))) {
+          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),
+      cache_root_directory.Append(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);
+  util::MigrateCacheFilesFromOldDirectories(cache_root_directory,
+                                            kCacheFileDirectory);
 
   if (!metadata_storage->Initialize()) {
     LOG(WARNING) << "Failed to initialize the metadata storage.";
     return FILE_ERROR_FAILED;
   }
 
   if (!cache->Initialize()) {
     LOG(WARNING) << "Failed to initialize the cache.";
     return FILE_ERROR_FAILED;
   }
@@ skipping 43 matching lines @@
         blocking_task_runner_.get(),
         GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
         GURL(google_apis::GDataWapiUrlGenerator::kBaseDownloadUrlForProduction),
         GetDriveUserAgent()));
   }
   scheduler_.reset(new JobScheduler(
       profile_->GetPrefs(),
       drive_service_.get(),
       blocking_task_runner_.get()));
   metadata_storage_.reset(new internal::ResourceMetadataStorage(
-      cache_root_directory_.Append(util::kMetadataDirectory),
+      cache_root_directory_.Append(kMetadataDirectory),
       blocking_task_runner_.get()));
   cache_.reset(new internal::FileCache(
       metadata_storage_.get(),
-      cache_root_directory_.Append(util::kCacheFileDirectory),
+      cache_root_directory_.Append(kCacheFileDirectory),
       blocking_task_runner_.get(),
       NULL /* free_disk_space_getter */));
   drive_app_registry_.reset(new DriveAppRegistry(scheduler_.get()));
 
   resource_metadata_.reset(new internal::ResourceMetadata(
       metadata_storage_.get(), blocking_task_runner_));
 
   file_system_.reset(
       test_file_system ? test_file_system : new FileSystem(
           profile_->GetPrefs(),
           cache_.get(),
           drive_service_.get(),
           scheduler_.get(),
           resource_metadata_.get(),
           blocking_task_runner_.get(),
-          cache_root_directory_.Append(util::kTemporaryFileDirectory)));
+          cache_root_directory_.Append(kTemporaryFileDirectory)));
   download_handler_.reset(new DownloadHandler(file_system()));
   debug_info_collector_.reset(
       new DebugInfoCollector(file_system(), cache_.get()));
 }
 
 DriveIntegrationService::~DriveIntegrationService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void DriveIntegrationService::Initialize() {
@@ skipping 153 matching lines @@
     }
     return;
   }
   is_initialized_ = true;
 
   content::DownloadManager* download_manager =
       g_browser_process->download_status_updater() ?
       BrowserContext::GetDownloadManager(profile_) : NULL;
   download_handler_->Initialize(
       download_manager,
-      cache_root_directory_.Append(util::kTemporaryFileDirectory));
+      cache_root_directory_.Append(kTemporaryFileDirectory));
 
   // Register for Google Drive invalidation notifications.
   DriveNotificationManager* drive_notification_manager =
       DriveNotificationManagerFactory::GetForBrowserContext(profile_);
   if (drive_notification_manager) {
     drive_notification_manager->AddObserver(this);
     const bool registered =
         drive_notification_manager->push_notification_registered();
     const char* status = (registered ? "registered" : "not registered");
     util::Log(logging::LOG_INFO, "Push notification is %s", status);
@@ skipping 77 matching lines @@
         profile, NULL, base::FilePath(), NULL);
   } else {
     service = factory_for_test_.Run(profile);
   }
 
   service->Initialize();
   return service;
 }
 
 }  // namespace drive