[WIP] Provided file system from NACL.

chrome/browser/chromeos/file_system_provider/provided_file_system.cc

Index: chrome/browser/chromeos/file_system_provider/provided_file_system.cc
diff --git a/chrome/browser/chromeos/file_system_provider/provided_file_system.cc b/chrome/browser/chromeos/file_system_provider/provided_file_system.cc
index c564ecb1954b5965282cd09111fb69a3a4bd59d2..7c1f11215f73cba3dd4fceeeb26f1566495f569a 100644
--- a/chrome/browser/chromeos/file_system_provider/provided_file_system.cc
+++ b/chrome/browser/chromeos/file_system_provider/provided_file_system.cc
@@ -8,6 +8,7 @@
 
 #include "base/files/file.h"
 #include "base/trace_event/trace_event.h"
+#include "chrome/browser/chromeos/file_system_provider/file_system_plugin/plugineventrouter.h"
 #include "chrome/browser/chromeos/file_system_provider/notification_manager.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/abort.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/add_watcher.h"
@@ -37,6 +38,22 @@ class IOBuffer;
 
 namespace chromeos {
 namespace file_system_provider {
+
+template <int source>
+typename SourcePolicy<source>::EventRouterType* SourcePolicy<source>::Get(
+    Profile* profile) {
+  return extensions::EventRouter::Get(profile);
+}
+
+template <>
+typename SourcePolicy<Source_Type::plugin>::EventRouterType*
+SourcePolicy<Source_Type::plugin>::Get(Profile*) {
+  return chromeos::PluginEventRouter::GetInstance();
+}
+
+template struct SourcePolicy<Source_Type::extension>;
+template struct SourcePolicy<Source_Type::plugin>;
+
 namespace {
 
 // Discards the result of Abort() when called from the destructor.
@@ -71,8 +88,8 @@ AutoUpdater::~AutoUpdater() {
   else if (pending_callbacks_)
     LOG(ERROR) << "Not all callbacks called. This may happen on shutdown.";
 }
-
-struct ProvidedFileSystem::AddWatcherInQueueArgs {
+template <int source>
+struct ProvidedFileSystem<source>::AddWatcherInQueueArgs {
   AddWatcherInQueueArgs(size_t token,
                         const GURL& origin,
                         const base::FilePath& entry_path,
@@ -99,7 +116,8 @@ struct ProvidedFileSystem::AddWatcherInQueueArgs {
   const storage::WatcherManager::NotificationCallback notification_callback;
 };
 
-struct ProvidedFileSystem::NotifyInQueueArgs {
+template <int source>
+struct ProvidedFileSystem<source>::NotifyInQueueArgs {
   NotifyInQueueArgs(size_t token,
                     const base::FilePath& entry_path,
                     bool recursive,
@@ -128,11 +146,12 @@ struct ProvidedFileSystem::NotifyInQueueArgs {
   DISALLOW_COPY_AND_ASSIGN(NotifyInQueueArgs);
 };
 
-ProvidedFileSystem::ProvidedFileSystem(
+template <int source>
+ProvidedFileSystem<source>::ProvidedFileSystem(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info)
     : profile_(profile),
-      event_router_(extensions::EventRouter::Get(profile)),  // May be NULL.
+      event_router_(SourcePolicy<source>::Get(profile)),  // May be NULL.
       file_system_info_(file_system_info),
       notification_manager_(
           new NotificationManager(profile_, file_system_info_)),
@@ -140,65 +159,70 @@ ProvidedFileSystem::ProvidedFileSystem(
       watcher_queue_(1),
       weak_ptr_factory_(this) {
 }
-
-ProvidedFileSystem::~ProvidedFileSystem() {
+template <int source>
+ProvidedFileSystem<source>::~ProvidedFileSystem() {
   const std::vector<int> request_ids = request_manager_->GetActiveRequestIds();
   for (size_t i = 0; i < request_ids.size(); ++i) {
     Abort(request_ids[i]);
   }
 }
-
-void ProvidedFileSystem::SetEventRouterForTesting(
-    extensions::EventRouter* event_router) {
+template <int source>
+void ProvidedFileSystem<source>::SetEventRouterForTesting(
+    typename SourcePolicy<source>::EventRouterType* event_router) {
   event_router_ = event_router;
 }
 
-void ProvidedFileSystem::SetNotificationManagerForTesting(
+template <int source>
+void ProvidedFileSystem<source>::SetNotificationManagerForTesting(
     scoped_ptr<NotificationManagerInterface> notification_manager) {
   notification_manager_ = notification_manager.Pass();
   request_manager_.reset(new RequestManager(notification_manager_.get()));
 }
 
-AbortCallback ProvidedFileSystem::RequestUnmount(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::RequestUnmount(
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
-      REQUEST_UNMOUNT,
-      scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::Unmount(event_router_, file_system_info_, callback)));
+      REQUEST_UNMOUNT, scoped_ptr<RequestManager::HandlerInterface>(
+                           new operations::Unmount<source>(
+                               event_router_, file_system_info_, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::GetMetadata(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::GetMetadata(
     const base::FilePath& entry_path,
     MetadataFieldMask fields,
     const GetMetadataCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
       GET_METADATA,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::GetMetadata(
-          event_router_, file_system_info_, entry_path, fields, callback)));
+      scoped_ptr<RequestManager::HandlerInterface>(
+          new operations::GetMetadata<source>(event_router_, file_system_info_,
+                                              entry_path, fields, callback)));
   if (!request_id) {
     callback.Run(make_scoped_ptr<EntryMetadata>(NULL),
                  base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::ReadDirectory(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::ReadDirectory(
     const base::FilePath& directory_path,
     const storage::AsyncFileUtil::ReadDirectoryCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
       READ_DIRECTORY,
       scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::ReadDirectory(
+          new operations::ReadDirectory<source>(
               event_router_, file_system_info_, directory_path, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY,
@@ -207,11 +231,12 @@ AbortCallback ProvidedFileSystem::ReadDirectory(
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::ReadFile(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::ReadFile(
     int file_handle,
     net::IOBuffer* buffer,
     int64 offset,
@@ -220,15 +245,10 @@ AbortCallback ProvidedFileSystem::ReadFile(
   TRACE_EVENT1(
       "file_system_provider", "ProvidedFileSystem::ReadFile", "length", length);
   const int request_id = request_manager_->CreateRequest(
-      READ_FILE,
-      make_scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::ReadFile(event_router_,
-                                   file_system_info_,
-                                   file_handle,
-                                   buffer,
-                                   offset,
-                                   length,
-                                   callback)));
+      READ_FILE, make_scoped_ptr<RequestManager::HandlerInterface>(
+                     new operations::ReadFile<source>(
+                         event_router_, file_system_info_, file_handle, buffer,
+                         offset, length, callback)));
   if (!request_id) {
     callback.Run(0 /* chunk_length */,
                  false /* has_more */,
@@ -236,123 +256,129 @@ AbortCallback ProvidedFileSystem::ReadFile(
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::OpenFile(const base::FilePath& file_path,
-                                           OpenFileMode mode,
-                                           const OpenFileCallback& callback) {
+template <int source>
+AbortCallback ProvidedFileSystem<source>::OpenFile(
+    const base::FilePath& file_path,
+    OpenFileMode mode,
+    const OpenFileCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
-      OPEN_FILE,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::OpenFile(
-          event_router_, file_system_info_, file_path, mode,
-          base::Bind(&ProvidedFileSystem::OnOpenFileCompleted,
-                     weak_ptr_factory_.GetWeakPtr(), file_path, mode,
-                     callback))));
+      OPEN_FILE, scoped_ptr<RequestManager::HandlerInterface>(
+                     new operations::OpenFile<source>(
+                         event_router_, file_system_info_, file_path, mode,
+                         base::Bind(&ProvidedFileSystem::OnOpenFileCompleted,
+                                    weak_ptr_factory_.GetWeakPtr(), file_path,
+                                    mode, callback))));
   if (!request_id) {
     callback.Run(0 /* file_handle */, base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CloseFile(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::CloseFile(
     int file_handle,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
       CLOSE_FILE,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::CloseFile(
-          event_router_, file_system_info_, file_handle,
-          base::Bind(&ProvidedFileSystem::OnCloseFileCompleted,
-                     weak_ptr_factory_.GetWeakPtr(), file_handle, callback))));
+      scoped_ptr<RequestManager::HandlerInterface>(
+          new operations::CloseFile<source>(
+              event_router_, file_system_info_, file_handle,
+              base::Bind(&ProvidedFileSystem<source>::OnCloseFileCompleted,
+                         weak_ptr_factory_.GetWeakPtr(), file_handle,
+                         callback))));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CreateDirectory(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::CreateDirectory(
     const base::FilePath& directory_path,
     bool recursive,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
-      CREATE_DIRECTORY,
-      scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::CreateDirectory(event_router_,
-                                          file_system_info_,
-                                          directory_path,
-                                          recursive,
-                                          callback)));
+      CREATE_DIRECTORY, scoped_ptr<RequestManager::HandlerInterface>(
+                            new operations::CreateDirectory<source>(
+                                event_router_, file_system_info_,
+                                directory_path, recursive, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::DeleteEntry(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::DeleteEntry(
     const base::FilePath& entry_path,
     bool recursive,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
-      DELETE_ENTRY,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::DeleteEntry(
-          event_router_, file_system_info_, entry_path, recursive, callback)));
+      DELETE_ENTRY, scoped_ptr<RequestManager::HandlerInterface>(
+                        new operations::DeleteEntry<source>(
+                            event_router_, file_system_info_, entry_path,
+                            recursive, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CreateFile(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::CreateFile(
     const base::FilePath& file_path,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
       CREATE_FILE,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::CreateFile(
-          event_router_, file_system_info_, file_path, callback)));
+      scoped_ptr<RequestManager::HandlerInterface>(
+          new operations::CreateFile<source>(event_router_, file_system_info_,
+                                             file_path, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CopyEntry(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::CopyEntry(
     const base::FilePath& source_path,
     const base::FilePath& target_path,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
-      COPY_ENTRY,
-      scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::CopyEntry(event_router_,
-                                    file_system_info_,
-                                    source_path,
-                                    target_path,
-                                    callback)));
+      COPY_ENTRY, scoped_ptr<RequestManager::HandlerInterface>(
+                      new operations::CopyEntry<source>(
+                          event_router_, file_system_info_, source_path,
+                          target_path, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::WriteFile(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::WriteFile(
     int file_handle,
     net::IOBuffer* buffer,
     int64 offset,
@@ -365,61 +391,58 @@ AbortCallback ProvidedFileSystem::WriteFile(
   const int request_id = request_manager_->CreateRequest(
       WRITE_FILE,
       make_scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::WriteFile(event_router_,
-                                    file_system_info_,
-                                    file_handle,
-                                    make_scoped_refptr(buffer),
-                                    offset,
-                                    length,
-                                    callback)));
+          new operations::WriteFile<source>(
+              event_router_, file_system_info_, file_handle,
+              make_scoped_refptr(buffer), offset, length, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::MoveEntry(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::MoveEntry(
     const base::FilePath& source_path,
     const base::FilePath& target_path,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
-      MOVE_ENTRY,
-      scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::MoveEntry(event_router_,
-                                    file_system_info_,
-                                    source_path,
-                                    target_path,
-                                    callback)));
+      MOVE_ENTRY, scoped_ptr<RequestManager::HandlerInterface>(
+                      new operations::MoveEntry<source>(
+                          event_router_, file_system_info_, source_path,
+                          target_path, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::Truncate(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::Truncate(
     const base::FilePath& file_path,
     int64 length,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
       TRUNCATE,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::Truncate(
-          event_router_, file_system_info_, file_path, length, callback)));
+      scoped_ptr<RequestManager::HandlerInterface>(
+          new operations::Truncate<source>(event_router_, file_system_info_,
+                                           file_path, length, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<source>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::AddWatcher(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::AddWatcher(
     const GURL& origin,
     const base::FilePath& entry_path,
     bool recursive,
@@ -429,7 +452,7 @@ AbortCallback ProvidedFileSystem::AddWatcher(
         notification_callback) {
   const size_t token = watcher_queue_.NewToken();
   watcher_queue_.Enqueue(
-      token, base::Bind(&ProvidedFileSystem::AddWatcherInQueue,
+      token, base::Bind(&ProvidedFileSystem<source>::AddWatcherInQueue,
                         base::Unretained(this),  // Outlived by the queue.
                         AddWatcherInQueueArgs(token, origin, entry_path,
                                               recursive, persistent, callback,
@@ -437,45 +460,56 @@ AbortCallback ProvidedFileSystem::AddWatcher(
   return AbortCallback();
 }
 
-void ProvidedFileSystem::RemoveWatcher(
+template <int source>
+void ProvidedFileSystem<source>::RemoveWatcher(
     const GURL& origin,
     const base::FilePath& entry_path,
     bool recursive,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const size_t token = watcher_queue_.NewToken();
   watcher_queue_.Enqueue(
-      token, base::Bind(&ProvidedFileSystem::RemoveWatcherInQueue,
+      token, base::Bind(&ProvidedFileSystem<source>::RemoveWatcherInQueue,
                         base::Unretained(this),  // Outlived by the queue.
                         token, origin, entry_path, recursive, callback));
 }
 
-const ProvidedFileSystemInfo& ProvidedFileSystem::GetFileSystemInfo() const {
+template <int source>
+const ProvidedFileSystemInfo& ProvidedFileSystem<source>::GetFileSystemInfo()
+    const {
   return file_system_info_;
 }
 
-RequestManager* ProvidedFileSystem::GetRequestManager() {
+template <int source>
+RequestManager* ProvidedFileSystem<source>::GetRequestManager() {
   return request_manager_.get();
 }
 
-Watchers* ProvidedFileSystem::GetWatchers() {
+template <int source>
+Watchers* ProvidedFileSystem<source>::GetWatchers() {
   return &watchers_;
 }
 
-const OpenedFiles& ProvidedFileSystem::GetOpenedFiles() const {
+template <int source>
+const OpenedFiles& ProvidedFileSystem<source>::GetOpenedFiles() const {
   return opened_files_;
 }
 
-void ProvidedFileSystem::AddObserver(ProvidedFileSystemObserver* observer) {
+template <int source>
+void ProvidedFileSystem<source>::AddObserver(
+    ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
-void ProvidedFileSystem::RemoveObserver(ProvidedFileSystemObserver* observer) {
+template <int source>
+void ProvidedFileSystem<source>::RemoveObserver(
+    ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
-void ProvidedFileSystem::Notify(
+template <int source>
+void ProvidedFileSystem<source>::Notify(
     const base::FilePath& entry_path,
     bool recursive,
     storage::WatcherManager::ChangeType change_type,
@@ -484,37 +518,40 @@ void ProvidedFileSystem::Notify(
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const size_t token = watcher_queue_.NewToken();
   watcher_queue_.Enqueue(
-      token, base::Bind(&ProvidedFileSystem::NotifyInQueue,
+      token, base::Bind(&ProvidedFileSystem<source>::NotifyInQueue,
                         base::Unretained(this),  // Outlived by the queue.
                         base::Passed(make_scoped_ptr(new NotifyInQueueArgs(
                             token, entry_path, recursive, change_type,
                             changes.Pass(), tag, callback)))));
 }
 
-void ProvidedFileSystem::Configure(
+template <int source>
+void ProvidedFileSystem<source>::Configure(
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const int request_id = request_manager_->CreateRequest(
-      CONFIGURE,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::Configure(
-          event_router_, file_system_info_, callback)));
+      CONFIGURE, scoped_ptr<RequestManager::HandlerInterface>(
+                     new operations::Configure<source>(
+                         event_router_, file_system_info_, callback)));
   if (!request_id)
     callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
-void ProvidedFileSystem::Abort(int operation_request_id) {
+template <int source>
+void ProvidedFileSystem<source>::Abort(int operation_request_id) {
   request_manager_->RejectRequest(operation_request_id,
                                   make_scoped_ptr(new RequestValue()),
                                   base::File::FILE_ERROR_ABORT);
   if (!request_manager_->CreateRequest(
-          ABORT,
-          scoped_ptr<RequestManager::HandlerInterface>(new operations::Abort(
-              event_router_, file_system_info_, operation_request_id,
-              base::Bind(&EmptyStatusCallback))))) {
+          ABORT, scoped_ptr<RequestManager::HandlerInterface>(
+                     new operations::Abort<source>(
+                         event_router_, file_system_info_, operation_request_id,
+                         base::Bind(&EmptyStatusCallback))))) {
     LOG(ERROR) << "Failed to create an abort request.";
   }
 }
 
-AbortCallback ProvidedFileSystem::AddWatcherInQueue(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::AddWatcherInQueue(
     const AddWatcherInQueueArgs& args) {
   if (args.persistent && (!file_system_info_.supports_notify_tag() ||
                           !args.notification_callback.is_null())) {
@@ -544,12 +581,13 @@ AbortCallback ProvidedFileSystem::AddWatcherInQueue(
 
   const int request_id = request_manager_->CreateRequest(
       ADD_WATCHER,
-      scoped_ptr<RequestManager::HandlerInterface>(new operations::AddWatcher(
-          event_router_, file_system_info_, args.entry_path, args.recursive,
-          base::Bind(&ProvidedFileSystem::OnAddWatcherInQueueCompleted,
-                     weak_ptr_factory_.GetWeakPtr(), args.token,
-                     args.entry_path, args.recursive, subscriber,
-                     args.callback))));
+      scoped_ptr<RequestManager::HandlerInterface>(
+          new operations::AddWatcher<source>(
+              event_router_, file_system_info_, args.entry_path, args.recursive,
+              base::Bind(
+                  &ProvidedFileSystem<source>::OnAddWatcherInQueueCompleted,
+                  weak_ptr_factory_.GetWeakPtr(), args.token, args.entry_path,
+                  args.recursive, subscriber, args.callback))));
 
   if (!request_id) {
     OnAddWatcherInQueueCompleted(args.token, args.entry_path, args.recursive,
@@ -560,7 +598,8 @@ AbortCallback ProvidedFileSystem::AddWatcherInQueue(
   return AbortCallback();
 }
 
-AbortCallback ProvidedFileSystem::RemoveWatcherInQueue(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::RemoveWatcherInQueue(
     size_t token,
     const GURL& origin,
     const base::FilePath& entry_path,
@@ -589,16 +628,18 @@ AbortCallback ProvidedFileSystem::RemoveWatcherInQueue(
   request_manager_->CreateRequest(
       REMOVE_WATCHER,
       scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::RemoveWatcher(
+          new operations::RemoveWatcher<source>(
               event_router_, file_system_info_, entry_path, recursive,
-              base::Bind(&ProvidedFileSystem::OnRemoveWatcherInQueueCompleted,
-                         weak_ptr_factory_.GetWeakPtr(), token, origin, key,
-                         callback, true /* extension_response */))));
+              base::Bind(
+                  &ProvidedFileSystem<source>::OnRemoveWatcherInQueueCompleted,
+                  weak_ptr_factory_.GetWeakPtr(), token, origin, key, callback,
+                  true /* extension_response */))));
 
   return AbortCallback();
 }
 
-AbortCallback ProvidedFileSystem::NotifyInQueue(
+template <int source>
+AbortCallback ProvidedFileSystem<source>::NotifyInQueue(
     scoped_ptr<NotifyInQueueArgs> args) {
   const WatcherKey key(args->entry_path, args->recursive);
   const auto& watcher_it = watchers_.find(key);
@@ -626,10 +667,10 @@ AbortCallback ProvidedFileSystem::NotifyInQueue(
   const ProvidedFileSystemObserver::Changes& changes_ref = *args->changes.get();
   const storage::WatcherManager::ChangeType change_type = args->change_type;
 
-  scoped_refptr<AutoUpdater> auto_updater(
-      new AutoUpdater(base::Bind(&ProvidedFileSystem::OnNotifyInQueueCompleted,
-                                 weak_ptr_factory_.GetWeakPtr(),
-                                 base::Passed(&args), base::File::FILE_OK)));
+  scoped_refptr<AutoUpdater> auto_updater(new AutoUpdater(
+      base::Bind(&ProvidedFileSystem<source>::OnNotifyInQueueCompleted,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&args),
+                 base::File::FILE_OK)));
 
   // Call all notification callbacks (if any).
   for (const auto& subscriber_it : watcher_it->second.subscribers) {
@@ -651,11 +692,14 @@ AbortCallback ProvidedFileSystem::NotifyInQueue(
   return AbortCallback();
 }
 
-base::WeakPtr<ProvidedFileSystemInterface> ProvidedFileSystem::GetWeakPtr() {
+template <int source>
+base::WeakPtr<ProvidedFileSystemInterface>
+ProvidedFileSystem<source>::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-void ProvidedFileSystem::OnAddWatcherInQueueCompleted(
+template <int source>
+void ProvidedFileSystem<source>::OnAddWatcherInQueueCompleted(
     size_t token,
     const base::FilePath& entry_path,
     bool recursive,
@@ -689,7 +733,8 @@ void ProvidedFileSystem::OnAddWatcherInQueueCompleted(
   watcher_queue_.Complete(token);
 }
 
-void ProvidedFileSystem::OnRemoveWatcherInQueueCompleted(
+template <int source>
+void ProvidedFileSystem<source>::OnRemoveWatcherInQueueCompleted(
     size_t token,
     const GURL& origin,
     const WatcherKey& key,
@@ -721,7 +766,8 @@ void ProvidedFileSystem::OnRemoveWatcherInQueueCompleted(
   watcher_queue_.Complete(token);
 }
 
-void ProvidedFileSystem::OnNotifyInQueueCompleted(
+template <int source>
+void ProvidedFileSystem<source>::OnNotifyInQueueCompleted(
     scoped_ptr<NotifyInQueueArgs> args,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
@@ -760,11 +806,13 @@ void ProvidedFileSystem::OnNotifyInQueueCompleted(
   watcher_queue_.Complete(args->token);
 }
 
-void ProvidedFileSystem::OnOpenFileCompleted(const base::FilePath& file_path,
-                                             OpenFileMode mode,
-                                             const OpenFileCallback& callback,
-                                             int file_handle,
-                                             base::File::Error result) {
+template <int source>
+void ProvidedFileSystem<source>::OnOpenFileCompleted(
+    const base::FilePath& file_path,
+    OpenFileMode mode,
+    const OpenFileCallback& callback,
+    int file_handle,
+    base::File::Error result) {
   if (result != base::File::FILE_OK) {
     callback.Run(file_handle, result);
     return;
@@ -774,7 +822,8 @@ void ProvidedFileSystem::OnOpenFileCompleted(const base::FilePath& file_path,
   callback.Run(file_handle, base::File::FILE_OK);
 }
 
-void ProvidedFileSystem::OnCloseFileCompleted(
+template <int source>
+void ProvidedFileSystem<source>::OnCloseFileCompleted(
     int file_handle,
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
@@ -784,5 +833,8 @@ void ProvidedFileSystem::OnCloseFileCompleted(
   callback.Run(result);
 }
 
+template class ProvidedFileSystem<Source_Type::extension>;
+template class ProvidedFileSystem<Source_Type::plugin>;
+
 }  // namespace file_system_provider
 }  // namespace chromeos