chrome/browser/chromeos/file_system_provider/provided_file_system.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/provided_file_system.h"
   6
   7 #include <vector>
   8
   9 #include "base/files/file.h"
  10 #include "base/trace_event/trace_event.h"
  11 #include "chrome/browser/chromeos/file_system_provider/notification_manager.h"
  12 #include "chrome/browser/chromeos/file_system_provider/operations/abort.h"
  13 #include "chrome/browser/chromeos/file_system_provider/operations/add_watcher.h"
  14 #include "chrome/browser/chromeos/file_system_provider/operations/close_file.h"
  15 #include "chrome/browser/chromeos/file_system_provider/operations/configure.h"
  16 #include "chrome/browser/chromeos/file_system_provider/operations/copy_entry.h"
  17 #include "chrome/browser/chromeos/file_system_provider/operations/create_directory.h"
  18 #include "chrome/browser/chromeos/file_system_provider/operations/create_file.h"
  19 #include "chrome/browser/chromeos/file_system_provider/operations/delete_entry.h"
  20 #include "chrome/browser/chromeos/file_system_provider/operations/execute_action.h"
  21 #include "chrome/browser/chromeos/file_system_provider/operations/get_actions.h"
  22 #include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h"
  23 #include "chrome/browser/chromeos/file_system_provider/operations/move_entry.h"
  24 #include "chrome/browser/chromeos/file_system_provider/operations/open_file.h"
  25 #include "chrome/browser/chromeos/file_system_provider/operations/read_directory.h"
  26 #include "chrome/browser/chromeos/file_system_provider/operations/read_file.h"
  27 #include "chrome/browser/chromeos/file_system_provider/operations/remove_watcher.h"
  28 #include "chrome/browser/chromeos/file_system_provider/operations/truncate.h"
  29 #include "chrome/browser/chromeos/file_system_provider/operations/unmount.h"
  30 #include "chrome/browser/chromeos/file_system_provider/operations/write_file.h"
  31 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
  32 #include "chrome/browser/profiles/profile.h"
  33 #include "chrome/common/extensions/api/file_system_provider.h"
  34 #include "extensions/browser/event_router.h"
  35
  36 namespace net {
  37 class IOBuffer;
  38 }  // namespace net
  39
  40 namespace chromeos {
  41 namespace file_system_provider {
  42 namespace {
  43
  44 // Discards the result of Abort() when called from the destructor.
  45 void EmptyStatusCallback(base::File::Error /* result */) {
  46 }
  47
  48 }  // namespace
  49
  50 AutoUpdater::AutoUpdater(const base::Closure& update_callback)
  51     : update_callback_(update_callback),
  52       created_callbacks_(0),
  53       pending_callbacks_(0) {
  54 }
  55
  56 base::Closure AutoUpdater::CreateCallback() {
  57   ++created_callbacks_;
  58   ++pending_callbacks_;
  59   return base::Bind(&AutoUpdater::OnPendingCallback, this);
  60 }
  61
  62 void AutoUpdater::OnPendingCallback() {
  63   DCHECK_LT(0, pending_callbacks_);
  64   if (--pending_callbacks_ == 0)
  65     update_callback_.Run();
  66 }
  67
  68 AutoUpdater::~AutoUpdater() {
  69   // If no callbacks are created, then we need to invoke updating in the
  70   // destructor.
  71   if (!created_callbacks_)
  72     update_callback_.Run();
  73   else if (pending_callbacks_)
  74     LOG(ERROR) << "Not all callbacks called. This may happen on shutdown.";
  75 }
  76
  77 struct ProvidedFileSystem::AddWatcherInQueueArgs {
  78   AddWatcherInQueueArgs(size_t token,
  79                         const GURL& origin,
  80                         const base::FilePath& entry_path,
  81                         bool recursive,
  82                         bool persistent,
  83                         const storage::AsyncFileUtil::StatusCallback& callback,
  84                         const storage::WatcherManager::NotificationCallback&
  85                             notification_callback)
  86       : token(token),
  87         origin(origin),
  88         entry_path(entry_path),
  89         recursive(recursive),
  90         persistent(persistent),
  91         callback(callback),
  92         notification_callback(notification_callback) {}
  93   ~AddWatcherInQueueArgs() {}
  94
  95   const size_t token;
  96   const GURL origin;
  97   const base::FilePath entry_path;
  98   const bool recursive;
  99   const bool persistent;
 100   const storage::AsyncFileUtil::StatusCallback callback;
 101   const storage::WatcherManager::NotificationCallback notification_callback;
 102 };
 103
 104 struct ProvidedFileSystem::NotifyInQueueArgs {
 105   NotifyInQueueArgs(size_t token,
 106                     const base::FilePath& entry_path,
 107                     bool recursive,
 108                     storage::WatcherManager::ChangeType change_type,
 109                     scoped_ptr<ProvidedFileSystemObserver::Changes> changes,
 110                     const std::string& tag,
 111                     const storage::AsyncFileUtil::StatusCallback& callback)
 112       : token(token),
 113         entry_path(entry_path),
 114         recursive(recursive),
 115         change_type(change_type),
 116         changes(changes.Pass()),
 117         tag(tag),
 118         callback(callback) {}
 119   ~NotifyInQueueArgs() {}
 120
 121   const size_t token;
 122   const base::FilePath entry_path;
 123   const bool recursive;
 124   const storage::WatcherManager::ChangeType change_type;
 125   const scoped_ptr<ProvidedFileSystemObserver::Changes> changes;
 126   const std::string tag;
 127   const storage::AsyncFileUtil::StatusCallback callback;
 128
 129  private:
 130   DISALLOW_COPY_AND_ASSIGN(NotifyInQueueArgs);
 131 };
 132
 133 ProvidedFileSystem::ProvidedFileSystem(
 134     Profile* profile,
 135     const ProvidedFileSystemInfo& file_system_info)
 136     : profile_(profile),
 137       event_router_(extensions::EventRouter::Get(profile)),  // May be NULL.
 138       file_system_info_(file_system_info),
 139       notification_manager_(
 140           new NotificationManager(profile_, file_system_info_)),
 141       request_manager_(new RequestManager(profile,
 142                                           file_system_info.extension_id(),
 143                                           notification_manager_.get())),
 144       watcher_queue_(1),
 145       weak_ptr_factory_(this) {
 146 }
 147
 148 ProvidedFileSystem::~ProvidedFileSystem() {
 149   const std::vector<int> request_ids = request_manager_->GetActiveRequestIds();
 150   for (size_t i = 0; i < request_ids.size(); ++i) {
 151     Abort(request_ids[i]);
 152   }
 153 }
 154
 155 void ProvidedFileSystem::SetEventRouterForTesting(
 156     extensions::EventRouter* event_router) {
 157   event_router_ = event_router;
 158 }
 159
 160 void ProvidedFileSystem::SetNotificationManagerForTesting(
 161     scoped_ptr<NotificationManagerInterface> notification_manager) {
 162   notification_manager_ = notification_manager.Pass();
 163   request_manager_.reset(new RequestManager(
 164       profile_, file_system_info_.extension_id(), notification_manager_.get()));
 165 }
 166
 167 AbortCallback ProvidedFileSystem::RequestUnmount(
 168     const storage::AsyncFileUtil::StatusCallback& callback) {
 169   const int request_id = request_manager_->CreateRequest(
 170       REQUEST_UNMOUNT,
 171       scoped_ptr<RequestManager::HandlerInterface>(
 172           new operations::Unmount(event_router_, file_system_info_, callback)));
 173   if (!request_id) {
 174     callback.Run(base::File::FILE_ERROR_SECURITY);
 175     return AbortCallback();
 176   }
 177
 178   return base::Bind(
 179       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 180 }
 181
 182 AbortCallback ProvidedFileSystem::GetMetadata(
 183     const base::FilePath& entry_path,
 184     MetadataFieldMask fields,
 185     const GetMetadataCallback& callback) {
 186   const int request_id = request_manager_->CreateRequest(
 187       GET_METADATA,
 188       scoped_ptr<RequestManager::HandlerInterface>(new operations::GetMetadata(
 189           event_router_, file_system_info_, entry_path, fields, callback)));
 190   if (!request_id) {
 191     callback.Run(make_scoped_ptr<EntryMetadata>(NULL),
 192                  base::File::FILE_ERROR_SECURITY);
 193     return AbortCallback();
 194   }
 195
 196   return base::Bind(
 197       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 198 }
 199
 200 AbortCallback ProvidedFileSystem::GetActions(
 201     const base::FilePath& entry_path,
 202     const GetActionsCallback& callback) {
 203   const int request_id = request_manager_->CreateRequest(
 204       GET_ACTIONS,
 205       scoped_ptr<RequestManager::HandlerInterface>(new operations::GetActions(
 206           event_router_, file_system_info_, entry_path, callback)));
 207   if (!request_id) {
 208     callback.Run(Actions(), base::File::FILE_ERROR_SECURITY);
 209     return AbortCallback();
 210   }
 211
 212   return base::Bind(&ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(),
 213                     request_id);
 214 }
 215
 216 AbortCallback ProvidedFileSystem::ExecuteAction(
 217     const base::FilePath& entry_path,
 218     const std::string& action_id,
 219     const storage::AsyncFileUtil::StatusCallback& callback) {
 220   const int request_id = request_manager_->CreateRequest(
 221       EXECUTE_ACTION,
 222       scoped_ptr<RequestManager::HandlerInterface>(
 223           new operations::ExecuteAction(event_router_, file_system_info_,
 224                                         entry_path, action_id, callback)));
 225   if (!request_id) {
 226     callback.Run(base::File::FILE_ERROR_SECURITY);
 227     return AbortCallback();
 228   }
 229
 230   return base::Bind(&ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(),
 231                     request_id);
 232 }
 233
 234 AbortCallback ProvidedFileSystem::ReadDirectory(
 235     const base::FilePath& directory_path,
 236     const storage::AsyncFileUtil::ReadDirectoryCallback& callback) {
 237   const int request_id = request_manager_->CreateRequest(
 238       READ_DIRECTORY,
 239       scoped_ptr<RequestManager::HandlerInterface>(
 240           new operations::ReadDirectory(
 241               event_router_, file_system_info_, directory_path, callback)));
 242   if (!request_id) {
 243     callback.Run(base::File::FILE_ERROR_SECURITY,
 244                  storage::AsyncFileUtil::EntryList(),
 245                  false /* has_more */);
 246     return AbortCallback();
 247   }
 248
 249   return base::Bind(
 250       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 251 }
 252
 253 AbortCallback ProvidedFileSystem::ReadFile(
 254     int file_handle,
 255     net::IOBuffer* buffer,
 256     int64 offset,
 257     int length,
 258     const ReadChunkReceivedCallback& callback) {
 259   TRACE_EVENT1(
 260       "file_system_provider", "ProvidedFileSystem::ReadFile", "length", length);
 261   const int request_id = request_manager_->CreateRequest(
 262       READ_FILE,
 263       make_scoped_ptr<RequestManager::HandlerInterface>(
 264           new operations::ReadFile(event_router_,
 265                                    file_system_info_,
 266                                    file_handle,
 267                                    buffer,
 268                                    offset,
 269                                    length,
 270                                    callback)));
 271   if (!request_id) {
 272     callback.Run(0 /* chunk_length */,
 273                  false /* has_more */,
 274                  base::File::FILE_ERROR_SECURITY);
 275     return AbortCallback();
 276   }
 277
 278   return base::Bind(
 279       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 280 }
 281
 282 AbortCallback ProvidedFileSystem::OpenFile(const base::FilePath& file_path,
 283                                            OpenFileMode mode,
 284                                            const OpenFileCallback& callback) {
 285   const int request_id = request_manager_->CreateRequest(
 286       OPEN_FILE,
 287       scoped_ptr<RequestManager::HandlerInterface>(new operations::OpenFile(
 288           event_router_, file_system_info_, file_path, mode,
 289           base::Bind(&ProvidedFileSystem::OnOpenFileCompleted,
 290                      weak_ptr_factory_.GetWeakPtr(), file_path, mode,
 291                      callback))));
 292   if (!request_id) {
 293     callback.Run(0 /* file_handle */, base::File::FILE_ERROR_SECURITY);
 294     return AbortCallback();
 295   }
 296
 297   return base::Bind(
 298       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 299 }
 300
 301 AbortCallback ProvidedFileSystem::CloseFile(
 302     int file_handle,
 303     const storage::AsyncFileUtil::StatusCallback& callback) {
 304   const int request_id = request_manager_->CreateRequest(
 305       CLOSE_FILE,
 306       scoped_ptr<RequestManager::HandlerInterface>(new operations::CloseFile(
 307           event_router_, file_system_info_, file_handle,
 308           base::Bind(&ProvidedFileSystem::OnCloseFileCompleted,
 309                      weak_ptr_factory_.GetWeakPtr(), file_handle, callback))));
 310   if (!request_id) {
 311     callback.Run(base::File::FILE_ERROR_SECURITY);
 312     return AbortCallback();
 313   }
 314
 315   return base::Bind(
 316       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 317 }
 318
 319 AbortCallback ProvidedFileSystem::CreateDirectory(
 320     const base::FilePath& directory_path,
 321     bool recursive,
 322     const storage::AsyncFileUtil::StatusCallback& callback) {
 323   const int request_id = request_manager_->CreateRequest(
 324       CREATE_DIRECTORY,
 325       scoped_ptr<RequestManager::HandlerInterface>(
 326           new operations::CreateDirectory(event_router_,
 327                                           file_system_info_,
 328                                           directory_path,
 329                                           recursive,
 330                                           callback)));
 331   if (!request_id) {
 332     callback.Run(base::File::FILE_ERROR_SECURITY);
 333     return AbortCallback();
 334   }
 335
 336   return base::Bind(
 337       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 338 }
 339
 340 AbortCallback ProvidedFileSystem::DeleteEntry(
 341     const base::FilePath& entry_path,
 342     bool recursive,
 343     const storage::AsyncFileUtil::StatusCallback& callback) {
 344   const int request_id = request_manager_->CreateRequest(
 345       DELETE_ENTRY,
 346       scoped_ptr<RequestManager::HandlerInterface>(new operations::DeleteEntry(
 347           event_router_, file_system_info_, entry_path, recursive, callback)));
 348   if (!request_id) {
 349     callback.Run(base::File::FILE_ERROR_SECURITY);
 350     return AbortCallback();
 351   }
 352
 353   return base::Bind(
 354       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 355 }
 356
 357 AbortCallback ProvidedFileSystem::CreateFile(
 358     const base::FilePath& file_path,
 359     const storage::AsyncFileUtil::StatusCallback& callback) {
 360   const int request_id = request_manager_->CreateRequest(
 361       CREATE_FILE,
 362       scoped_ptr<RequestManager::HandlerInterface>(new operations::CreateFile(
 363           event_router_, file_system_info_, file_path, callback)));
 364   if (!request_id) {
 365     callback.Run(base::File::FILE_ERROR_SECURITY);
 366     return AbortCallback();
 367   }
 368
 369   return base::Bind(
 370       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 371 }
 372
 373 AbortCallback ProvidedFileSystem::CopyEntry(
 374     const base::FilePath& source_path,
 375     const base::FilePath& target_path,
 376     const storage::AsyncFileUtil::StatusCallback& callback) {
 377   const int request_id = request_manager_->CreateRequest(
 378       COPY_ENTRY,
 379       scoped_ptr<RequestManager::HandlerInterface>(
 380           new operations::CopyEntry(event_router_,
 381                                     file_system_info_,
 382                                     source_path,
 383                                     target_path,
 384                                     callback)));
 385   if (!request_id) {
 386     callback.Run(base::File::FILE_ERROR_SECURITY);
 387     return AbortCallback();
 388   }
 389
 390   return base::Bind(
 391       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 392 }
 393
 394 AbortCallback ProvidedFileSystem::WriteFile(
 395     int file_handle,
 396     net::IOBuffer* buffer,
 397     int64 offset,
 398     int length,
 399     const storage::AsyncFileUtil::StatusCallback& callback) {
 400   TRACE_EVENT1("file_system_provider",
 401                "ProvidedFileSystem::WriteFile",
 402                "length",
 403                length);
 404   const int request_id = request_manager_->CreateRequest(
 405       WRITE_FILE,
 406       make_scoped_ptr<RequestManager::HandlerInterface>(
 407           new operations::WriteFile(event_router_,
 408                                     file_system_info_,
 409                                     file_handle,
 410                                     make_scoped_refptr(buffer),
 411                                     offset,
 412                                     length,
 413                                     callback)));
 414   if (!request_id) {
 415     callback.Run(base::File::FILE_ERROR_SECURITY);
 416     return AbortCallback();
 417   }
 418
 419   return base::Bind(
 420       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 421 }
 422
 423 AbortCallback ProvidedFileSystem::MoveEntry(
 424     const base::FilePath& source_path,
 425     const base::FilePath& target_path,
 426     const storage::AsyncFileUtil::StatusCallback& callback) {
 427   const int request_id = request_manager_->CreateRequest(
 428       MOVE_ENTRY,
 429       scoped_ptr<RequestManager::HandlerInterface>(
 430           new operations::MoveEntry(event_router_,
 431                                     file_system_info_,
 432                                     source_path,
 433                                     target_path,
 434                                     callback)));
 435   if (!request_id) {
 436     callback.Run(base::File::FILE_ERROR_SECURITY);
 437     return AbortCallback();
 438   }
 439
 440   return base::Bind(
 441       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 442 }
 443
 444 AbortCallback ProvidedFileSystem::Truncate(
 445     const base::FilePath& file_path,
 446     int64 length,
 447     const storage::AsyncFileUtil::StatusCallback& callback) {
 448   const int request_id = request_manager_->CreateRequest(
 449       TRUNCATE,
 450       scoped_ptr<RequestManager::HandlerInterface>(new operations::Truncate(
 451           event_router_, file_system_info_, file_path, length, callback)));
 452   if (!request_id) {
 453     callback.Run(base::File::FILE_ERROR_SECURITY);
 454     return AbortCallback();
 455   }
 456
 457   return base::Bind(
 458       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 459 }
 460
 461 AbortCallback ProvidedFileSystem::AddWatcher(
 462     const GURL& origin,
 463     const base::FilePath& entry_path,
 464     bool recursive,
 465     bool persistent,
 466     const storage::AsyncFileUtil::StatusCallback& callback,
 467     const storage::WatcherManager::NotificationCallback&
 468         notification_callback) {
 469   const size_t token = watcher_queue_.NewToken();
 470   watcher_queue_.Enqueue(
 471       token, base::Bind(&ProvidedFileSystem::AddWatcherInQueue,
 472                         base::Unretained(this),  // Outlived by the queue.
 473                         AddWatcherInQueueArgs(token, origin, entry_path,
 474                                               recursive, persistent, callback,
 475                                               notification_callback)));
 476   return AbortCallback();
 477 }
 478
 479 void ProvidedFileSystem::RemoveWatcher(
 480     const GURL& origin,
 481     const base::FilePath& entry_path,
 482     bool recursive,
 483     const storage::AsyncFileUtil::StatusCallback& callback) {
 484   const size_t token = watcher_queue_.NewToken();
 485   watcher_queue_.Enqueue(
 486       token, base::Bind(&ProvidedFileSystem::RemoveWatcherInQueue,
 487                         base::Unretained(this),  // Outlived by the queue.
 488                         token, origin, entry_path, recursive, callback));
 489 }
 490
 491 const ProvidedFileSystemInfo& ProvidedFileSystem::GetFileSystemInfo() const {
 492   return file_system_info_;
 493 }
 494
 495 RequestManager* ProvidedFileSystem::GetRequestManager() {
 496   return request_manager_.get();
 497 }
 498
 499 Watchers* ProvidedFileSystem::GetWatchers() {
 500   return &watchers_;
 501 }
 502
 503 const OpenedFiles& ProvidedFileSystem::GetOpenedFiles() const {
 504   return opened_files_;
 505 }
 506
 507 void ProvidedFileSystem::AddObserver(ProvidedFileSystemObserver* observer) {
 508   DCHECK(observer);
 509   observers_.AddObserver(observer);
 510 }
 511
 512 void ProvidedFileSystem::RemoveObserver(ProvidedFileSystemObserver* observer) {
 513   DCHECK(observer);
 514   observers_.RemoveObserver(observer);
 515 }
 516
 517 void ProvidedFileSystem::Notify(
 518     const base::FilePath& entry_path,
 519     bool recursive,
 520     storage::WatcherManager::ChangeType change_type,
 521     scoped_ptr<ProvidedFileSystemObserver::Changes> changes,
 522     const std::string& tag,
 523     const storage::AsyncFileUtil::StatusCallback& callback) {
 524   const size_t token = watcher_queue_.NewToken();
 525   watcher_queue_.Enqueue(
 526       token, base::Bind(&ProvidedFileSystem::NotifyInQueue,
 527                         base::Unretained(this),  // Outlived by the queue.
 528                         base::Passed(make_scoped_ptr(new NotifyInQueueArgs(
 529                             token, entry_path, recursive, change_type,
 530                             changes.Pass(), tag, callback)))));
 531 }
 532
 533 void ProvidedFileSystem::Configure(
 534     const storage::AsyncFileUtil::StatusCallback& callback) {
 535   const int request_id = request_manager_->CreateRequest(
 536       CONFIGURE,
 537       scoped_ptr<RequestManager::HandlerInterface>(new operations::Configure(
 538           event_router_, file_system_info_, callback)));
 539   if (!request_id)
 540     callback.Run(base::File::FILE_ERROR_SECURITY);
 541 }
 542
 543 void ProvidedFileSystem::Abort(int operation_request_id) {
 544   request_manager_->RejectRequest(operation_request_id,
 545                                   make_scoped_ptr(new RequestValue()),
 546                                   base::File::FILE_ERROR_ABORT);
 547   if (!request_manager_->CreateRequest(
 548           ABORT,
 549           scoped_ptr<RequestManager::HandlerInterface>(new operations::Abort(
 550               event_router_, file_system_info_, operation_request_id,
 551               base::Bind(&EmptyStatusCallback))))) {
 552     LOG(ERROR) << "Failed to create an abort request.";
 553   }
 554 }
 555
 556 AbortCallback ProvidedFileSystem::AddWatcherInQueue(
 557     const AddWatcherInQueueArgs& args) {
 558   if (args.persistent && (!file_system_info_.supports_notify_tag() ||
 559                           !args.notification_callback.is_null())) {
 560     OnAddWatcherInQueueCompleted(args.token, args.entry_path, args.recursive,
 561                                  Subscriber(), args.callback,
 562                                  base::File::FILE_ERROR_INVALID_OPERATION);
 563     return AbortCallback();
 564   }
 565
 566   // Create a candidate subscriber. This could be done in OnAddWatcherCompleted,
 567   // but base::Bind supports only up to 7 arguments.
 568   Subscriber subscriber;
 569   subscriber.origin = args.origin;
 570   subscriber.persistent = args.persistent;
 571   subscriber.notification_callback = args.notification_callback;
 572
 573   const WatcherKey key(args.entry_path, args.recursive);
 574   const Watchers::const_iterator it = watchers_.find(key);
 575   if (it != watchers_.end()) {
 576     const bool exists = it->second.subscribers.find(args.origin) !=
 577                         it->second.subscribers.end();
 578     OnAddWatcherInQueueCompleted(
 579         args.token, args.entry_path, args.recursive, subscriber, args.callback,
 580         exists ? base::File::FILE_ERROR_EXISTS : base::File::FILE_OK);
 581     return AbortCallback();
 582   }
 583
 584   const int request_id = request_manager_->CreateRequest(
 585       ADD_WATCHER,
 586       scoped_ptr<RequestManager::HandlerInterface>(new operations::AddWatcher(
 587           event_router_, file_system_info_, args.entry_path, args.recursive,
 588           base::Bind(&ProvidedFileSystem::OnAddWatcherInQueueCompleted,
 589                      weak_ptr_factory_.GetWeakPtr(), args.token,
 590                      args.entry_path, args.recursive, subscriber,
 591                      args.callback))));
 592
 593   if (!request_id) {
 594     OnAddWatcherInQueueCompleted(args.token, args.entry_path, args.recursive,
 595                                  subscriber, args.callback,
 596                                  base::File::FILE_ERROR_SECURITY);
 597   }
 598
 599   return AbortCallback();
 600 }
 601
 602 AbortCallback ProvidedFileSystem::RemoveWatcherInQueue(
 603     size_t token,
 604     const GURL& origin,
 605     const base::FilePath& entry_path,
 606     bool recursive,
 607     const storage::AsyncFileUtil::StatusCallback& callback) {
 608   const WatcherKey key(entry_path, recursive);
 609   const Watchers::iterator it = watchers_.find(key);
 610   if (it == watchers_.end() ||
 611       it->second.subscribers.find(origin) == it->second.subscribers.end()) {
 612     OnRemoveWatcherInQueueCompleted(token, origin, key, callback,
 613                                     false /* extension_response */,
 614                                     base::File::FILE_ERROR_NOT_FOUND);
 615     return AbortCallback();
 616   }
 617
 618   // If there are other subscribers, then do not remove the observer, but simply
 619   // return a success.
 620   if (it->second.subscribers.size() > 1) {
 621     OnRemoveWatcherInQueueCompleted(token, origin, key, callback,
 622                                     false /* extension_response */,
 623                                     base::File::FILE_OK);
 624     return AbortCallback();
 625   }
 626
 627   // Otherwise, emit an event, and remove the watcher.
 628   request_manager_->CreateRequest(
 629       REMOVE_WATCHER,
 630       scoped_ptr<RequestManager::HandlerInterface>(
 631           new operations::RemoveWatcher(
 632               event_router_, file_system_info_, entry_path, recursive,
 633               base::Bind(&ProvidedFileSystem::OnRemoveWatcherInQueueCompleted,
 634                          weak_ptr_factory_.GetWeakPtr(), token, origin, key,
 635                          callback, true /* extension_response */))));
 636
 637   return AbortCallback();
 638 }
 639
 640 AbortCallback ProvidedFileSystem::NotifyInQueue(
 641     scoped_ptr<NotifyInQueueArgs> args) {
 642   const WatcherKey key(args->entry_path, args->recursive);
 643   const auto& watcher_it = watchers_.find(key);
 644   if (watcher_it == watchers_.end()) {
 645     OnNotifyInQueueCompleted(args.Pass(), base::File::FILE_ERROR_NOT_FOUND);
 646     return AbortCallback();
 647   }
 648
 649   // The tag must be provided if and only if it's explicitly supported.
 650   if (file_system_info_.supports_notify_tag() == args->tag.empty()) {
 651     OnNotifyInQueueCompleted(args.Pass(),
 652                              base::File::FILE_ERROR_INVALID_OPERATION);
 653     return AbortCallback();
 654   }
 655
 656   // It's illegal to provide a tag which is not unique.
 657   if (!args->tag.empty() && args->tag == watcher_it->second.last_tag) {
 658     OnNotifyInQueueCompleted(args.Pass(),
 659                              base::File::FILE_ERROR_INVALID_OPERATION);
 660     return AbortCallback();
 661   }
 662
 663   // The object is owned by AutoUpdated, so the reference is valid as long as
 664   // callbacks created with AutoUpdater::CreateCallback().
 665   const ProvidedFileSystemObserver::Changes& changes_ref = *args->changes.get();
 666   const storage::WatcherManager::ChangeType change_type = args->change_type;
 667
 668   scoped_refptr<AutoUpdater> auto_updater(
 669       new AutoUpdater(base::Bind(&ProvidedFileSystem::OnNotifyInQueueCompleted,
 670                                  weak_ptr_factory_.GetWeakPtr(),
 671                                  base::Passed(&args), base::File::FILE_OK)));
 672
 673   // Call all notification callbacks (if any).
 674   for (const auto& subscriber_it : watcher_it->second.subscribers) {
 675     const storage::WatcherManager::NotificationCallback& notification_callback =
 676         subscriber_it.second.notification_callback;
 677     if (!notification_callback.is_null())
 678       notification_callback.Run(change_type);
 679   }
 680
 681   // Notify all observers.
 682   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
 683                     observers_,
 684                     OnWatcherChanged(file_system_info_,
 685                                      watcher_it->second,
 686                                      change_type,
 687                                      changes_ref,
 688                                      auto_updater->CreateCallback()));
 689
 690   return AbortCallback();
 691 }
 692
 693 base::WeakPtr<ProvidedFileSystemInterface> ProvidedFileSystem::GetWeakPtr() {
 694   return weak_ptr_factory_.GetWeakPtr();
 695 }
 696
 697 void ProvidedFileSystem::OnAddWatcherInQueueCompleted(
 698     size_t token,
 699     const base::FilePath& entry_path,
 700     bool recursive,
 701     const Subscriber& subscriber,
 702     const storage::AsyncFileUtil::StatusCallback& callback,
 703     base::File::Error result) {
 704   if (result != base::File::FILE_OK) {
 705     callback.Run(result);
 706     watcher_queue_.Complete(token);
 707     return;
 708   }
 709
 710   const WatcherKey key(entry_path, recursive);
 711   const Watchers::iterator it = watchers_.find(key);
 712   if (it != watchers_.end()) {
 713     callback.Run(base::File::FILE_OK);
 714     watcher_queue_.Complete(token);
 715     return;
 716   }
 717
 718   Watcher* const watcher = &watchers_[key];
 719   watcher->entry_path = entry_path;
 720   watcher->recursive = recursive;
 721   watcher->subscribers[subscriber.origin] = subscriber;
 722
 723   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
 724                     observers_,
 725                     OnWatcherListChanged(file_system_info_, watchers_));
 726
 727   callback.Run(base::File::FILE_OK);
 728   watcher_queue_.Complete(token);
 729 }
 730
 731 void ProvidedFileSystem::OnRemoveWatcherInQueueCompleted(
 732     size_t token,
 733     const GURL& origin,
 734     const WatcherKey& key,
 735     const storage::AsyncFileUtil::StatusCallback& callback,
 736     bool extension_response,
 737     base::File::Error result) {
 738   if (!extension_response && result != base::File::FILE_OK) {
 739     watcher_queue_.Complete(token);
 740     callback.Run(result);
 741     return;
 742   }
 743
 744   // Even if the extension returns an error, the callback is called with base::
 745   // File::FILE_OK.
 746   const auto it = watchers_.find(key);
 747   DCHECK(it != watchers_.end());
 748   DCHECK(it->second.subscribers.find(origin) != it->second.subscribers.end());
 749
 750   it->second.subscribers.erase(origin);
 751
 752   FOR_EACH_OBSERVER(ProvidedFileSystemObserver, observers_,
 753                     OnWatcherListChanged(file_system_info_, watchers_));
 754
 755   // If there are no more subscribers, then remove the watcher.
 756   if (!it->second.subscribers.size())
 757     watchers_.erase(it);
 758
 759   callback.Run(base::File::FILE_OK);
 760   watcher_queue_.Complete(token);
 761 }
 762
 763 void ProvidedFileSystem::OnNotifyInQueueCompleted(
 764     scoped_ptr<NotifyInQueueArgs> args,
 765     base::File::Error result) {
 766   if (result != base::File::FILE_OK) {
 767     args->callback.Run(result);
 768     watcher_queue_.Complete(args->token);
 769     return;
 770   }
 771
 772   // Check if the entry is still watched.
 773   const WatcherKey key(args->entry_path, args->recursive);
 774   const Watchers::iterator it = watchers_.find(key);
 775   if (it == watchers_.end()) {
 776     args->callback.Run(base::File::FILE_ERROR_NOT_FOUND);
 777     watcher_queue_.Complete(args->token);
 778     return;
 779   }
 780
 781   it->second.last_tag = args->tag;
 782
 783   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
 784                     observers_,
 785                     OnWatcherTagUpdated(file_system_info_, it->second));
 786
 787   // If the watched entry is deleted, then remove the watcher.
 788   if (args->change_type == storage::WatcherManager::DELETED) {
 789     // Make a copy, since the |it| iterator will get invalidated on the last
 790     // subscriber.
 791     Subscribers subscribers = it->second.subscribers;
 792     for (const auto& subscriber_it : subscribers) {
 793       RemoveWatcher(subscriber_it.second.origin, args->entry_path,
 794                     args->recursive, base::Bind(&EmptyStatusCallback));
 795     }
 796   }
 797
 798   args->callback.Run(base::File::FILE_OK);
 799   watcher_queue_.Complete(args->token);
 800 }
 801
 802 void ProvidedFileSystem::OnOpenFileCompleted(const base::FilePath& file_path,
 803                                              OpenFileMode mode,
 804                                              const OpenFileCallback& callback,
 805                                              int file_handle,
 806                                              base::File::Error result) {
 807   if (result != base::File::FILE_OK) {
 808     callback.Run(file_handle, result);
 809     return;
 810   }
 811
 812   opened_files_[file_handle] = OpenedFile(file_path, mode);
 813   callback.Run(file_handle, base::File::FILE_OK);
 814 }
 815
 816 void ProvidedFileSystem::OnCloseFileCompleted(
 817     int file_handle,
 818     const storage::AsyncFileUtil::StatusCallback& callback,
 819     base::File::Error result) {
 820   // Closing files is final. Even if an error happened, we remove it from the
 821   // list of opened files.
 822   opened_files_.erase(file_handle);
 823   callback.Run(result);
 824 }
 825
 826 }  // namespace file_system_provider
 827 }  // namespace chromeos