Call WatcherManager functions on the IO thread.

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.cc

 // Copyright 2013 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/extensions/file_manager/private_api_file_system.h"
 
 #include <sys/statvfs.h>
 
 #include <algorithm>
-#include <set>
 #include <utility>
-#include <vector>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/weak_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/event_router.h"
@@ skipping 273 matching lines @@
       backend->GrantFileAccessToExtension(extension_->id(),
                                           file_system_url.virtual_path());
       content::ChildProcessSecurityPolicy::GetInstance()
           ->GrantCreateReadWriteFile(render_frame_host()->GetProcess()->GetID(),
                                      file_system_url.path());
     }
   }
   return RespondNow(NoArguments());
 }
 
+namespace {
+
+void CallResponseCallbackOnUIThread(
+    const FileWatchFunctionBase::ResponseCallback& callback,
+    bool success) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, success));
+}
+
+void CallNotificationCallbackOnUIThread(
+    const storage::WatcherManager::NotificationCallback& callback,
+    storage::WatcherManager::ChangeType type) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, type));
+}
+
+}  // namespace
+
 void FileWatchFunctionBase::Respond(bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SetResult(base::MakeUnique<base::FundamentalValue>(success));
   SendResponse(success);
 }
 
 bool FileWatchFunctionBase::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!render_frame_host() || !render_frame_host()->GetProcess())
     return false;
 
   // First param is url of a file to watch.
   std::string url;
   if (!args_->GetString(0, &url) || url.empty())
     return false;
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           GetProfile(), render_frame_host());
 
   const FileSystemURL file_system_url =
       file_system_context->CrackURL(GURL(url));
   if (file_system_url.path().empty()) {
     Respond(false);
     return true;
   }
 
-  PerformFileWatchOperation(file_system_context, file_system_url,
-                            extension_id());
-  return true;
-}
-
-void FileManagerPrivateInternalAddFileWatchFunction::PerformFileWatchOperation(
-    scoped_refptr<storage::FileSystemContext> file_system_context,
-    const storage::FileSystemURL& file_system_url,
-    const std::string& extension_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
   file_manager::EventRouter* const event_router =
       file_manager::EventRouterFactory::GetForProfile(GetProfile());
 
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&FileWatchFunctionBase::RunAsyncOnIOThread,
+                                     this, file_system_context, file_system_url,
+                                     event_router->GetWeakPtr()));
+  return true;
+}
+
+void FileWatchFunctionBase::RunAsyncOnIOThread(
+    scoped_refptr<storage::FileSystemContext> file_system_context,
+    const storage::FileSystemURL& file_system_url,
+    base::WeakPtr<file_manager::EventRouter> event_router) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   storage::WatcherManager* const watcher_manager =
       file_system_context->GetWatcherManager(file_system_url.type());
-  if (watcher_manager) {
-    watcher_manager->AddWatcher(
-        file_system_url, false /* recursive */,
+
+  if (!watcher_manager) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
         base::Bind(
-            &StatusCallbackToResponseCallback,
-            base::Bind(&FileManagerPrivateInternalAddFileWatchFunction::Respond,
-                       this)),
-        base::Bind(&file_manager::EventRouter::OnWatcherManagerNotification,
-                   event_router->GetWeakPtr(), file_system_url, extension_id));
+            &FileWatchFunctionBase::PerformFallbackFileWatchOperationOnUIThread,
+            this, file_system_url, event_router));
     return;
   }
 
