Use a new Supplement constructor for LocalFrame's supplements

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 54 matching lines @@
   std::unique_ptr<AsyncFileSystemCallbacks> release() {
     return std::move(m_callbacks);
   }
 
   DEFINE_INLINE_TRACE() {}
 
  private:
   std::unique_ptr<AsyncFileSystemCallbacks> m_callbacks;
 };
 
-LocalFileSystem* LocalFileSystem::create(
-    std::unique_ptr<FileSystemClient> client) {
-  return new LocalFileSystem(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,
@@ skipping 117 matching lines @@
     fileSystemNotAvailable(context, callbacks);
     return;
   }
   KURL storagePartition =
       KURL(KURL(), context->getSecurityOrigin()->toString());
   fileSystem->deleteFileSystem(storagePartition,
                                static_cast<WebFileSystemType>(type),
                                callbacks->release());
 }
 
-LocalFileSystem::LocalFileSystem(std::unique_ptr<FileSystemClient> client)
-    : m_client(std::move(client)) {}
+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())
-    return static_cast<LocalFileSystem*>(Supplement<LocalFrame>::from(
-        toDocument(context).frame(), supplementName()));
+  if (context.isDocument()) {
+    LocalFileSystem* fileSystem =
+        static_cast<LocalFileSystem*>(Supplement<LocalFrame>::from(
+            toDocument(context).frame(), supplementName()));
+    DCHECK(fileSystem);
+    return fileSystem;
+  }
 
   WorkerClients* clients = toWorkerGlobalScope(context).clients();
   ASSERT(clients);
-  return static_cast<LocalFileSystem*>(
+  LocalFileSystem* fileSystem = static_cast<LocalFileSystem*>(
       Supplement<WorkerClients>::from(clients, supplementName()));
+  DCHECK(fileSystem);
+  return fileSystem;
 }
 
 void provideLocalFileSystemTo(LocalFrame& frame,
                               std::unique_ptr<FileSystemClient> client) {
   frame.provideSupplement(LocalFileSystem::supplementName(),
-                          LocalFileSystem::create(std::move(client)));
+                          new LocalFileSystem(frame, std::move(client)));
 }
 
-void provideLocalFileSystemToWorker(WorkerClients* clients,
+void provideLocalFileSystemToWorker(WorkerClients* workerClients,
                                     std::unique_ptr<FileSystemClient> client) {
-  clients->provideSupplement(LocalFileSystem::supplementName(),
-                             LocalFileSystem::create(std::move(client)));
+  Supplement<WorkerClients>::provideTo(
+      *workerClients, LocalFileSystem::supplementName(),
+      new LocalFileSystem(*workerClients, std::move(client)));
 }
 
 }  // namespace blink