chrome/browser/chromeos/file_system_provider/service.cc

   1 // Copyright 2014 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/file_system_provider/service.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/prefs/scoped_user_pref_update.h"
  10 #include "base/stl_util.h"
  11 #include "base/values.h"
  12 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
  13 #include "chrome/browser/chromeos/file_system_provider/observer.h"
  14 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
  15 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
  16 #include "chrome/browser/chromeos/file_system_provider/registry.h"
  17 #include "chrome/browser/chromeos/file_system_provider/registry_interface.h"
  18 #include "chrome/browser/chromeos/file_system_provider/service_factory.h"
  19 #include "chrome/browser/chromeos/file_system_provider/throttled_file_system.h"
  20 #include "extensions/browser/event_router.h"
  21 #include "extensions/browser/extension_registry.h"
  22 #include "extensions/browser/extension_system.h"
  23 #include "extensions/common/permissions/api_permission.h"
  24 #include "extensions/common/permissions/permissions_data.h"
  25 #include "storage/browser/fileapi/external_mount_points.h"
  26 #include "storage/common/fileapi/file_system_mount_option.h"
  27
  28 namespace chromeos {
  29 namespace file_system_provider {
  30 namespace {
  31
  32 // Maximum number of file systems to be mounted in the same time, per profile.
  33 const size_t kMaxFileSystems = 16;
  34
  35 // Default factory for provided file systems. |profile| must not be NULL.
  36 ProvidedFileSystemInterface* CreateProvidedFileSystem(
  37     Profile* profile,
  38     const ProvidedFileSystemInfo& file_system_info) {
  39   DCHECK(profile);
  40   return new ThrottledFileSystem(
  41       make_scoped_ptr(new ProvidedFileSystem(profile, file_system_info)));
  42 }
  43
  44 }  // namespace
  45
  46 ProvidingExtensionInfo::ProvidingExtensionInfo() {
  47 }
  48
  49 ProvidingExtensionInfo::~ProvidingExtensionInfo() {
  50 }
  51
  52 Service::Service(Profile* profile,
  53                  extensions::ExtensionRegistry* extension_registry)
  54     : profile_(profile),
  55       extension_registry_(extension_registry),
  56       file_system_factory_(base::Bind(&CreateProvidedFileSystem)),
  57       registry_(new Registry(profile)),
  58       weak_ptr_factory_(this) {
  59   extension_registry_->AddObserver(this);
  60 }
  61
  62 Service::~Service() {
  63   extension_registry_->RemoveObserver(this);
  64
  65   // Provided file systems should be already unmounted because of receiving
  66   // OnExtensionUnload calls for each installed extension. However, for tests
  67   // we may still have mounted extensions.
  68   // TODO(mtomasz): Create a TestingService class and remove this code.
  69   ProvidedFileSystemMap::iterator it = file_system_map_.begin();
  70   while (it != file_system_map_.end()) {
  71     const std::string file_system_id =
  72         it->second->GetFileSystemInfo().file_system_id();
  73     const std::string extension_id =
  74         it->second->GetFileSystemInfo().extension_id();
  75     ++it;
  76     const base::File::Error unmount_result = UnmountFileSystem(
  77         extension_id, file_system_id, UNMOUNT_REASON_SHUTDOWN);
  78     DCHECK_EQ(base::File::FILE_OK, unmount_result);
  79   }
  80
  81   DCHECK_EQ(0u, file_system_map_.size());
  82   STLDeleteValues(&file_system_map_);
  83 }
  84
  85 // static
  86 Service* Service::Get(content::BrowserContext* context) {
  87   return ServiceFactory::Get(context);
  88 }
  89
  90 void Service::AddObserver(Observer* observer) {
  91   DCHECK(observer);
  92   observers_.AddObserver(observer);
  93 }
  94
  95 void Service::RemoveObserver(Observer* observer) {
  96   DCHECK(observer);
  97   observers_.RemoveObserver(observer);
  98 }
  99
 100 void Service::SetFileSystemFactoryForTesting(
 101     const FileSystemFactoryCallback& factory_callback) {
 102   DCHECK(!factory_callback.is_null());
 103   file_system_factory_ = factory_callback;
 104 }
 105
 106 void Service::SetRegistryForTesting(scoped_ptr<RegistryInterface> registry) {
 107   DCHECK(registry);
 108   registry_.reset(registry.release());
 109 }
 110
 111 base::File::Error Service::MountFileSystem(const std::string& extension_id,
 112                                            const MountOptions& options) {
 113   return MountFileSystemInternal(extension_id, options, MOUNT_CONTEXT_USER);
 114 }
 115
 116 base::File::Error Service::MountFileSystemInternal(
 117     const std::string& extension_id,
 118     const MountOptions& options,
 119     MountContext context) {
 120   DCHECK(thread_checker_.CalledOnValidThread());
 121
 122   // If already exists a file system provided by the same extension with this
 123   // id, then abort.
 124   if (GetProvidedFileSystem(extension_id, options.file_system_id)) {
 125     FOR_EACH_OBSERVER(
 126         Observer, observers_,
 127         OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
 128                                   base::File::FILE_ERROR_EXISTS));
 129     return base::File::FILE_ERROR_EXISTS;
 130   }
 131
 132   // Restrict number of file systems to prevent system abusing.
 133   if (file_system_map_.size() + 1 > kMaxFileSystems) {
 134     FOR_EACH_OBSERVER(
 135         Observer, observers_,
 136         OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
 137                                   base::File::FILE_ERROR_TOO_MANY_OPENED));
 138     return base::File::FILE_ERROR_TOO_MANY_OPENED;
 139   }
 140
 141   storage::ExternalMountPoints* const mount_points =
 142       storage::ExternalMountPoints::GetSystemInstance();
 143   DCHECK(mount_points);
 144
 145   // The mount point path and name are unique per system, since they are system
 146   // wide. This is necessary for copying between profiles.
 147   const base::FilePath& mount_path =
 148       util::GetMountPath(profile_, extension_id, options.file_system_id);
 149   const std::string mount_point_name = mount_path.BaseName().AsUTF8Unsafe();
 150
 151   if (!mount_points->RegisterFileSystem(
 152           mount_point_name, storage::kFileSystemTypeProvided,
 153           storage::FileSystemMountOption(
 154               storage::FlushPolicy::FLUSH_ON_COMPLETION),
 155           mount_path)) {
 156     FOR_EACH_OBSERVER(
 157         Observer, observers_,
 158         OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
 159                                   base::File::FILE_ERROR_INVALID_OPERATION));
 160     return base::File::FILE_ERROR_INVALID_OPERATION;
 161   }
 162
 163   ProvidingExtensionInfo provider_info;
 164   // TODO(mtomasz): Set up a testing extension in unit tests.
 165   GetProvidingExtensionInfo(extension_id, &provider_info);
 166   // Store the file system descriptor. Use the mount point name as the file
 167   // system provider file system id.
 168   // Examples:
 169   //   file_system_id = hello_world
 170   //   mount_point_name =  b33f1337-hello_world-5aa5
 171   //   writable = false
 172   //   supports_notify_tag = false
 173   //   mount_path = /provided/b33f1337-hello_world-5aa5
 174   //   configurable = true
 175   //   watchable = true
 176   //   source = SOURCE_FILE
 177   ProvidedFileSystemInfo file_system_info(
 178       extension_id, options, mount_path,
 179       provider_info.capabilities.configurable(),
 180       provider_info.capabilities.watchable(),
 181       provider_info.capabilities.source());
 182
 183   ProvidedFileSystemInterface* file_system =
 184       file_system_factory_.Run(profile_, file_system_info);
 185   DCHECK(file_system);
 186   file_system_map_[FileSystemKey(extension_id, options.file_system_id)] =
 187       file_system;
 188   mount_point_name_to_key_map_[mount_point_name] =
 189       FileSystemKey(extension_id, options.file_system_id);
 190   registry_->RememberFileSystem(file_system_info, *file_system->GetWatchers());
 191
 192   FOR_EACH_OBSERVER(Observer, observers_,
 193                     OnProvidedFileSystemMount(file_system_info, context,
 194                                               base::File::FILE_OK));
 195
 196   return base::File::FILE_OK;
 197 }
 198
 199 base::File::Error Service::UnmountFileSystem(const std::string& extension_id,
 200                                              const std::string& file_system_id,
 201                                              UnmountReason reason) {
 202   DCHECK(thread_checker_.CalledOnValidThread());
 203
 204   const ProvidedFileSystemMap::iterator file_system_it =
 205       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
 206   if (file_system_it == file_system_map_.end()) {
 207     const ProvidedFileSystemInfo empty_file_system_info;
 208     FOR_EACH_OBSERVER(
 209         Observer,
 210         observers_,
 211         OnProvidedFileSystemUnmount(empty_file_system_info,
 212                                     base::File::FILE_ERROR_NOT_FOUND));
 213     return base::File::FILE_ERROR_NOT_FOUND;
 214   }
 215
 216   storage::ExternalMountPoints* const mount_points =
 217       storage::ExternalMountPoints::GetSystemInstance();
 218   DCHECK(mount_points);
 219
 220   const ProvidedFileSystemInfo& file_system_info =
 221       file_system_it->second->GetFileSystemInfo();
 222
 223   const std::string mount_point_name =
 224       file_system_info.mount_path().BaseName().value();
 225   if (!mount_points->RevokeFileSystem(mount_point_name)) {
 226     FOR_EACH_OBSERVER(
 227         Observer,
 228         observers_,
 229         OnProvidedFileSystemUnmount(file_system_info,
 230                                     base::File::FILE_ERROR_INVALID_OPERATION));
 231     return base::File::FILE_ERROR_INVALID_OPERATION;
 232   }
 233
 234   FOR_EACH_OBSERVER(
 235       Observer,
 236       observers_,
 237       OnProvidedFileSystemUnmount(file_system_info, base::File::FILE_OK));
 238
 239   mount_point_name_to_key_map_.erase(mount_point_name);
 240
 241   if (reason == UNMOUNT_REASON_USER) {
 242     registry_->ForgetFileSystem(file_system_info.extension_id(),
 243                                 file_system_info.file_system_id());
 244   }
 245
 246   delete file_system_it->second;
 247   file_system_map_.erase(file_system_it);
 248
 249   return base::File::FILE_OK;
 250 }
 251
 252 bool Service::RequestUnmount(const std::string& extension_id,
 253                              const std::string& file_system_id) {
 254   DCHECK(thread_checker_.CalledOnValidThread());
 255
 256   ProvidedFileSystemMap::iterator file_system_it =
 257       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
 258   if (file_system_it == file_system_map_.end())
 259     return false;
 260
 261   file_system_it->second->RequestUnmount(
 262       base::Bind(&Service::OnRequestUnmountStatus,
 263                  weak_ptr_factory_.GetWeakPtr(),
 264                  file_system_it->second->GetFileSystemInfo()));
 265   return true;
 266 }
 267
 268 bool Service::RequestMount(const std::string& extension_id) {
 269   DCHECK(thread_checker_.CalledOnValidThread());
 270
 271   extensions::EventRouter* const event_router =
 272       extensions::EventRouter::Get(profile_);
 273   DCHECK(event_router);
 274
 275   if (!event_router->ExtensionHasEventListener(
 276           extension_id, extensions::api::file_system_provider::
 277                             OnMountRequested::kEventName)) {
 278     return false;
 279   }
 280
 281   event_router->DispatchEventToExtension(
 282       extension_id,
 283       make_scoped_ptr(new extensions::Event(
 284           extensions::events::FILE_SYSTEM_PROVIDER_ON_MOUNT_REQUESTED,
 285           extensions::api::file_system_provider::OnMountRequested::kEventName,
 286           scoped_ptr<base::ListValue>(new base::ListValue()))));
 287
 288   return true;
 289 }
 290
 291 std::vector<ProvidedFileSystemInfo> Service::GetProvidedFileSystemInfoList() {
 292   DCHECK(thread_checker_.CalledOnValidThread());
 293
 294   std::vector<ProvidedFileSystemInfo> result;
 295   for (ProvidedFileSystemMap::const_iterator it = file_system_map_.begin();
 296        it != file_system_map_.end();
 297        ++it) {
 298     result.push_back(it->second->GetFileSystemInfo());
 299   }
 300   return result;
 301 }
 302
 303 ProvidedFileSystemInterface* Service::GetProvidedFileSystem(
 304     const std::string& extension_id,
 305     const std::string& file_system_id) {
 306   DCHECK(thread_checker_.CalledOnValidThread());
 307
 308   const ProvidedFileSystemMap::const_iterator file_system_it =
 309       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
 310   if (file_system_it == file_system_map_.end())
 311     return NULL;
 312
 313   return file_system_it->second;
 314 }
 315
 316 std::vector<ProvidingExtensionInfo> Service::GetProvidingExtensionInfoList()
 317     const {
 318   extensions::ExtensionRegistry* const registry =
 319       extensions::ExtensionRegistry::Get(profile_);
 320   DCHECK(registry);
 321
 322   std::vector<ProvidingExtensionInfo> result;
 323   for (const auto& extension : registry->enabled_extensions()) {
 324     ProvidingExtensionInfo info;
 325     if (GetProvidingExtensionInfo(extension->id(), &info))
 326       result.push_back(info);
 327   }
 328
 329   return result;
 330 }
 331
 332 bool Service::GetProvidingExtensionInfo(const std::string& extension_id,
 333                                         ProvidingExtensionInfo* result) const {
 334   DCHECK(result);
 335   extensions::ExtensionRegistry* const registry =
 336       extensions::ExtensionRegistry::Get(profile_);
 337   DCHECK(registry);
 338
 339   const extensions::Extension* const extension = registry->GetExtensionById(
 340       extension_id, extensions::ExtensionRegistry::ENABLED);
 341   if (!extension ||
 342       !extension->permissions_data()->HasAPIPermission(
 343           extensions::APIPermission::kFileSystemProvider)) {
 344     return false;
 345   }
 346
 347   result->extension_id = extension->id();
 348   result->name = extension->name();
 349   const extensions::FileSystemProviderCapabilities* const capabilities =
 350       extensions::FileSystemProviderCapabilities::Get(extension);
 351   DCHECK(capabilities);
 352   result->capabilities = *capabilities;
 353
 354   return true;
 355 }
 356
 357 void Service::OnExtensionUnloaded(
 358     content::BrowserContext* browser_context,
 359     const extensions::Extension* extension,
 360     extensions::UnloadedExtensionInfo::Reason reason) {
 361   // Unmount all of the provided file systems associated with this extension.
 362   ProvidedFileSystemMap::iterator it = file_system_map_.begin();
 363   while (it != file_system_map_.end()) {
 364     const ProvidedFileSystemInfo& file_system_info =
 365         it->second->GetFileSystemInfo();
 366     // Advance the iterator beforehand, otherwise it will become invalidated
 367     // by the UnmountFileSystem() call.
 368     ++it;
 369     if (file_system_info.extension_id() == extension->id()) {
 370       const base::File::Error unmount_result = UnmountFileSystem(
 371           file_system_info.extension_id(), file_system_info.file_system_id(),
 372           reason == extensions::UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN
 373               ? UNMOUNT_REASON_SHUTDOWN
 374               : UNMOUNT_REASON_USER);
 375       DCHECK_EQ(base::File::FILE_OK, unmount_result);
 376     }
 377   }
 378 }
 379
 380 void Service::OnExtensionLoaded(content::BrowserContext* browser_context,
 381                                 const extensions::Extension* extension) {
 382   scoped_ptr<RegistryInterface::RestoredFileSystems> restored_file_systems =
 383       registry_->RestoreFileSystems(extension->id());
 384
 385   for (const auto& restored_file_system : *restored_file_systems) {
 386     const base::File::Error result = MountFileSystemInternal(
 387         restored_file_system.extension_id, restored_file_system.options,
 388         MOUNT_CONTEXT_RESTORE);
 389     if (result != base::File::FILE_OK) {
 390       LOG(ERROR) << "Failed to restore a provided file system from "
 391                  << "registry: " << restored_file_system.extension_id << ", "
 392                  << restored_file_system.options.file_system_id << ", "
 393                  << restored_file_system.options.display_name << ".";
 394       // Since remounting of the file system failed, then remove it from
 395       // preferences to avoid remounting it over and over again with a failure.
 396       registry_->ForgetFileSystem(restored_file_system.extension_id,
 397                                   restored_file_system.options.file_system_id);
 398       continue;
 399     }
 400
 401     ProvidedFileSystemInterface* const file_system =
 402         GetProvidedFileSystem(restored_file_system.extension_id,
 403                               restored_file_system.options.file_system_id);
 404     DCHECK(file_system);
 405     file_system->GetWatchers()->insert(restored_file_system.watchers.begin(),
 406                                        restored_file_system.watchers.end());
 407   }
 408 }
 409
 410 ProvidedFileSystemInterface* Service::GetProvidedFileSystem(
 411     const std::string& mount_point_name) {
 412   DCHECK(thread_checker_.CalledOnValidThread());
 413
 414   const MountPointNameToKeyMap::const_iterator mapping_it =
 415       mount_point_name_to_key_map_.find(mount_point_name);
 416   if (mapping_it == mount_point_name_to_key_map_.end())
 417     return NULL;
 418
 419   const ProvidedFileSystemMap::const_iterator file_system_it =
 420       file_system_map_.find(mapping_it->second);
 421   if (file_system_it == file_system_map_.end())
 422     return NULL;
 423
 424   return file_system_it->second;
 425 }
 426
 427 void Service::OnRequestUnmountStatus(
 428     const ProvidedFileSystemInfo& file_system_info,
 429     base::File::Error error) {
 430   // Notify observers about failure in unmounting, since mount() will not be
 431   // called by the provided file system. In case of success mount() will be
 432   // invoked, and observers notified, so there is no need to call them now.
 433   if (error != base::File::FILE_OK) {
 434     FOR_EACH_OBSERVER(Observer,
 435                       observers_,
 436                       OnProvidedFileSystemUnmount(file_system_info, error));
 437   }
 438 }
 439
 440 void Service::OnWatcherChanged(const ProvidedFileSystemInfo& file_system_info,
 441                                const Watcher& watcher,
 442                                storage::WatcherManager::ChangeType change_type,
 443                                const Changes& changes,
 444                                const base::Closure& callback) {
 445   callback.Run();
 446 }
 447
 448 void Service::OnWatcherTagUpdated(
 449     const ProvidedFileSystemInfo& file_system_info,
 450     const Watcher& watcher) {
 451   PrefService* const pref_service = profile_->GetPrefs();
 452   DCHECK(pref_service);
 453
 454   registry_->UpdateWatcherTag(file_system_info, watcher);
 455 }
 456
 457 void Service::OnWatcherListChanged(
 458     const ProvidedFileSystemInfo& file_system_info,
 459     const Watchers& watchers) {
 460   registry_->RememberFileSystem(file_system_info, watchers);
 461 }
 462
 463 }  // namespace file_system_provider
 464 }  // namespace chromeos