mediaview: Implement FakeFileSystemInstance.

components/arc/test/fake_file_system_instance.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 "components/arc/test/fake_file_system_instance.h"
 
 #include <string.h>
 #include <unistd.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/optional.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/edk/embedder/embedder.h"
@@ skipping 69 matching lines @@
 
 FakeFileSystemInstance::FakeFileSystemInstance() {
   bool temp_dir_created = temp_dir_.CreateUniqueTempDir();
   DCHECK(temp_dir_created);
 }
 
 FakeFileSystemInstance::~FakeFileSystemInstance() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
+bool FakeFileSystemInstance::InitCalled() {
+  return host_;
+}
+
 void FakeFileSystemInstance::AddFile(const File& file) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0u, files_.count(std::string(file.url)));
   files_.insert(std::make_pair(std::string(file.url), file));
 }
 
 void FakeFileSystemInstance::AddDocument(const Document& document) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DocumentKey key(document.authority, document.document_id);
   DCHECK_EQ(0u, documents_.count(key));
   documents_.insert(std::make_pair(key, document));
   child_documents_[key];  // Allocate a vector.
   if (!document.parent_document_id.empty()) {
     DocumentKey parent_key(document.authority, document.parent_document_id);
     DCHECK_EQ(1u, documents_.count(parent_key));
     child_documents_[parent_key].push_back(key);
   }
 }
 
+void FakeFileSystemInstance::TriggerWatchers(const std::string& authority,
+                                             const std::string& document_id,
+                                             mojom::ChangeType type) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!host_) {
+    LOG(ERROR) << "FileSystemHost is not available.";
+    return;
+  }
+  auto iter = document_to_watchers_.find(DocumentKey(authority, document_id));
+  if (iter == document_to_watchers_.end())
+    return;
+  for (int64_t watcher_id : iter->second) {
+    host_->OnDocumentChanged(watcher_id, type);
+  }
+}
+
 void FakeFileSystemInstance::AddWatcher(const std::string& authority,
                                         const std::string& document_id,
                                         const AddWatcherCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  NOTIMPLEMENTED();
+  DocumentKey key(authority, document_id);
+  auto iter = documents_.find(key);
+  if (iter == documents_.end()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  base::Bind(callback, -1));
+    return;
+  }
+  int64_t watcher_id = next_watcher_id_++;
+  document_to_watchers_[key].insert(watcher_id);
+  watcher_to_document_.insert(std::make_pair(watcher_id, key));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(callback, watcher_id));
 }
 
 void FakeFileSystemInstance::GetFileSize(const std::string& url,
                                          const GetFileSizeCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   auto iter = files_.find(url);
   if (iter == files_.end()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, -1));
     return;
@@ skipping 63 matching lines @@
     children.emplace_back(MakeDocument(doc_iter->second));
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  base::Passed(base::make_optional(std::move(children)))));
 }
 
 void FakeFileSystemInstance::Init(mojom::FileSystemHostPtr host) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  NOTIMPLEMENTED();
+  DCHECK(host);
+  DCHECK(!host_);
+  host_ = std::move(host);
 }
 
 void FakeFileSystemInstance::RemoveWatcher(
     int64_t watcher_id,
     const RemoveWatcherCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  NOTIMPLEMENTED();
+  auto iter = watcher_to_document_.find(watcher_id);
+  if (iter == watcher_to_document_.end()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  base::Bind(callback, false));
+    return;
+  }
+  document_to_watchers_[iter->second].erase(watcher_id);
+  watcher_to_document_.erase(iter);
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                base::Bind(callback, true));
 }
 
 void FakeFileSystemInstance::RequestMediaScan(
     const std::vector<std::string>& paths) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Do nothing and pretend we scaned them.
 }
 
 }  // namespace arc