Provide a per-supplement implementation of LocalFileSystem.

third_party/WebKit/Source/modules/filesystem/LocalFileSystem.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
  */
 
 #include "modules/filesystem/LocalFileSystem.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/fileapi/FileError.h"
 #include "core/frame/LocalFrame.h"
+#include "core/workers/WorkerClients.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "modules/filesystem/FileSystemClient.h"
 #include "platform/AsyncFileSystemCallbacks.h"
 #include "platform/ContentSettingCallbacks.h"
+#include "platform/Supplementable.h"
+#include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFileSystem.h"
-#include "wtf/Functional.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 void reportFailure(std::unique_ptr<AsyncFileSystemCallbacks> callbacks,
                    FileError::ErrorCode error) {
   callbacks->didFail(error);
 }
 
 }  // namespace
 
 class CallbackWrapper final
     : public GarbageCollectedFinalized<CallbackWrapper> {
  public:
-  CallbackWrapper(std::unique_ptr<AsyncFileSystemCallbacks> c)
+  explicit CallbackWrapper(std::unique_ptr<AsyncFileSystemCallbacks> c)
       : m_callbacks(std::move(c)) {}
-  virtual ~CallbackWrapper() {}
+  ~CallbackWrapper() {}
+
   std::unique_ptr<AsyncFileSystemCallbacks> release() {
     return std::move(m_callbacks);
   }
 
   DEFINE_INLINE_TRACE() {}
 
  private:
   std::unique_ptr<AsyncFileSystemCallbacks> m_callbacks;
 };
 
+template <typename T>
+class LocalFileSystemImpl final
+    : public GarbageCollectedFinalized<LocalFileSystemImpl<T>>,
+      public LocalFileSystem,
+      public Supplement<T> {
+  WTF_MAKE_NONCOPYABLE(LocalFileSystemImpl);
+  USING_GARBAGE_COLLECTED_MIXIN(LocalFileSystemImpl);
+
+ public:
+  LocalFileSystemImpl(T& supplementable,
+                      std::unique_ptr<FileSystemClient> client)
+      : LocalFileSystem(std::move(client)), Supplement<T>(supplementable) {}
+  ~LocalFileSystemImpl() = default;
+
+  void resolveURL(
+      ExecutionContext* context,
+      const KURL& fileSystemURL,
+      std::unique_ptr<AsyncFileSystemCallbacks> callbacks) override {
+    CallbackWrapper* wrapper = new CallbackWrapper(std::move(callbacks));
+    requestFileSystemAccessInternal(
+        context,
+        WTF::bind(&LocalFileSystemImpl::resolveURLInternal,
+                  wrapCrossThreadPersistent(this), wrapPersistent(context),
+                  fileSystemURL, wrapPersistent(wrapper)),
+        WTF::bind(&LocalFileSystemImpl::fileSystemNotAllowedInternal,
+                  wrapCrossThreadPersistent(this), wrapPersistent(context),
+                  wrapPersistent(wrapper)));
+  }
+
+  void requestFileSystem(
+      ExecutionContext* context,
+      FileSystemType type,
+      long long size,
+      std::unique_ptr<AsyncFileSystemCallbacks> callbacks) override {
+    CallbackWrapper* wrapper = new CallbackWrapper(std::move(callbacks));
+    requestFileSystemAccessInternal(
+        context,
+        WTF::bind(&LocalFileSystemImpl::fileSystemAllowedInternal,
+                  wrapCrossThreadPersistent(this), wrapPersistent(context),
+                  type, wrapPersistent(wrapper)),
+        WTF::bind(&LocalFileSystemImpl::fileSystemNotAllowedInternal,
+                  wrapCrossThreadPersistent(this), wrapPersistent(context),
+                  wrapPersistent(wrapper)));
+  }
+};
+
+LocalFileSystem::LocalFileSystem(std::unique_ptr<FileSystemClient> client)
+    : m_client(std::move(client)) {}
+
 LocalFileSystem::~LocalFileSystem() {}
 
