chrome/browser/chromeos/drive/file_system_util.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/drive/file_system_util.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/files/file_path.h"
  14 #include "base/files/file_util.h"
  15 #include "base/i18n/icu_string_conversions.h"
  16 #include "base/json/json_file_value_serializer.h"
  17 #include "base/logging.h"
  18 #include "base/memory/scoped_ptr.h"
  19 #include "base/prefs/pref_service.h"
  20 #include "base/strings/string_number_conversions.h"
  21 #include "base/strings/string_util.h"
  22 #include "base/strings/stringprintf.h"
  23 #include "base/thread_task_runner_handle.h"
  24 #include "base/threading/sequenced_worker_pool.h"
  25 #include "chrome/browser/browser_process.h"
  26 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
  27 #include "chrome/browser/chromeos/drive/write_on_cache_file.h"
  28 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  29 #include "chrome/browser/chromeos/profiles/profile_util.h"
  30 #include "chrome/browser/profiles/profile.h"
  31 #include "chrome/browser/profiles/profile_manager.h"
  32 #include "chrome/common/chrome_constants.h"
  33 #include "chrome/common/chrome_paths_internal.h"
  34 #include "chromeos/chromeos_constants.h"
  35 #include "components/drive/drive.pb.h"
  36 #include "components/drive/drive_pref_names.h"
  37 #include "components/drive/file_system_core_util.h"
  38 #include "components/drive/file_system_interface.h"
  39 #include "components/drive/job_list.h"
  40 #include "components/user_manager/user_manager.h"
  41 #include "content/public/browser/browser_thread.h"
  42 #include "net/base/escape.h"
  43 #include "storage/browser/fileapi/file_system_url.h"
  44
  45 using content::BrowserThread;
  46
  47 namespace drive {
  48 namespace util {
  49
  50 namespace {
  51
  52 // Returns DriveIntegrationService instance, if Drive is enabled.
  53 // Otherwise, NULL.
  54 DriveIntegrationService* GetIntegrationServiceByProfile(Profile* profile) {
  55   DriveIntegrationService* service =
  56       DriveIntegrationServiceFactory::FindForProfile(profile);
  57   if (!service || !service->IsMounted())
  58     return NULL;
  59   return service;
  60 }
  61
  62 }  // namespace
  63
  64 base::FilePath GetDriveMountPointPath(Profile* profile) {
  65   std::string id = chromeos::ProfileHelper::GetUserIdHashFromProfile(profile);
  66   if (id.empty() || id == chrome::kLegacyProfileDir) {
  67     // ProfileHelper::GetUserIdHashFromProfile works only when multi-profile is
  68     // enabled. In that case, we fall back to use UserManager (it basically just
  69     // returns currently active users's hash in such a case.) I still try
  70     // ProfileHelper first because it works better in tests.
  71     const user_manager::User* const user =
  72         user_manager::UserManager::IsInitialized()
  73             ? chromeos::ProfileHelper::Get()->GetUserByProfile(
  74                   profile->GetOriginalProfile())
  75             : NULL;
  76     if (user)
  77       id = user->username_hash();
  78   }
  79   return GetDriveMountPointPathForUserIdHash(id);
  80 }
  81
  82 base::FilePath GetDriveMountPointPathForUserIdHash(
  83     const std::string user_id_hash) {
  84   static const base::FilePath::CharType kSpecialMountPointRoot[] =
  85       FILE_PATH_LITERAL("/special");
  86   static const char kDriveMountPointNameBase[] = "drive";
  87   return base::FilePath(kSpecialMountPointRoot)
  88       .AppendASCII(net::EscapeQueryParamValue(
  89           kDriveMountPointNameBase +
  90               (user_id_hash.empty() ? "" : "-" + user_id_hash),
  91           false));
  92 }
  93
  94 bool IsUnderDriveMountPoint(const base::FilePath& path) {
  95   return !ExtractDrivePath(path).empty();
  96 }
  97
  98 base::FilePath ExtractDrivePath(const base::FilePath& path) {
  99   std::vector<base::FilePath::StringType> components;
 100   path.GetComponents(&components);
 101   if (components.size() < 3)
 102     return base::FilePath();
 103   if (components[0] != FILE_PATH_LITERAL("/"))
 104     return base::FilePath();
 105   if (components[1] != FILE_PATH_LITERAL("special"))
 106     return base::FilePath();
 107   static const base::FilePath::CharType kPrefix[] = FILE_PATH_LITERAL("drive");
 108   if (components[2].compare(0, arraysize(kPrefix) - 1, kPrefix) != 0)
 109     return base::FilePath();
 110
 111   base::FilePath drive_path = GetDriveGrandRootPath();
 112   for (size_t i = 3; i < components.size(); ++i)
 113     drive_path = drive_path.Append(components[i]);
 114   return drive_path;
 115 }
 116
 117 FileSystemInterface* GetFileSystemByProfile(Profile* profile) {
 118   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 119
 120   DriveIntegrationService* integration_service =
 121       GetIntegrationServiceByProfile(profile);
 122   return integration_service ? integration_service->file_system() : NULL;
 123 }
 124
 125 FileSystemInterface* GetFileSystemByProfileId(void* profile_id) {
 126   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 127
 128   // |profile_id| needs to be checked with ProfileManager::IsValidProfile
 129   // before using it.
 130   Profile* profile = reinterpret_cast<Profile*>(profile_id);
 131   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
 132     return NULL;
 133   return GetFileSystemByProfile(profile);
 134 }
 135
 136 DriveAppRegistry* GetDriveAppRegistryByProfile(Profile* profile) {
 137   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 138
 139   DriveIntegrationService* integration_service =
 140       GetIntegrationServiceByProfile(profile);
 141   return integration_service ? integration_service->drive_app_registry() : NULL;
 142 }
 143
 144 DriveServiceInterface* GetDriveServiceByProfile(Profile* profile) {
 145   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 146
 147   DriveIntegrationService* integration_service =
 148       GetIntegrationServiceByProfile(profile);
 149   return integration_service ? integration_service->drive_service() : NULL;
 150 }
 151
 152 Profile* ExtractProfileFromPath(const base::FilePath& path) {
 153   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 154
 155   const std::vector<Profile*>& profiles =
 156       g_browser_process->profile_manager()->GetLoadedProfiles();
 157   for (size_t i = 0; i < profiles.size(); ++i) {
 158     Profile* original_profile = profiles[i]->GetOriginalProfile();
 159     if (original_profile == profiles[i] &&
 160         !chromeos::ProfileHelper::IsSigninProfile(original_profile)) {
 161       const base::FilePath base = GetDriveMountPointPath(original_profile);
 162       if (base == path || base.IsParent(path))
 163         return original_profile;
 164     }
 165   }
 166   return NULL;
 167 }
 168
 169 base::FilePath ExtractDrivePathFromFileSystemUrl(
 170     const storage::FileSystemURL& url) {
 171   if (!url.is_valid() || url.type() != storage::kFileSystemTypeDrive)
 172     return base::FilePath();
 173   return ExtractDrivePath(url.path());
 174 }
 175
 176 base::FilePath GetCacheRootPath(Profile* profile) {
 177   base::FilePath cache_base_path;
 178   chrome::GetUserCacheDirectory(profile->GetPath(), &cache_base_path);
 179   base::FilePath cache_root_path =
 180       cache_base_path.Append(chromeos::kDriveCacheDirname);
 181   static const base::FilePath::CharType kFileCacheVersionDir[] =
 182       FILE_PATH_LITERAL("v1");
 183   return cache_root_path.Append(kFileCacheVersionDir);
 184 }
 185
 186 void PrepareWritableFileAndRun(Profile* profile,
 187                                const base::FilePath& path,
 188                                const PrepareWritableFileCallback& callback) {
 189   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 190   DCHECK(!callback.is_null());
 191
 192   FileSystemInterface* file_system = GetFileSystemByProfile(profile);
 193   if (!file_system || !IsUnderDriveMountPoint(path)) {
 194     content::BrowserThread::GetBlockingPool()->PostTask(
 195         FROM_HERE, base::Bind(callback, FILE_ERROR_FAILED, base::FilePath()));
 196     return;
 197   }
 198
 199   WriteOnCacheFile(file_system, ExtractDrivePath(path),
 200                    std::string(),  // mime_type
 201                    callback);
 202 }
 203
 204 void EnsureDirectoryExists(Profile* profile,
 205                            const base::FilePath& directory,
 206                            const FileOperationCallback& callback) {
 207   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 208   DCHECK(!callback.is_null());
 209   if (IsUnderDriveMountPoint(directory)) {
 210     FileSystemInterface* file_system = GetFileSystemByProfile(profile);
 211     DCHECK(file_system);
 212     file_system->CreateDirectory(ExtractDrivePath(directory),
 213                                  true /* is_exclusive */,
 214                                  true /* is_recursive */, callback);
 215   } else {
 216     base::ThreadTaskRunnerHandle::Get()->PostTask(
 217         FROM_HERE, base::Bind(callback, FILE_ERROR_OK));
 218   }
 219 }
 220
 221 bool IsDriveEnabledForProfile(Profile* profile) {
 222   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 223
 224   if (!chromeos::IsProfileAssociatedWithGaiaAccount(profile))
 225     return false;
 226
 227   // Disable Drive if preference is set. This can happen with commandline flag
 228   // --disable-drive or enterprise policy, or with user settings.
 229   if (profile->GetPrefs()->GetBoolean(prefs::kDisableDrive))
 230     return false;
 231
 232   return true;
 233 }
 234
 235 ConnectionStatusType GetDriveConnectionStatus(Profile* profile) {
 236   drive::DriveServiceInterface* const drive_service =
 237       drive::util::GetDriveServiceByProfile(profile);
 238
 239   if (!drive_service)
 240     return DRIVE_DISCONNECTED_NOSERVICE;
 241   if (net::NetworkChangeNotifier::IsOffline())
 242     return DRIVE_DISCONNECTED_NONETWORK;
 243   if (!drive_service->CanSendRequest())
 244     return DRIVE_DISCONNECTED_NOTREADY;
 245
 246   const bool is_connection_cellular =
 247       net::NetworkChangeNotifier::IsConnectionCellular(
 248           net::NetworkChangeNotifier::GetConnectionType());
 249   const bool disable_sync_over_celluar =
 250       profile->GetPrefs()->GetBoolean(prefs::kDisableDriveOverCellular);
 251
 252   if (is_connection_cellular && disable_sync_over_celluar)
 253     return DRIVE_CONNECTED_METERED;
 254   return DRIVE_CONNECTED;
 255 }
 256
 257 }  // namespace util
 258 }  // namespace drive