+  PerformFileWatchOperationOnIOThread(file_system_context, watcher_manager,
+                                      file_system_url, event_router);
+}
+
+void FileManagerPrivateInternalAddFileWatchFunction::
+    PerformFileWatchOperationOnIOThread(
+        scoped_refptr<storage::FileSystemContext> file_system_context,
+        storage::WatcherManager* watcher_manager,
+        const storage::FileSystemURL& file_system_url,
+        base::WeakPtr<file_manager::EventRouter> event_router) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  watcher_manager->AddWatcher(
+      file_system_url, false /* recursive */,
+      base::Bind(&StatusCallbackToResponseCallback,
+                 base::Bind(&CallResponseCallbackOnUIThread,
+                            base::Bind(&FileWatchFunctionBase::Respond, this))),
+      base::Bind(
+          &CallNotificationCallbackOnUIThread,
+          base::Bind(&file_manager::EventRouter::OnWatcherManagerNotification,
+                     event_router, file_system_url, extension_id())));
+}
+
+void FileManagerPrivateInternalAddFileWatchFunction::
+    PerformFallbackFileWatchOperationOnUIThread(
+        const storage::FileSystemURL& file_system_url,
+        base::WeakPtr<file_manager::EventRouter> event_router) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(event_router);
+
   // Obsolete. Fallback code if storage::WatcherManager is not implemented.
-  event_router->AddFileWatch(
-      file_system_url.path(), file_system_url.virtual_path(), extension_id,
-      base::Bind(&FileManagerPrivateInternalAddFileWatchFunction::Respond,
-                 this));
+  event_router->AddFileWatch(file_system_url.path(),
+                             file_system_url.virtual_path(), extension_id(),
+                             base::Bind(&FileWatchFunctionBase::Respond, this));
 }
 
 void FileManagerPrivateInternalRemoveFileWatchFunction::
-    PerformFileWatchOperation(
+    PerformFileWatchOperationOnIOThread(
         scoped_refptr<storage::FileSystemContext> file_system_context,
+        storage::WatcherManager* watcher_manager,
         const storage::FileSystemURL& file_system_url,
-        const std::string& extension_id) {
+        base::WeakPtr<file_manager::EventRouter> event_router) {

[tzik, 2017/02/23 03:57:18]

|event_router| is not used?

[Shuhei Takahashi, 2017/02/23 04:05:57]

It is not used in FileManagerPrivateInternalRemoveFileWatchFunction, but it is
used in FileManagerPrivateInternalAddFileWatchFunction. Since the two classes
inherit from the same base class FileWatchFunctionBase, we need the same
signature.

+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  watcher_manager->RemoveWatcher(
+      file_system_url, false /* recursive */,
+      base::Bind(
+          &StatusCallbackToResponseCallback,
+          base::Bind(&CallResponseCallbackOnUIThread,
+                     base::Bind(&FileWatchFunctionBase::Respond, this))));
+}
+
+void FileManagerPrivateInternalRemoveFileWatchFunction::
+    PerformFallbackFileWatchOperationOnUIThread(
+        const storage::FileSystemURL& file_system_url,
+        base::WeakPtr<file_manager::EventRouter> event_router) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  file_manager::EventRouter* const event_router =
-      file_manager::EventRouterFactory::GetForProfile(GetProfile());
-
-  storage::WatcherManager* const watcher_manager =
-      file_system_context->GetWatcherManager(file_system_url.type());
-  if (watcher_manager) {
-    watcher_manager->RemoveWatcher(
-        file_system_url, false /* recursive */,
-        base::Bind(&StatusCallbackToResponseCallback,
-                   base::Bind(&FileWatchFunctionBase::Respond, this)));
-    return;
-  }
+  DCHECK(event_router);
 
   // Obsolete. Fallback code if storage::WatcherManager is not implemented.
-  event_router->RemoveFileWatch(file_system_url.path(), extension_id);
+  event_router->RemoveFileWatch(file_system_url.path(), extension_id());
   Respond(true);
 }
 
 bool FileManagerPrivateGetSizeStatsFunction::RunAsync() {
   using extensions::api::file_manager_private::GetSizeStats::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using file_manager::VolumeManager;
   using file_manager::Volume;
@@ skipping 596 matching lines @@
 }
 
 void FileManagerPrivateInternalGetDirectorySizeFunction::
     OnDirectorySizeRetrieved(int64_t size) {
   SetResult(
       base::MakeUnique<base::FundamentalValue>(static_cast<double>(size)));
   SendResponse(true);
 }
 
 }  // namespace extensions