Replace GetForProfile by Get{FileSystem,DriveAppRegistry,DriveService)ByProfile.

chrome/browser/chromeos/drive/file_system_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/drive/file_system_util.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 52 matching lines @@
 
 const char kSlash[] = "/";
 const char kEscapedSlash[] = "\xE2\x88\x95";
 
 const base::FilePath& GetDriveMyDriveMountPointPath() {
   CR_DEFINE_STATIC_LOCAL(base::FilePath, drive_mydrive_mount_path,
       (kDriveMyDriveMountPointPath));
   return drive_mydrive_mount_path;
 }
 
-FileSystemInterface* GetFileSystem(Profile* profile) {
-  DriveIntegrationService* integration_service =
-      DriveIntegrationServiceFactory::GetForProfile(profile);
-  return integration_service ? integration_service->file_system() : NULL;
-}
-
 std::string ReadStringFromGDocFile(const base::FilePath& file_path,
                                    const std::string& key) {
   const int64 kMaxGDocSize = 4096;
   int64 file_size = 0;
   if (!file_util::GetFileSize(file_path, &file_size) ||
       file_size > kMaxGDocSize) {
     DLOG(INFO) << "File too large to be a GDoc file " << file_path.value();
     return std::string();
   }
 
@@ skipping 24 matching lines @@
   base::FileEnumerator enumerator(directory_from, false,  // not recursive
                                   base::FileEnumerator::FILES);
   for (base::FilePath file_from = enumerator.Next(); !file_from.empty();
        file_from = enumerator.Next()) {
     const base::FilePath file_to = directory_to.Append(file_from.BaseName());
     if (!base::PathExists(file_to))  // Do not overwrite existing files.
       base::Move(file_from, file_to);
   }
 }
 
+// Returns DriveIntegrationService instance, if Drive is enabled.
+// Otherwise, NULL.
+DriveIntegrationService* GetIntegrationServiceByProfile(Profile* profile) {
+  // TODO(hidehiko): GetForProfile will return DriveIntegrationService
+  // regardless of mounting state. Needs to check the mounting state
+  // later. crbug.com/284972.
+  return DriveIntegrationServiceFactory::GetForProfile(profile);
+}
+
 }  // namespace
 
 const base::FilePath& GetDriveGrandRootPath() {
   CR_DEFINE_STATIC_LOCAL(base::FilePath, grand_root_path,
       (util::kDriveGrandRootDirName));
   return grand_root_path;
 }
 
 const base::FilePath& GetDriveMyDriveRootPath() {
   CR_DEFINE_STATIC_LOCAL(base::FilePath, drive_root_path,
       (util::kDriveMyDriveRootPath));
   return drive_root_path;
 }
 
 const base::FilePath& GetDriveMountPointPath() {
   CR_DEFINE_STATIC_LOCAL(base::FilePath, drive_mount_path,
       (base::FilePath::FromUTF8Unsafe(kDriveMountPointPath)));
   return drive_mount_path;
 }
 
+FileSystemInterface* GetFileSystemByProfile(Profile* profile) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DriveIntegrationService* integration_service =
+      GetIntegrationServiceByProfile(profile);
+  return integration_service ? integration_service->file_system() : NULL;
+}
+
 FileSystemInterface* GetFileSystemByProfileId(void* profile_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |profile_id| needs to be checked with ProfileManager::IsValidProfile
   // before using it.
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return NULL;
-  return GetFileSystem(profile);
+  return GetFileSystemByProfile(profile);
+}
+
+DriveAppRegistry* GetDriveAppRegistryByProfile(Profile* profile) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DriveIntegrationService* integration_service =
+      GetIntegrationServiceByProfile(profile);
+  return integration_service ?
+      integration_service->drive_app_registry() :
+      NULL;
+}
+
+DriveServiceInterface* GetDriveServiceByProfile(Profile* profile) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DriveIntegrationService* integration_service =
+      GetIntegrationServiceByProfile(profile);
+  return integration_service ? integration_service->drive_service() : NULL;
 }
 
 bool IsSpecialResourceId(const std::string& resource_id) {
   return resource_id == kDriveGrandRootSpecialResourceId ||
       resource_id == kDriveOtherDirSpecialResourceId;
 }
 
 ResourceEntry CreateMyDriveRootEntry(const std::string& root_resource_id) {
   ResourceEntry mydrive_root;
   mydrive_root.mutable_file_info()->set_is_directory(true);
@@ skipping 23 matching lines @@
       url.path(), net::UnescapeRule::NORMAL);
   return base::FilePath::FromUTF8Unsafe(path_string);
 }
 
 void MaybeSetDriveURL(Profile* profile, const base::FilePath& path, GURL* url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!IsUnderDriveMountPoint(path))
     return;
 
-  FileSystemInterface* file_system = GetFileSystem(profile);
+  FileSystemInterface* file_system = GetFileSystemByProfile(profile);
   if (!file_system)
     return;
 
   *url = FilePathToDriveURL(util::ExtractDrivePath(path));
 }
 
 bool IsUnderDriveMountPoint(const base::FilePath& path) {
   return GetDriveMountPointPath() == path ||
          GetDriveMountPointPath().IsParent(path);
 }
@@ skipping 106 matching lines @@
   // Move all files inside "tmp" to "files".
   MoveAllFilesFromDirectory(tmp_directory, cache_file_directory);
 }
 
 void PrepareWritableFileAndRun(Profile* profile,
                                const base::FilePath& path,
                                const PrepareWritableFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  FileSystemInterface* file_system = GetFileSystem(profile);
+  FileSystemInterface* file_system = GetFileSystemByProfile(profile);
   if (!file_system || !IsUnderDriveMountPoint(path)) {
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE, base::Bind(callback, FILE_ERROR_FAILED, base::FilePath()));
     return;
   }
 
   WriteOnCacheFile(file_system,
                    ExtractDrivePath(path),
                    std::string(), // mime_type
                    callback);
 }
 
 void EnsureDirectoryExists(Profile* profile,
                            const base::FilePath& directory,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   if (IsUnderDriveMountPoint(directory)) {
-    FileSystemInterface* file_system = GetFileSystem(profile);
+    FileSystemInterface* file_system = GetFileSystemByProfile(profile);
     DCHECK(file_system);
     file_system->CreateDirectory(
         ExtractDrivePath(directory),
         true /* is_exclusive */,
         true /* is_recursive */,
         callback);
   } else {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, FILE_ERROR_OK));
   }
@@ skipping 71 matching lines @@
   // Disable Drive if preference is set. This can happen with commandline flag
   // --disable-drive or enterprise policy, or with user settings.
   if (profile->GetPrefs()->GetBoolean(prefs::kDisableDrive))
     return false;
 
   return true;
 }
 
 }  // namespace util
 }  // namespace drive