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);

[dcheng, 2017/03/03 09:40:56]

This is called by... Chromium code? Would it make sense to DCHECK this instead?

[Shuhei Takahashi, 2017/03/03 10:12:10]

It is called by Chromium code, but the upstream explicitly requires us to return
errors when it was attempted to install multiple watchers to the same path. So
we can't DCHECK here unfortunately.

https://cs.chromium.org/chromium/src/storage/browser/fileapi/watcher_manager....

+    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()) {

[dcheng, 2017/03/03 09:40:56]

Ditto: if this is something called by code within Chromium, I think it should
probably be a DCHECK?

[Shuhei Takahashi, 2017/03/03 10:12:11]

Same as above.

+    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 iter = path_to_watcher_id_.begin();
+       iter != path_to_watcher_id_.end(); ++iter) {

[dcheng, 2017/03/03 09:40:56]

Nit:
for (auto& it : path_to_watcher_id_)
  it->second = -1;

[Shuhei Takahashi, 2017/03/03 10:12:11]

Ah yes, we can do that. Thanks!

+    iter->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()) {

[dcheng, 2017/03/03 09:40:56]

DCHECK if this is only called by Chromium code?

[Shuhei Takahashi, 2017/03/03 10:12:10]

This can happen when AddWatcher() is called to non-existent files, which can
happen in race conditions.

+    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