Rename GDataSystemService to DriveSystemService

chrome/browser/chromeos/extensions/file_browser_private_api.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/extensions/file_browser_private_api.h"
 
 #include <sys/statvfs.h>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/singleton.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/extensions/file_handler_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
+#include "chrome/browser/chromeos/gdata/drive_system_service.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
-#include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "chrome/browser/chromeos/gdata/operation_registry.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 155 matching lines @@
   if (!render_view_host || !render_view_host->GetProcess())
     return;
 
   // Grant R/W permissions to gdata 'folder'. File API layer still
   // expects this to be satisfied.
   GrantFilePermissionsToHost(render_view_host,
                              mount_point,
                              file_handler_util::GetReadWritePermissions());
 
   // Grant R/W permission for tmp and pinned cache folder.
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile);
   // |system_service| is NULL if incognito window / guest login.
   if (!system_service || !system_service->file_system())
     return;
   gdata::DriveCache* cache = system_service->cache();
 
   // 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.
   GrantFilePermissionsToHost(render_view_host,
@@ skipping 391 matching lines @@
 // apps and add them, with generated task ids. Extension ids will be the app_ids
 // from drive. We'll know that they are drive apps because the extension id will
 // begin with kDriveTaskExtensionPrefix.
 bool GetFileTasksFileBrowserFunction::FindDriveAppTasks(
     const FileInfoList& file_info_list,
     ListValue* result_list) {
 
   if (file_info_list.empty())
     return true;
 
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if incognito window / guest login. We return true
   // in this case because there might be other extension tasks, even if we don't
   // have any to add.
   if (!system_service || !system_service->webapps_registry())
     return true;
 
 
   gdata::DriveWebAppsRegistry* registry = system_service->webapps_registry();
 
   // Map of app_id to DriveWebAppInfo so we can look up the apps we've found
@@ skipping 482 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!files.size()) {
     SendResponse(false);
     return;
   }
 
   const FilePath& source_path = files[0].local_path;
   const FilePath::StringType& display_name = files[0].display_name;
   // Check if the source path is under GData cache directory.
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   gdata::DriveCache* cache = system_service ? system_service->cache() : NULL;
   if (cache && cache->IsUnderDriveCacheDirectory(source_path)) {
     cache->SetMountedStateOnUIThread(
         source_path,
         true,
         base::Bind(&AddMountFunction::OnMountedStateSet, this, mount_type_str,
                    display_name));
   } else {
     OnMountedStateSet(mount_type_str, display_name,
                       gdata::DRIVE_FILE_OK, source_path);
@@ skipping 108 matching lines @@
 void GetSizeStatsFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
   if (files[0].file_path == gdata::util::GetGDataMountPointPath()) {
-    gdata::GDataSystemService* system_service =
-        gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+    gdata::DriveSystemService* system_service =
+        gdata::DriveSystemServiceFactory::GetForProfile(profile_);
 
     gdata::DriveFileSystemInterface* file_system =
         system_service->file_system();
 
     file_system->GetAvailableSpace(
         base::Bind(&GetSizeStatsFunction::GetGDataAvailableSpaceCallback,
                    this));
 
   } else {
     BrowserThread::PostTask(
@@ skipping 519 matching lines @@
   std::string file_str;
   path_list_->GetString(current_index_, &file_str);
   GURL file_url = GURL(file_str);
   FilePath file_path = GetVirtualPathFromURL(file_url);
 
   base::DictionaryValue* property_dict = new base::DictionaryValue;
   property_dict->SetString("fileUrl", file_url.spec());
   file_properties_->Append(property_dict);
 
   // Start getting the file info.
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   system_service->file_system()->GetEntryInfoByPath(
       file_path,
       base::Bind(&GetGDataFilePropertiesFunction::OnGetFileInfo,
                  this,
                  file_path,
                  property_dict));
 }
 
 void GetGDataFilePropertiesFunction::CompleteGetFileProperties() {
   current_index_++;
@@ skipping 43 matching lines @@
   if (!entry_proto->content_url().empty()) {
     property_dict->SetString("contentUrl", entry_proto->content_url());
   }
 
   property_dict->SetBoolean("isHosted",
                             file_specific_info.is_hosted_document());
 
   property_dict->SetString("contentMimeType",
                            file_specific_info.content_mime_type());
 
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
 
   // Get drive WebApps that can accept this file.
   ScopedVector<gdata::DriveWebAppInfo> web_apps;
   system_service->webapps_registry()->GetWebAppsForFile(
           file_path, file_specific_info.content_mime_type(), &web_apps);
   if (!web_apps.empty()) {
     ListValue* apps = new ListValue();
     property_dict->Set("driveApps", apps);
     for (ScopedVector<gdata::DriveWebAppInfo>::const_iterator it =
              web_apps.begin();
@@ skipping 62 matching lines @@
 
   return true;
 }
 
 void PinGDataFileFunction::DoOperation(
     const FilePath& file_path,
     base::DictionaryValue* properties,
     scoped_ptr<gdata::DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   // This is subtle but we should take references of resource_id and md5
   // before |file_info| is passed to |callback| by base::Passed(). Otherwise,
   // file_info->whatever() crashes.
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& md5 = entry_proto->file_specific_info().file_md5();
   const gdata::CacheOperationCallback callback =
       base::Bind(&PinGDataFileFunction::OnPinStateSet,
                  this,
                  file_path,
                  properties,
@@ skipping 104 matching lines @@
 }
 
 void GetGDataFilesFunction::GetFileOrSendResponse() {
   // Send the response if all files are obtained.
   if (remaining_gdata_paths_.empty()) {
     SetResult(local_paths_);
     SendResponse(true);
     return;
   }
 
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   DCHECK(system_service);
 
   // Get the file on the top of the queue.
   FilePath gdata_path = remaining_gdata_paths_.front();
   system_service->file_system()->GetFileByPath(
       gdata_path,
       base::Bind(&GetGDataFilesFunction::OnFileReady, this),
       gdata::GetContentCallback());
 }
 
@@ skipping 24 matching lines @@
 
   // Start getting the next file.
   GetFileOrSendResponse();
 }
 
 GetFileTransfersFunction::GetFileTransfersFunction() {}
 
 GetFileTransfersFunction::~GetFileTransfersFunction() {}
 
 ListValue* GetFileTransfersFunction::GetFileTransfersList() {
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service)
     return NULL;
 
   std::vector<gdata::OperationRegistry::ProgressStatus>
       list = system_service->drive_service()->operation_registry()->
       GetProgressStatusList();
   return file_manager_util::ProgressStatusVectorToListValue(
       profile_, source_url_.GetOrigin(), list);
 }
 
@@ skipping 33 matching lines @@
   GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
       file_urls,
       base::Bind(&CancelFileTransfersFunction::GetLocalPathsResponseOnUIThread,
                  this));
   return true;
 }
 
 void CancelFileTransfersFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service) {
     SendResponse(false);
     return;
   }
 
   gdata::OperationRegistry* operation_registry =
       system_service->drive_service()->operation_registry();
 
   scoped_ptr<ListValue> responses(new ListValue());
   for (size_t i = 0; i < files.size(); ++i) {
@@ skipping 41 matching lines @@
 }
 
 void TransferFileFunction::GetLocalPathsResponseOnUIThread(
     const SelectedFileInfoList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (files.size() != 2U) {
     SendResponse(false);
     return;
   }
 
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service) {
     SendResponse(false);
     return;
   }
 
   FilePath source_file = files[0].file_path;
   FilePath destination_file = files[1].file_path;
 
   bool source_file_under_gdata =
       gdata::util::IsUnderGDataMountPoint(source_file);
@@ skipping 100 matching lines @@
     const std::string& file_system_name,
     const GURL& file_system_url) {
   if (result != base::PLATFORM_FILE_OK) {
     SendResponse(false);
     return;
   }
 
   file_system_name_ = file_system_name;
   file_system_url_ = file_system_url;
 
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system()) {
     SendResponse(false);
     return;
   }
 
   system_service->file_system()->Search(
       query_, GURL(next_feed_),
       base::Bind(&SearchDriveFunction::OnSearch, this));
 }
 
@@ skipping 22 matching lines @@
 
   base::DictionaryValue* result = new DictionaryValue();
   result->Set("entries", entries);
   result->SetString("nextFeed", next_feed.spec());
 
   SetResult(result);
   SendResponse(true);
 }
 
 bool ClearDriveCacheFunction::RunImpl() {
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if incognito window / guest login.
   if (!system_service || !system_service->file_system())
     return false;
 
   // TODO(yoshiki): Receive a callback from JS-side and pass it to
   // ClearCacheAndRemountFileSystem(). http://crbug.com/140511
   system_service->ClearCacheAndRemountFileSystem(base::Callback<void(bool)>());
 
   SendResponse(true);
   return true;
@@ skipping 22 matching lines @@
   SetResult(value.release());
 
   return true;
 }
 
 bool RequestDirectoryRefreshFunction::RunImpl() {
   std::string file_url_as_string;
   if (!args_->GetString(0, &file_url_as_string))
     return false;
 
-  gdata::GDataSystemService* system_service =
-      gdata::GDataSystemServiceFactory::GetForProfile(profile_);
+  gdata::DriveSystemService* system_service =
+      gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system())
     return false;
 
   FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }