mediaview: Support watchers in ArcDocumentsProviderRoot.

chrome/browser/chromeos/arc/fileapi/arc_documents_provider_root.cc

 // Copyright 2016 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/arc/fileapi/arc_documents_provider_root.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/arc/fileapi/arc_documents_provider_util.h"
-#include "chrome/browser/chromeos/arc/fileapi/arc_file_system_operation_runner_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using EntryList = storage::AsyncFileUtil::EntryList;
 
 namespace arc {
 
 namespace {
 
@@ skipping 38 matching lines @@
 
 ArcDocumentsProviderRoot::ArcDocumentsProviderRoot(
     const std::string& authority,
     const std::string& root_document_id)
     : authority_(authority),
       root_document_id_(root_document_id),
       weak_ptr_factory_(this) {}
 
 ArcDocumentsProviderRoot::~ArcDocumentsProviderRoot() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (observer_wrapper_)
+    file_system_operation_runner_util::RemoveObserverOnIOThread(
+        std::move(observer_wrapper_));
 }
 
 void ArcDocumentsProviderRoot::GetFileInfo(
     const base::FilePath& path,
     const GetFileInfoCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ResolveToDocumentId(
       path, base::Bind(&ArcDocumentsProviderRoot::GetFileInfoWithDocumentId,
                        weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ArcDocumentsProviderRoot::ReadDirectory(
     const base::FilePath& path,
     const ReadDirectoryCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ResolveToDocumentId(
       path, base::Bind(&ArcDocumentsProviderRoot::ReadDirectoryWithDocumentId,
                        weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
+void ArcDocumentsProviderRoot::AddWatcher(
+    const base::FilePath& path,
+    const WatcherCallback& watcher_callback,
+    const StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (path_to_watcher_id_.count(path)) {
+    callback.Run(base::File::FILE_ERROR_FAILED);
+    return;
+  }
+  ResolveToDocumentId(
+      path,
+      base::Bind(&ArcDocumentsProviderRoot::AddWatcherWithDocumentId,
+                 weak_ptr_factory_.GetWeakPtr(), path, watcher_callback,
+                 callback));
+}
+
+void ArcDocumentsProviderRoot::RemoveWatcher(const base::FilePath& path,
+                                             const StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  auto iter = path_to_watcher_id_.find(path);
+  if (iter == path_to_watcher_id_.end()) {
+    callback.Run(base::File::FILE_ERROR_FAILED);
+    return;
+  }
+  int64_t watcher_id = iter->second;
+  path_to_watcher_id_.erase(iter);
+  if (watcher_id < 0) {
+    // This is an orphan watcher. Just remove an entry from
+    // |path_to_watcher_id_| and return success.
+    callback.Run(base::File::FILE_OK);
+    return;
+  }
+  file_system_operation_runner_util::RemoveWatcherOnIOThread(
+      watcher_id,
+      base::Bind(&ArcDocumentsProviderRoot::OnWatcherRemoved,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
 void ArcDocumentsProviderRoot::ResolveToContentUrl(
     const base::FilePath& path,
     const ResolveToContentUrlCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ResolveToDocumentId(
       path,
       base::Bind(&ArcDocumentsProviderRoot::ResolveToContentUrlWithDocumentId,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
+void ArcDocumentsProviderRoot::OnWatchersCleared() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // Mark all watchers orphan.
+  for (auto& entry : path_to_watcher_id_)
+    entry.second = -1;
+}
+
 void ArcDocumentsProviderRoot::GetFileInfoWithDocumentId(
     const GetFileInfoCallback& callback,
     const std::string& document_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (document_id.empty()) {
     callback.Run(base::File::FILE_ERROR_NOT_FOUND, base::File::Info());
     return;
   }
   // Specially handle the root directory since Files app does not update the
   // list of file systems (left pane) until all volumes respond to GetMetadata
   // requests to root directories.
   if (document_id == root_document_id_) {
     base::File::Info info;
     info.size = -1;
@@ skipping 54 matching lines @@
   }
   EntryList entry_list;
   for (const auto& pair : mapping) {
     entry_list.emplace_back(pair.first, pair.second.is_directory
                                             ? storage::DirectoryEntry::DIRECTORY
                                             : storage::DirectoryEntry::FILE);
   }
   callback.Run(base::File::FILE_OK, entry_list, false /* has_more */);
 }
 
+void ArcDocumentsProviderRoot::AddWatcherWithDocumentId(
+    const base::FilePath& path,
+    const WatcherCallback& watcher_callback,
+    const StatusCallback& callback,
+    const std::string& document_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (document_id.empty()) {
+    callback.Run(base::File::FILE_ERROR_NOT_FOUND);
+    return;
+  }
+  // Start observing ArcFileSystemOperationRunner if we have not.
+  if (!observer_wrapper_) {
+    observer_wrapper_ =
+        new file_system_operation_runner_util::ObserverIOThreadWrapper(this);
+    file_system_operation_runner_util::AddObserverOnIOThread(observer_wrapper_);
+  }
+  file_system_operation_runner_util::AddWatcherOnIOThread(
+      authority_, document_id, watcher_callback,
+      base::Bind(&ArcDocumentsProviderRoot::OnWatcherAdded,
+                 weak_ptr_factory_.GetWeakPtr(), path, callback));
+}
+
+void ArcDocumentsProviderRoot::OnWatcherAdded(const base::FilePath& path,
+                                              const StatusCallback& callback,
+                                              int64_t watcher_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (watcher_id < 0) {
+    callback.Run(base::File::FILE_ERROR_FAILED);
+    return;
+  }
+  if (path_to_watcher_id_.count(path)) {
+    // Multiple watchers have been installed on the same file path in a race.
+    // Following the contract of WatcherManager, we reject all except the first.
+    file_system_operation_runner_util::RemoveWatcherOnIOThread(
+        watcher_id,
+        base::Bind(&ArcDocumentsProviderRoot::OnWatcherAddedButRemoved,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+    return;
+  }
+  path_to_watcher_id_.insert(std::make_pair(path, watcher_id));
+  callback.Run(base::File::FILE_OK);
+}
+
+void ArcDocumentsProviderRoot::OnWatcherAddedButRemoved(
+    const StatusCallback& callback,
+    bool success) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  callback.Run(base::File::FILE_ERROR_FAILED);
+}
+
+void ArcDocumentsProviderRoot::OnWatcherRemoved(const StatusCallback& callback,
+                                                bool success) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  callback.Run(success ? base::File::FILE_OK : base::File::FILE_ERROR_FAILED);
+}
+
 void ArcDocumentsProviderRoot::ResolveToContentUrlWithDocumentId(
     const ResolveToContentUrlCallback& callback,
     const std::string& document_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (document_id.empty()) {
     callback.Run(GURL());
     return;
   }
   callback.Run(BuildDocumentUrl(authority_, document_id));
 }
@@ skipping 96 matching lines @@
 
     mapping[filename] =
         ThinDocument{document->document_id,
                      document->mime_type == kAndroidDirectoryMimeType};
   }
 
   callback.Run(base::File::FILE_OK, std::move(mapping));
 }
 
 }  // namespace arc