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

chrome/browser/chromeos/extensions/file_manager/private_api_drive.cc

 // Copyright 2013 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/extensions/file_manager/private_api_drive.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/drive/drive_app_registry.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
@@ skipping 70 matching lines @@
 
   GURL file_url = GURL(file_url_str);
   file_path_ = drive::util::ExtractDrivePath(
       file_manager::util::GetLocalPathFromURL(
           render_view_host(), profile(), file_url));
 
   properties_.reset(new base::DictionaryValue);
   properties_->SetString("fileUrl", file_url.spec());
 
   // Start getting the file info.
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-  // |integration_service| is NULL if Drive is disabled.
-  if (!integration_service) {
+  drive::FileSystemInterface* file_system =
+      drive::util::GetFileSystemByProfile(profile());
+  if (!file_system) {
+    // |file_system| is NULL if Drive is disabled or not mounted.
     CompleteGetFileProperties(drive::FILE_ERROR_FAILED);
     return true;
   }
 
-  integration_service->file_system()->GetResourceEntryByPath(
+  file_system->GetResourceEntryByPath(
       file_path_,
       base::Bind(&FileBrowserPrivateGetDriveEntryPropertiesFunction::
                      OnGetFileInfo, this));
   return true;
 }
 
 void FileBrowserPrivateGetDriveEntryPropertiesFunction::OnGetFileInfo(
     drive::FileError error,
     scoped_ptr<drive::ResourceEntry> entry) {
   DCHECK(properties_);
 
   if (error != drive::FILE_ERROR_OK) {
     CompleteGetFileProperties(error);
     return;
   }
   DCHECK(entry);
 
   FillDriveEntryPropertiesValue(*entry, properties_.get());
 
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-  // |integration_service| is NULL if Drive is disabled.
-  if (!integration_service) {
+  drive::FileSystemInterface* file_system =
+      drive::util::GetFileSystemByProfile(profile_);
+  drive::DriveAppRegistry* app_registry =
+      drive::util::GetDriveAppRegistryByProfile(profile_);
+  if (!file_system || !app_registry) {
+    // |file_system| or |app_registry| is NULL if Drive is disabled.
     CompleteGetFileProperties(drive::FILE_ERROR_FAILED);
     return;
   }
 
   // The properties meaningful for directories are already filled in
   // FillDriveEntryPropertiesValue().
   if (entry.get() && !entry->has_file_specific_info()) {
     CompleteGetFileProperties(error);
     return;
   }
 
   const drive::FileSpecificInfo& file_specific_info =
       entry->file_specific_info();
 
   // Get drive WebApps that can accept this file. We just need to extract the
   // doc icon for the drive app, which is set as default.
   ScopedVector<drive::DriveAppInfo> drive_apps;
-  integration_service->drive_app_registry()->GetAppsForFile(
-      file_path_.Extension(),
-      file_specific_info.content_mime_type(),
-      &drive_apps);
+  app_registry->GetAppsForFile(file_path_.Extension(),
+                               file_specific_info.content_mime_type(),
+                               &drive_apps);
   if (!drive_apps.empty()) {
     std::string default_task_id =
         file_manager::file_tasks::GetDefaultTaskIdFromPrefs(
             *profile_->GetPrefs(),
             file_specific_info.content_mime_type(),
             file_path_.Extension());
     file_manager::file_tasks::TaskDescriptor default_task;
     file_manager::file_tasks::ParseTaskID(default_task_id, &default_task);
     DCHECK(default_task_id.empty() || !default_task.app_id.empty());
     for (size_t i = 0; i < drive_apps.size(); ++i) {
       const drive::DriveAppInfo* app_info = drive_apps[i];
       if (default_task.app_id == app_info->app_id) {
         // The drive app is set as default. Files.app should use the doc icon.
         const GURL doc_icon =
             drive::util::FindPreferredIcon(app_info->document_icons,
                                            drive::util::kPreferredIconSize);
         properties_->SetString("customIconUrl", doc_icon.spec());
       }
     }
   }
 
-  integration_service->file_system()->GetCacheEntryByPath(
+  file_system->GetCacheEntryByPath(
       file_path_,
       base::Bind(&FileBrowserPrivateGetDriveEntryPropertiesFunction::
                      CacheStateReceived, this));
 }
 
 void FileBrowserPrivateGetDriveEntryPropertiesFunction::CacheStateReceived(
     bool /* success */,
     const drive::FileCacheEntry& cache_entry) {
   // In case of an error (i.e. success is false), cache_entry.is_*() all
   // returns false.
@@ skipping 22 matching lines @@
 
 bool FileBrowserPrivatePinDriveFileFunction::RunImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::string url;
   bool set_pin = false;
   if (args_->GetSize() != 2 ||
       !args_->GetString(0, &url) ||
       !args_->GetBoolean(1, &set_pin))
     return false;
 
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   drive::FileSystemInterface* file_system =
-      integration_service ? integration_service->file_system() : NULL;
+      drive::util::GetFileSystemByProfile(profile());
   if (!file_system)  // |file_system| is NULL if Drive is disabled.
     return false;
 
   base::FilePath drive_path =
       drive::util::ExtractDrivePath(file_manager::util::GetLocalPathFromURL(
           render_view_host(), profile(), GURL(url)));
   if (set_pin) {
     file_system->Pin(drive_path,
                      base::Bind(&FileBrowserPrivatePinDriveFileFunction::
                                     OnPinStateSet, this));
@@ skipping 51 matching lines @@
   // Send the response if all files are obtained.
   if (remaining_drive_paths_.empty()) {
     SetResult(local_paths_);
     SendResponse(true);
     return;
   }
 
   // Get the file on the top of the queue.
   base::FilePath drive_path = remaining_drive_paths_.front();
 
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-  // |integration_service| is NULL if Drive is disabled.
-  if (!integration_service) {
+  drive::FileSystemInterface* file_system =
+      drive::util::GetFileSystemByProfile(profile());
+  if (!file_system) {
+    // |file_system| is NULL if Drive is disabled or not mounted.
     OnFileReady(drive::FILE_ERROR_FAILED, drive_path,
                 scoped_ptr<drive::ResourceEntry>());
     return;
   }
 
-  integration_service->file_system()->GetFileByPath(
+  file_system->GetFileByPath(
       drive_path,
       base::Bind(&FileBrowserPrivateGetDriveFilesFunction::OnFileReady, this));
 }
 
 
 void FileBrowserPrivateGetDriveFilesFunction::OnFileReady(
     drive::FileError error,
     const base::FilePath& local_path,
     scoped_ptr<drive::ResourceEntry> entry) {
   base::FilePath drive_path = remaining_drive_paths_.front();
@@ skipping 28 matching lines @@
 }
 
 bool FileBrowserPrivateCancelFileTransfersFunction::RunImpl() {
   ListValue* url_list = NULL;
   if (!args_->GetList(0, &url_list))
     return false;
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   // |integration_service| is NULL if Drive is disabled.
+  // TODO(hidehiko): GetForProfile will return the instance regardless of
+  // preference. Will need to check the mounting state. crbug.com/284972.
   if (!integration_service)
     return false;
 
   // Create the mapping from file path to job ID.
   drive::JobListInterface* job_list = integration_service->job_list();
   DCHECK(job_list);
   std::vector<drive::JobInfo> jobs = job_list->GetJobInfoList();
 
   typedef std::map<base::FilePath, std::vector<drive::JobID> > PathToIdMap;
   PathToIdMap path_to_id_map;
@@ skipping 48 matching lines @@
     return false;
 
   std::string query;
   if (!search_params->GetString("query", &query))
     return false;
 
   std::string next_feed;
   if (!search_params->GetString("nextFeed", &next_feed))
     return false;
 
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-  // |integration_service| is NULL if Drive is disabled.
-  if (!integration_service || !integration_service->file_system())
+  drive::FileSystemInterface* file_system =
+      drive::util::GetFileSystemByProfile(profile());
+  if (!file_system) {
+    // |file_system| is NULL if Drive is disabled.
     return false;
+  }
 
-  integration_service->file_system()->Search(
+  file_system->Search(
       query, GURL(next_feed),
       base::Bind(&FileBrowserPrivateSearchDriveFunction::OnSearch, this));
   return true;
 }
 
 void FileBrowserPrivateSearchDriveFunction::OnSearch(
     drive::FileError error,
     const GURL& next_link,
     scoped_ptr<std::vector<drive::SearchResultInfo> > results) {
   if (error != drive::FILE_ERROR_OK) {
@@ skipping 55 matching lines @@
     return false;
 
   drive::util::Log(logging::LOG_INFO,
                    "%s[%d] called. (types: '%s', maxResults: '%d')",
                    name().c_str(),
                    request_id(),
                    types.c_str(),
                    max_results);
   set_log_on_completion(true);
 
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-  // |integration_service| is NULL if Drive is disabled.
-  if (!integration_service || !integration_service->file_system())
+  drive::FileSystemInterface* file_system =
+      drive::util::GetFileSystemByProfile(profile());
+  if (!file_system) {
+    // |file_system| is NULL if Drive is disabled.
     return false;
+  }
 
   int options = drive::SEARCH_METADATA_ALL;
   // TODO(hirono): Switch to the JSON scheme compiler. http://crbug.com/241693
   if (types == "EXCLUDE_DIRECTORIES")
     options = drive::SEARCH_METADATA_EXCLUDE_DIRECTORIES;
   else if (types == "SHARED_WITH_ME")
     options = drive::SEARCH_METADATA_SHARED_WITH_ME;
   else if (types == "OFFLINE")
     options = drive::SEARCH_METADATA_OFFLINE;
   else
     DCHECK_EQ("ALL", types);
 
-  integration_service->file_system()->SearchMetadata(
+  file_system->SearchMetadata(
       query,
       options,
       max_results,
       base::Bind(&FileBrowserPrivateSearchDriveMetadataFunction::
                      OnSearchMetadata, this));
   return true;
 }
 
 void FileBrowserPrivateSearchDriveMetadataFunction::OnSearchMetadata(
     drive::FileError error,
@@ skipping 42 matching lines @@
     FileBrowserPrivateClearDriveCacheFunction() {
 }
 
 FileBrowserPrivateClearDriveCacheFunction::
     ~FileBrowserPrivateClearDriveCacheFunction() {
 }
 
 bool FileBrowserPrivateClearDriveCacheFunction::RunImpl() {
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-  // |integration_service| is NULL if Drive is disabled.
+  // TODO(hidehiko): GetForProfile will return the instance even if it is
+  // disabled. Needs to check the mounting state. crbug.com/284972.
   if (!integration_service || !integration_service->file_system())
     return false;
 
   // TODO(yoshiki): Receive a callback from JS-side and pass it to
   // ClearCacheAndRemountFileSystem(). http://crbug.com/140511
   integration_service->ClearCacheAndRemountFileSystem(
       base::Bind(&DoNothingWithBool));
 
   SendResponse(true);
   return true;
 }
 
 FileBrowserPrivateGetDriveConnectionStateFunction::
     FileBrowserPrivateGetDriveConnectionStateFunction() {
 }
 
 FileBrowserPrivateGetDriveConnectionStateFunction::
     ~FileBrowserPrivateGetDriveConnectionStateFunction() {
 }
 
 bool FileBrowserPrivateGetDriveConnectionStateFunction::RunImpl() {
-  scoped_ptr<DictionaryValue> value(new DictionaryValue());
-  scoped_ptr<ListValue> reasons(new ListValue());
+  drive::DriveServiceInterface* drive_service =
+      drive::util::GetDriveServiceByProfile(profile());
 
-  std::string type_string;
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-
-  bool ready = integration_service &&
-      integration_service->drive_service()->CanSendRequest();
+  bool ready = drive_service && drive_service->CanSendRequest();
   bool is_connection_cellular =
       net::NetworkChangeNotifier::IsConnectionCellular(
           net::NetworkChangeNotifier::GetConnectionType());
 
+  std::string type_string;
+  scoped_ptr<ListValue> reasons(new ListValue());
   if (net::NetworkChangeNotifier::IsOffline() || !ready) {
     type_string = kDriveConnectionTypeOffline;
     if (net::NetworkChangeNotifier::IsOffline())
       reasons->AppendString(kDriveConnectionReasonNoNetwork);
     if (!ready)
       reasons->AppendString(kDriveConnectionReasonNotReady);
-    if (!integration_service)
+    if (!drive_service)
       reasons->AppendString(kDriveConnectionReasonNoService);
   } else if (
       is_connection_cellular &&
       profile_->GetPrefs()->GetBoolean(prefs::kDisableDriveOverCellular)) {
     type_string = kDriveConnectionTypeMetered;
   } else {
     type_string = kDriveConnectionTypeOnline;
   }
 
+  scoped_ptr<DictionaryValue> value(new DictionaryValue());
   value->SetString("type", type_string);
   value->Set("reasons", reasons.release());
   SetResult(value.release());
 
   drive::util::Log(logging::LOG_INFO, "%s succeeded.", name().c_str());
   return true;
 }
 
 FileBrowserPrivateRequestAccessTokenFunction::
     FileBrowserPrivateRequestAccessTokenFunction() {
 }
 
 FileBrowserPrivateRequestAccessTokenFunction::
     ~FileBrowserPrivateRequestAccessTokenFunction() {
 }
 
 bool FileBrowserPrivateRequestAccessTokenFunction::RunImpl() {
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
   bool refresh;
-  args_->GetBoolean(0, &refresh);
+  if (!args_->GetBoolean(0, &refresh))
+    return false;
 
-  if (!integration_service) {
+  drive::DriveServiceInterface* drive_service =
+      drive::util::GetDriveServiceByProfile(profile());
+
+  if (!drive_service) {
+    // DriveService is not available.
     SetResult(new base::StringValue(""));
     SendResponse(true);
     return true;
   }
 
   // If refreshing is requested, then clear the token to refetch it.
   if (refresh)
-    integration_service->drive_service()->ClearAccessToken();
+    drive_service->ClearAccessToken();
 
   // Retrieve the cached auth token (if available), otherwise the AuthService
   // instance will try to refetch it.
-  integration_service->drive_service()->RequestAccessToken(
+  drive_service->RequestAccessToken(
       base::Bind(&FileBrowserPrivateRequestAccessTokenFunction::
                       OnAccessTokenFetched, this));
   return true;
 }
 
 void FileBrowserPrivateRequestAccessTokenFunction::OnAccessTokenFetched(
     google_apis::GDataErrorCode code,
     const std::string& access_token) {
   SetResult(new base::StringValue(access_token));
   SendResponse(true);
@@ skipping 10 matching lines @@
   std::string file_url;
   if (!args_->GetString(0, &file_url))
     return false;
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_view_host(), profile(), GURL(file_url));
   DCHECK(drive::util::IsUnderDriveMountPoint(path));
 
   base::FilePath drive_path = drive::util::ExtractDrivePath(path);
 
-  drive::DriveIntegrationService* integration_service =
-      drive::DriveIntegrationServiceFactory::GetForProfile(profile_);
-  // |integration_service| is NULL if Drive is disabled.
-  if (!integration_service)
+  drive::FileSystemInterface* file_system =
+      drive::util::GetFileSystemByProfile(profile());
+  if (!file_system) {
+    // |file_system| is NULL if Drive is disabled.
     return false;
+  }
 
-  integration_service->file_system()->GetShareUrl(
+  file_system->GetShareUrl(
       drive_path,
       file_manager::util::GetFileManagerBaseUrl(),  // embed origin
       base::Bind(&FileBrowserPrivateGetShareUrlFunction::OnGetShareUrl, this));
   return true;
 }
 
-
 void FileBrowserPrivateGetShareUrlFunction::OnGetShareUrl(
     drive::FileError error,
     const GURL& share_url) {
   if (error != drive::FILE_ERROR_OK) {
     error_ = "Share Url for this item is not available.";
     SendResponse(false);
     return;
   }
 
   SetResult(new base::StringValue(share_url.spec()));
   SendResponse(true);
 }
 
 }  // namespace extensions