[part 1] Make classes and structures in modules/ fast-allocated.

Source/modules/fetch/DataConsumerHandleTestUtil.h

 // Copyright 2015 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.
 
 #ifndef DataConsumerHandleTestUtil_h
 #define DataConsumerHandleTestUtil_h
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/testing/NullExecutionContext.h"
 #include "gin/public/isolate_holder.h"
@@ skipping 16 matching lines @@
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <v8.h>
 
 namespace blink {
 
 class DataConsumerHandleTestUtil {
+    STATIC_ONLY(DataConsumerHandleTestUtil);
 public:
     class NoopClient final : public WebDataConsumerHandle::Client {
+        DISALLOW_ALLOCATION();
     public:
         void didGetReadable() override { }
     };
 
     // Thread has a WebThreadSupportingGC. It initializes / shutdowns
     // additional objects based on the given policy. The constructor and the
     // destructor blocks during the setup and the teardown.
     class Thread final {
+        WTF_MAKE_FAST_ALLOCATED(Thread);
     public:
         // Initialization policy of a thread.
         enum InitializationPolicy {
             // Only garbage collection is supported.
             GarbageCollection,
             // Creating an isolate in addition to GarbageCollection.
             ScriptExecution,
             // Creating an execution context in addition to ScriptExecution.
             WithExecutionContext,
         };
@@ skipping 90 matching lines @@
 
             // Protects |m_holder|.
             Mutex m_holderMutex;
             // Because Context outlives ThreadHolder, holding a raw pointer
             // here is safe.
             ThreadHolder* m_holder;
         };
 
         // The reading/updating threads are alive while ThreadHolder is alive.
         class ThreadHolder {
+            DISALLOW_ALLOCATION();
         public:
             ThreadHolder(ThreadingTestBase* test)
                 : m_context(test->m_context)
                 , m_readingThread(adoptPtr(new Thread("reading thread")))
                 , m_updatingThread(adoptPtr(new Thread("updating thread")))
             {
                 m_context->registerThreadHolder(this);
             }
             ~ThreadHolder()
             {
                 m_context->unregisterThreadHolder();
             }
 
             WebThreadSupportingGC* readingThread() { return m_readingThread->thread(); }
             WebThreadSupportingGC* updatingThread() { return m_updatingThread->thread(); }
 
         private:
             RefPtr<Context> m_context;
             OwnPtr<Thread> m_readingThread;
             OwnPtr<Thread> m_updatingThread;
         };
 
         class ReaderImpl final : public WebDataConsumerHandle::Reader {
+            WTF_MAKE_FAST_ALLOCATED(ReaderImpl);
         public:
             ReaderImpl(const String& name, PassRefPtr<Context> context) : m_name(name.isolatedCopy()), m_context(context)
             {
                 m_context->recordAttach(m_name.isolatedCopy());
             }
             ~ReaderImpl() override { m_context->recordDetach(m_name.isolatedCopy()); }
 
             using Result = WebDataConsumerHandle::Result;
             using Flags = WebDataConsumerHandle::Flags;
             Result read(void*, size_t, Flags, size_t*) override { return WebDataConsumerHandle::ShouldWait; }
             Result beginRead(const void**, Flags, size_t*) override { return WebDataConsumerHandle::ShouldWait; }
             Result endRead(size_t) override { return WebDataConsumerHandle::UnexpectedError; }
 
         private:
             const String m_name;
             RefPtr<Context> m_context;
         };
         class DataConsumerHandle final : public WebDataConsumerHandle {
+            WTF_MAKE_FAST_ALLOCATED(DataConsumerHandle);
         public:
             static PassOwnPtr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context)
             {
                 return adoptPtr(new DataConsumerHandle(name, context));
             }
 
         private:
             DataConsumerHandle(const String& name, PassRefPtr<Context> context) : m_name(name.isolatedCopy()), m_context(context) { }
 
             Reader* obtainReaderInternal(Client*) { return new ReaderImpl(m_name, m_context); }
@@ skipping 141 matching lines @@
         {
             didFetchDataLoadedArrayBufferMock(arrayBuffer);
         }
         void didFetchDataLoadedBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle) override
         {
             didFetchDataLoadedBlobHandleMock(blobDataHandle);
         }
     };
 
     class Command final {
+        ALLOW_ONLY_INLINE_ALLOCATION();
     public:
         enum Name {
             Data,
             Done,
             Error,
             Wait,
         };
 
         Command(Name name) : m_name(name) { }
         Command(Name name, const Vector<char>& body) : m_name(name), m_body(body) { }
         Command(Name name, const char* body, size_t size) : m_name(name)
         {
             m_body.append(body, size);
         }
         Command(Name name, const char* body) : Command(name, body, strlen(body)) { }
         Name name() const { return m_name; }
         const Vector<char>& body() const { return m_body; }
 
     private:
         const Name m_name;
         Vector<char> m_body;
     };
 
     // ReplayingHandle stores commands via |add| and replays the stored commends when read.
     class ReplayingHandle final : public WebDataConsumerHandle {
+        WTF_MAKE_FAST_ALLOCATED(ReplayingHandle);
     public:
         static PassOwnPtr<ReplayingHandle> create() { return adoptPtr(new ReplayingHandle()); }
         ~ReplayingHandle();
 
         // Add a command to this handle. This function must be called on the
         // creator thread. This function must be called BEFORE any reader is
         // obtained.
         void add(const Command&);
 
         class Context final : public ThreadSafeRefCounted<Context> {
@@ skipping 34 matching lines @@
         class ReaderImpl;
 
         ReplayingHandle();
         Reader* obtainReaderInternal(Client*) override;
         const char* debugName() const override { return "ReplayingHandle"; }
 
         RefPtr<Context> m_context;
     };
 
     class HandleReadResult final {
+        WTF_MAKE_FAST_ALLOCATED(HandleReadResult);
     public:
         HandleReadResult(WebDataConsumerHandle::Result result, const Vector<char>& data) : m_result(result), m_data(data) { }
         WebDataConsumerHandle::Result result() const { return m_result; }
         const Vector<char>& data() const { return m_data; }
 
     private:
         const WebDataConsumerHandle::Result m_result;
         const Vector<char> m_data;
     };
 
     // HandleReader reads all data from the given WebDataConsumerHandle using
     // Reader::read on the thread on which it is created. When reading is done
     // or failed, it calls the given callback with the result.
     class HandleReader final : public WebDataConsumerHandle::Client {
+        WTF_MAKE_FAST_ALLOCATED(HandleReader);
     public:
         using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>;
 
         HandleReader(PassOwnPtr<WebDataConsumerHandle>, PassOwnPtr<OnFinishedReading>);
         void didGetReadable() override;
 
     private:
         void runOnFinishedReading(PassOwnPtr<HandleReadResult>);
 
         OwnPtr<WebDataConsumerHandle::Reader> m_reader;
         OwnPtr<OnFinishedReading> m_onFinishedReading;
         Vector<char> m_data;
     };
 
     // HandleTwoPhaseReader does the same as HandleReader, but it uses
     // |beginRead| / |endRead| instead of |read|.
     class HandleTwoPhaseReader final : public WebDataConsumerHandle::Client {
+        WTF_MAKE_FAST_ALLOCATED(HandleTwoPhaseReader);
     public:
         using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>;
 
         HandleTwoPhaseReader(PassOwnPtr<WebDataConsumerHandle>, PassOwnPtr<OnFinishedReading>);
         void didGetReadable() override;
 
     private:
         void runOnFinishedReading(PassOwnPtr<HandleReadResult>);
 
         OwnPtr<WebDataConsumerHandle::Reader> m_reader;
         OwnPtr<OnFinishedReading> m_onFinishedReading;
         Vector<char> m_data;
     };
 
     // HandleReaderRunner<T> creates a dedicated thread and run T on the thread
     // where T is one of HandleReader and HandleTwophaseReader.
     template <typename T>
     class HandleReaderRunner final {
+        STACK_ALLOCATED();
     public:
         explicit HandleReaderRunner(PassOwnPtr<WebDataConsumerHandle> handle)
             : m_thread(adoptPtr(new Thread("reading thread")))
             , m_event(adoptPtr(Platform::current()->createWaitableEvent()))
             , m_isDone(false)
         {
             m_thread->thread()->postTask(FROM_HERE, new Task(threadSafeBind(&HandleReaderRunner::start, AllowCrossThreadAccess(this), handle)));
         }
         ~HandleReaderRunner()
         {
@@ skipping 27 matching lines @@
         OwnPtr<HandleReadResult> m_result;
         bool m_isDone;
 
         OwnPtr<T> m_handleReader;
     };
 };
 
 } // namespace blink
 
 #endif // DataConsumerHandleTestUtil_h