-void LocalFileSystem::resolveURL(
-    ExecutionContext* context,
-    const KURL& fileSystemURL,
-    std::unique_ptr<AsyncFileSystemCallbacks> callbacks) {
-  CallbackWrapper* wrapper = new CallbackWrapper(std::move(callbacks));
-  requestFileSystemAccessInternal(
-      context,
-      WTF::bind(&LocalFileSystem::resolveURLInternal,
-                wrapCrossThreadPersistent(this), wrapPersistent(context),
-                fileSystemURL, wrapPersistent(wrapper)),
-      WTF::bind(&LocalFileSystem::fileSystemNotAllowedInternal,
-                wrapCrossThreadPersistent(this), wrapPersistent(context),
-                wrapPersistent(wrapper)));
-}
-
-void LocalFileSystem::requestFileSystem(
-    ExecutionContext* context,
-    FileSystemType type,
-    long long size,
-    std::unique_ptr<AsyncFileSystemCallbacks> callbacks) {
-  CallbackWrapper* wrapper = new CallbackWrapper(std::move(callbacks));
-  requestFileSystemAccessInternal(
-      context,
-      WTF::bind(&LocalFileSystem::fileSystemAllowedInternal,
-                wrapCrossThreadPersistent(this), wrapPersistent(context), type,
-                wrapPersistent(wrapper)),
-      WTF::bind(&LocalFileSystem::fileSystemNotAllowedInternal,
-                wrapCrossThreadPersistent(this), wrapPersistent(context),
-                wrapPersistent(wrapper)));
+const char* LocalFileSystem::supplementName() {
+  return "LocalFileSystem";
 }
 
 WebFileSystem* LocalFileSystem::getFileSystem() const {
   Platform* platform = Platform::current();
   if (!platform)
     return nullptr;
 
   return platform->fileSystem();
 }
 
@@ skipping 53 matching lines @@
                                          const KURL& fileSystemURL,
                                          CallbackWrapper* callbacks) {
   WebFileSystem* fileSystem = getFileSystem();
   if (!fileSystem) {
     fileSystemNotAvailable(context, callbacks);
     return;
   }
   fileSystem->resolveURL(fileSystemURL, callbacks->release());
 }
 
-LocalFileSystem::LocalFileSystem(LocalFrame& frame,
-                                 std::unique_ptr<FileSystemClient> client)
-    : Supplement<LocalFrame>(frame), m_client(std::move(client)) {}
-
-LocalFileSystem::LocalFileSystem(WorkerClients& workerClients,
-                                 std::unique_ptr<FileSystemClient> client)
-    : Supplement<WorkerClients>(workerClients), m_client(std::move(client)) {}
-
-DEFINE_TRACE(LocalFileSystem) {
-  Supplement<LocalFrame>::trace(visitor);
-  Supplement<WorkerClients>::trace(visitor);
-}
-
-const char* LocalFileSystem::supplementName() {
-  return "LocalFileSystem";
-}
-
 LocalFileSystem* LocalFileSystem::from(ExecutionContext& context) {
   if (context.isDocument()) {
-    LocalFileSystem* fileSystem =
-        static_cast<LocalFileSystem*>(Supplement<LocalFrame>::from(
-            toDocument(context).frame(), supplementName()));
+    auto fileSystem = static_cast<LocalFileSystemImpl<LocalFrame>*>(
+        Supplement<LocalFrame>::from(toDocument(context).frame(),
+                                     supplementName()));
     DCHECK(fileSystem);
     return fileSystem;
   }
 
   WorkerClients* clients = toWorkerGlobalScope(context).clients();
   ASSERT(clients);
-  LocalFileSystem* fileSystem = static_cast<LocalFileSystem*>(
+  auto fileSystem = static_cast<LocalFileSystemImpl<WorkerClients>*>(
       Supplement<WorkerClients>::from(clients, supplementName()));
   DCHECK(fileSystem);
   return fileSystem;
 }
 
 void provideLocalFileSystemTo(LocalFrame& frame,
                               std::unique_ptr<FileSystemClient> client) {
-  frame.provideSupplement(LocalFileSystem::supplementName(),
-                          new LocalFileSystem(frame, std::move(client)));
+  Supplement<LocalFrame>::provideTo(
+      frame, LocalFileSystem::supplementName(),
+      new LocalFileSystemImpl<LocalFrame>(frame, std::move(client)));
 }
 
-void provideLocalFileSystemToWorker(WorkerClients* workerClients,
+void provideLocalFileSystemToWorker(WorkerClients* clients,
                                     std::unique_ptr<FileSystemClient> client) {
   Supplement<WorkerClients>::provideTo(
-      *workerClients, LocalFileSystem::supplementName(),
-      new LocalFileSystem(*workerClients, std::move(client)));
+      *clients, LocalFileSystem::supplementName(),
+      new LocalFileSystemImpl<WorkerClients>(*clients, std::move(client)));
 }
 
 }  // namespace blink