[WIP] Provided file system from NACL.

chrome/browser/chromeos/file_system_provider/provided_file_system.cc

 // Copyright 2014 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/file_system_provider/provided_file_system.h"
 
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/trace_event/trace_event.h"
+#include "chrome/browser/chromeos/file_system_provider/file_system_plugin/plugin_operation_router.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"
 #include "chrome/browser/chromeos/file_system_provider/operations/close_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/configure.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/copy_entry.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/create_directory.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/create_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/delete_entry.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/move_entry.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/open_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/read_directory.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/read_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/remove_watcher.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/truncate.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/unmount.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/write_file.h"
 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/file_system_provider.h"
 #include "extensions/browser/event_router.h"
 
 namespace net {
 class IOBuffer;
 }  // namespace net
 
 namespace chromeos {
 namespace file_system_provider {
+
+
+typename ExtensionDestination::EventRouterType*
+ExtensionDestination::Get(Profile *profile) {
+  return extensions::EventRouter::Get(profile);
+}
+
+PluginDestination::EventRouterType* PluginDestination::Get(Profile *) {
+  return chromeos::file_system_provider::PluginOperationRouter::GetInstance();
+}
+
 namespace {
 
 // Discards the result of Abort() when called from the destructor.
 void EmptyStatusCallback(base::File::Error /* result */) {
 }
 
 }  // namespace
 
 AutoUpdater::AutoUpdater(const base::Closure& update_callback)
     : update_callback_(update_callback),
@@ skipping 14 matching lines @@
 }
 
 AutoUpdater::~AutoUpdater() {
   // If no callbacks are created, then we need to invoke updating in the
   // destructor.
   if (!created_callbacks_)
     update_callback_.Run();
   else if (pending_callbacks_)
     LOG(ERROR) << "Not all callbacks called. This may happen on shutdown.";
 }
-
-struct ProvidedFileSystem::AddWatcherInQueueArgs {
+template <class DestinationPolicy>
+struct ProvidedFileSystem<DestinationPolicy>::AddWatcherInQueueArgs {
   AddWatcherInQueueArgs(size_t token,
                         const GURL& origin,
                         const base::FilePath& entry_path,
                         bool recursive,
                         bool persistent,
                         const storage::AsyncFileUtil::StatusCallback& callback,
                         const storage::WatcherManager::NotificationCallback&
                             notification_callback)
       : token(token),
         origin(origin),
         entry_path(entry_path),
         recursive(recursive),
         persistent(persistent),
         callback(callback),
         notification_callback(notification_callback) {}
   ~AddWatcherInQueueArgs() {}
 
   const size_t token;
   const GURL origin;
   const base::FilePath entry_path;
   const bool recursive;
   const bool persistent;
   const storage::AsyncFileUtil::StatusCallback callback;
   const storage::WatcherManager::NotificationCallback notification_callback;
 };
 
-struct ProvidedFileSystem::NotifyInQueueArgs {
+template <class DestinationPolicy>
+struct ProvidedFileSystem<DestinationPolicy>::NotifyInQueueArgs {
   NotifyInQueueArgs(size_t token,
                     const base::FilePath& entry_path,
                     bool recursive,
                     storage::WatcherManager::ChangeType change_type,
                     scoped_ptr<ProvidedFileSystemObserver::Changes> changes,
                     const std::string& tag,
                     const storage::AsyncFileUtil::StatusCallback& callback)
       : token(token),
         entry_path(entry_path),
         recursive(recursive),
         change_type(change_type),
         changes(changes.Pass()),
         tag(tag),
         callback(callback) {}
   ~NotifyInQueueArgs() {}
 
   const size_t token;
   const base::FilePath entry_path;
   const bool recursive;
   const storage::WatcherManager::ChangeType change_type;
   const scoped_ptr<ProvidedFileSystemObserver::Changes> changes;
   const std::string tag;
   const storage::AsyncFileUtil::StatusCallback callback;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NotifyInQueueArgs);
 };
 
-ProvidedFileSystem::ProvidedFileSystem(
+template <class DestinationPolicy>
+ProvidedFileSystem<DestinationPolicy>::ProvidedFileSystem(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info)
     : profile_(profile),
-      event_router_(extensions::EventRouter::Get(profile)),  // May be NULL.
+      event_router_(DestinationPolicy::Get(profile)),  // May be NULL.
       file_system_info_(file_system_info),
       notification_manager_(
           new NotificationManager(profile_, file_system_info_)),
       request_manager_(new RequestManager(profile,
                                           file_system_info.extension_id(),
                                           notification_manager_.get())),
       watcher_queue_(1),
       weak_ptr_factory_(this) {
 }
-
-ProvidedFileSystem::~ProvidedFileSystem() {
+template <class DestinationPolicy>
+ProvidedFileSystem<DestinationPolicy>::~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 <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::SetEventRouterForTesting(
+    typename DestinationPolicy::EventRouterType* event_router) {
   event_router_ = event_router;
 }
 
-void ProvidedFileSystem::SetNotificationManagerForTesting(
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::SetNotificationManagerForTesting(
     scoped_ptr<NotificationManagerInterface> notification_manager) {
   notification_manager_ = notification_manager.Pass();
   request_manager_.reset(new RequestManager(
       profile_, file_system_info_.extension_id(), notification_manager_.get()));
 }
 
-AbortCallback ProvidedFileSystem::RequestUnmount(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                               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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::GetMetadata(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+              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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::ReadDirectory(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
               event_router_, file_system_info_, directory_path, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY,
                  storage::AsyncFileUtil::EntryList(),
                  false /* has_more */);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::ReadFile(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::ReadFile(
     int file_handle,
     net::IOBuffer* buffer,
     int64 offset,
     int length,
     const ReadChunkReceivedCallback& callback) {
   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<DestinationPolicy>(
+                         event_router_, file_system_info_, file_handle, buffer,
+                         offset, length, callback)));
   if (!request_id) {
     callback.Run(0 /* chunk_length */,
                  false /* has_more */,
                  base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
-  return base::Bind(
-      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+  return base::Bind(&ProvidedFileSystem<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::OpenFile(const base::FilePath& file_path,
-                                           OpenFileMode mode,
-                                           const OpenFileCallback& callback) {
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                         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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CloseFile(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+              event_router_, file_system_info_, file_handle,
+              base::Bind(
+                  &ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CreateDirectory(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                                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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::DeleteEntry(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                            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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CreateFile(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+              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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::CopyEntry(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                          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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::WriteFile(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::WriteFile(
     int file_handle,
     net::IOBuffer* buffer,
     int64 offset,
     int length,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   TRACE_EVENT1("file_system_provider",
                "ProvidedFileSystem::WriteFile",
                "length",
                length);
   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<DestinationPolicy>(
+              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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::MoveEntry(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                          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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::Truncate(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+              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<DestinationPolicy>::Abort,
+                    weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-AbortCallback ProvidedFileSystem::AddWatcher(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::AddWatcher(
     const GURL& origin,
     const base::FilePath& entry_path,
     bool recursive,
     bool persistent,
     const storage::AsyncFileUtil::StatusCallback& callback,
     const storage::WatcherManager::NotificationCallback&
         notification_callback) {
   const size_t token = watcher_queue_.NewToken();
   watcher_queue_.Enqueue(
-      token, base::Bind(&ProvidedFileSystem::AddWatcherInQueue,
-                        base::Unretained(this),  // Outlived by the queue.
-                        AddWatcherInQueueArgs(token, origin, entry_path,
-                                              recursive, persistent, callback,
-                                              notification_callback)));
+      token, base::Bind(
+                &ProvidedFileSystem<DestinationPolicy>::AddWatcherInQueue,
+                base::Unretained(this),  // Outlived by the queue.
+                AddWatcherInQueueArgs(token, origin, entry_path,
+                    recursive, persistent, callback,
+                    notification_callback)));
   return AbortCallback();
 }
 
-void ProvidedFileSystem::RemoveWatcher(
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::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,
-                        base::Unretained(this),  // Outlived by the queue.
-                        token, origin, entry_path, recursive, callback));
+      token, base::Bind(
+                &ProvidedFileSystem<DestinationPolicy>::RemoveWatcherInQueue,
+                base::Unretained(this),  // Outlived by the queue.
+                token, origin, entry_path, recursive, callback));
 }
 
-const ProvidedFileSystemInfo& ProvidedFileSystem::GetFileSystemInfo() const {
+template <class DestinationPolicy>
+const ProvidedFileSystemInfo&
+ProvidedFileSystem<DestinationPolicy>::GetFileSystemInfo() const {
   return file_system_info_;
 }
 
-RequestManager* ProvidedFileSystem::GetRequestManager() {
+template <class DestinationPolicy>
+RequestManager* ProvidedFileSystem<DestinationPolicy>::GetRequestManager() {
   return request_manager_.get();
 }
 
-Watchers* ProvidedFileSystem::GetWatchers() {
+template <class DestinationPolicy>
+Watchers* ProvidedFileSystem<DestinationPolicy>::GetWatchers() {
   return &watchers_;
 }
 
-const OpenedFiles& ProvidedFileSystem::GetOpenedFiles() const {
+template <class DestinationPolicy>
+const OpenedFiles&
+ProvidedFileSystem<DestinationPolicy>::GetOpenedFiles() const {
   return opened_files_;
 }
 
-void ProvidedFileSystem::AddObserver(ProvidedFileSystemObserver* observer) {
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::AddObserver(
+    ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
-void ProvidedFileSystem::RemoveObserver(ProvidedFileSystemObserver* observer) {
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::RemoveObserver(
+    ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
-void ProvidedFileSystem::Notify(
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::Notify(
     const base::FilePath& entry_path,
     bool recursive,
     storage::WatcherManager::ChangeType change_type,
     scoped_ptr<ProvidedFileSystemObserver::Changes> changes,
     const std::string& tag,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const size_t token = watcher_queue_.NewToken();
   watcher_queue_.Enqueue(
-      token, base::Bind(&ProvidedFileSystem::NotifyInQueue,
+      token, base::Bind(&ProvidedFileSystem<DestinationPolicy>::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 <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                         event_router_, file_system_info_, callback)));
   if (!request_id)
     callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
-void ProvidedFileSystem::Abort(int operation_request_id) {
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::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<DestinationPolicy>(
+                         event_router_, file_system_info_, operation_request_id,
+                         base::Bind(&EmptyStatusCallback))))) {
     LOG(ERROR) << "Failed to create an abort request.";
   }
 }
 
-AbortCallback ProvidedFileSystem::AddWatcherInQueue(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::AddWatcherInQueue(
     const AddWatcherInQueueArgs& args) {
   if (args.persistent && (!file_system_info_.supports_notify_tag() ||
                           !args.notification_callback.is_null())) {
     OnAddWatcherInQueueCompleted(args.token, args.entry_path, args.recursive,
                                  Subscriber(), args.callback,
                                  base::File::FILE_ERROR_INVALID_OPERATION);
     return AbortCallback();
   }
 
   // Create a candidate subscriber. This could be done in OnAddWatcherCompleted,
   // but base::Bind supports only up to 7 arguments.
   Subscriber subscriber;
   subscriber.origin = args.origin;
   subscriber.persistent = args.persistent;
   subscriber.notification_callback = args.notification_callback;
 
   const WatcherKey key(args.entry_path, args.recursive);
   const Watchers::const_iterator it = watchers_.find(key);
   if (it != watchers_.end()) {
     const bool exists = it->second.subscribers.find(args.origin) !=
                         it->second.subscribers.end();
     OnAddWatcherInQueueCompleted(
         args.token, args.entry_path, args.recursive, subscriber, args.callback,
         exists ? base::File::FILE_ERROR_EXISTS : base::File::FILE_OK);
     return AbortCallback();
   }
 
   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<DestinationPolicy>(
+              event_router_, file_system_info_, args.entry_path, args.recursive,
+              base::Bind(
+                  &ProvidedFileSystem<DestinationPolicy>::
+                      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,
                                  subscriber, args.callback,
                                  base::File::FILE_ERROR_SECURITY);
   }
 
   return AbortCallback();
 }
 
-AbortCallback ProvidedFileSystem::RemoveWatcherInQueue(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::RemoveWatcherInQueue(
     size_t token,
     const GURL& origin,
     const base::FilePath& entry_path,
     bool recursive,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const WatcherKey key(entry_path, recursive);
   const Watchers::iterator it = watchers_.find(key);
   if (it == watchers_.end() ||
       it->second.subscribers.find(origin) == it->second.subscribers.end()) {
     OnRemoveWatcherInQueueCompleted(token, origin, key, callback,
                                     false /* extension_response */,
                                     base::File::FILE_ERROR_NOT_FOUND);
     return AbortCallback();
   }
 
   // If there are other subscribers, then do not remove the observer, but simply
   // return a success.
   if (it->second.subscribers.size() > 1) {
     OnRemoveWatcherInQueueCompleted(token, origin, key, callback,
                                     false /* extension_response */,
                                     base::File::FILE_OK);
     return AbortCallback();
   }
 
   // Otherwise, emit an event, and remove the watcher.
   request_manager_->CreateRequest(
       REMOVE_WATCHER,
       scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::RemoveWatcher(
+          new operations::RemoveWatcher<DestinationPolicy>(
               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<DestinationPolicy>::
+                      OnRemoveWatcherInQueueCompleted,
+                  weak_ptr_factory_.GetWeakPtr(), token, origin, key, callback,
+                  true /* extension_response */))));
 
   return AbortCallback();
 }
 
-AbortCallback ProvidedFileSystem::NotifyInQueue(
+template <class DestinationPolicy>
+AbortCallback ProvidedFileSystem<DestinationPolicy>::NotifyInQueue(
     scoped_ptr<NotifyInQueueArgs> args) {
   const WatcherKey key(args->entry_path, args->recursive);
   const auto& watcher_it = watchers_.find(key);
   if (watcher_it == watchers_.end()) {
     OnNotifyInQueueCompleted(args.Pass(), base::File::FILE_ERROR_NOT_FOUND);
     return AbortCallback();
   }
 
   // The tag must be provided if and only if it's explicitly supported.
   if (file_system_info_.supports_notify_tag() == args->tag.empty()) {
     OnNotifyInQueueCompleted(args.Pass(),
                              base::File::FILE_ERROR_INVALID_OPERATION);
     return AbortCallback();
   }
 
   // It's illegal to provide a tag which is not unique.
   if (!args->tag.empty() && args->tag == watcher_it->second.last_tag) {
     OnNotifyInQueueCompleted(args.Pass(),
                              base::File::FILE_ERROR_INVALID_OPERATION);
     return AbortCallback();
   }
 
   // The object is owned by AutoUpdated, so the reference is valid as long as
   // callbacks created with AutoUpdater::CreateCallback().
   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<DestinationPolicy>::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) {
     const storage::WatcherManager::NotificationCallback& notification_callback =
         subscriber_it.second.notification_callback;
     if (!notification_callback.is_null())
       notification_callback.Run(change_type);
   }
 
   // Notify all observers.
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
                     OnWatcherChanged(file_system_info_,
                                      watcher_it->second,
                                      change_type,
                                      changes_ref,
                                      auto_updater->CreateCallback()));
 
   return AbortCallback();
 }
 
-base::WeakPtr<ProvidedFileSystemInterface> ProvidedFileSystem::GetWeakPtr() {
+template <class DestinationPolicy>
+base::WeakPtr<ProvidedFileSystemInterface>
+ProvidedFileSystem<DestinationPolicy>::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-void ProvidedFileSystem::OnAddWatcherInQueueCompleted(
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::OnAddWatcherInQueueCompleted(
     size_t token,
     const base::FilePath& entry_path,
     bool recursive,
     const Subscriber& subscriber,
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     callback.Run(result);
     watcher_queue_.Complete(token);
     return;
@@ skipping 13 matching lines @@
   watcher->subscribers[subscriber.origin] = subscriber;
 
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
                     OnWatcherListChanged(file_system_info_, watchers_));
 
   callback.Run(base::File::FILE_OK);
   watcher_queue_.Complete(token);
 }
 
-void ProvidedFileSystem::OnRemoveWatcherInQueueCompleted(
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::OnRemoveWatcherInQueueCompleted(
     size_t token,
     const GURL& origin,
     const WatcherKey& key,
     const storage::AsyncFileUtil::StatusCallback& callback,
     bool extension_response,
     base::File::Error result) {
   if (!extension_response && result != base::File::FILE_OK) {
     watcher_queue_.Complete(token);
     callback.Run(result);
     return;
@@ skipping 11 matching lines @@
                     OnWatcherListChanged(file_system_info_, watchers_));
 
   // If there are no more subscribers, then remove the watcher.
   if (!it->second.subscribers.size())
     watchers_.erase(it);
 
   callback.Run(base::File::FILE_OK);
   watcher_queue_.Complete(token);
 }
 
-void ProvidedFileSystem::OnNotifyInQueueCompleted(
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::OnNotifyInQueueCompleted(
     scoped_ptr<NotifyInQueueArgs> args,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     args->callback.Run(result);
     watcher_queue_.Complete(args->token);
     return;
   }
 
   // Check if the entry is still watched.
   const WatcherKey key(args->entry_path, args->recursive);
@@ skipping 18 matching lines @@
     for (const auto& subscriber_it : subscribers) {
       RemoveWatcher(subscriber_it.second.origin, args->entry_path,
                     args->recursive, base::Bind(&EmptyStatusCallback));
     }
   }
 
   args->callback.Run(base::File::FILE_OK);
   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 <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::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;
   }
 
   opened_files_[file_handle] = OpenedFile(file_path, mode);
   callback.Run(file_handle, base::File::FILE_OK);
 }
 
-void ProvidedFileSystem::OnCloseFileCompleted(
+template <class DestinationPolicy>
+void ProvidedFileSystem<DestinationPolicy>::OnCloseFileCompleted(
     int file_handle,
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   // Closing files is final. Even if an error happened, we remove it from the
   // list of opened files.
   opened_files_.erase(file_handle);
   callback.Run(result);
 }
 
+FOR_EACH_DESTINATION_SPECIALIZE(ProvidedFileSystem)
+
 }  // namespace file_system_provider
 }  // namespace chromeos