wtf reformat test

third_party/WebKit/Source/wtf/ArrayBufferContents.h

Index: third_party/WebKit/Source/wtf/ArrayBufferContents.h
diff --git a/third_party/WebKit/Source/wtf/ArrayBufferContents.h b/third_party/WebKit/Source/wtf/ArrayBufferContents.h
index 3050379251aa5d91f46e17676ae9f3e7acc5fa45..eb8653df7ea8d2bc8d11b72fb79e1c889b2e38c5 100644
--- a/third_party/WebKit/Source/wtf/ArrayBufferContents.h
+++ b/third_party/WebKit/Source/wtf/ArrayBufferContents.h
@@ -38,76 +38,86 @@
 namespace WTF {
 
 class WTF_EXPORT ArrayBufferContents {
-    WTF_MAKE_NONCOPYABLE(ArrayBufferContents);
-    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-public:
-    enum InitializationPolicy {
-        ZeroInitialize,
-        DontInitialize
-    };
-
-    enum SharingType {
-        NotShared,
-        Shared,
-    };
-
-    ArrayBufferContents();
-    ArrayBufferContents(unsigned numElements, unsigned elementByteSize, SharingType isShared, ArrayBufferContents::InitializationPolicy);
-
-    // Use with care. data must be allocated with allocateMemory.
-    // ArrayBufferContents will take ownership of the data and free it (using freeMemory)
-    // upon destruction.
-    // This constructor will not call observer->StartObserving(), so it is a responsibility
-    // of the caller to make sure JS knows about external memory.
-    ArrayBufferContents(void* data, unsigned sizeInBytes, SharingType isShared);
-
-    ~ArrayBufferContents();
-
-    void neuter();
-
-    void* data() const { return m_holder ? m_holder->data() : nullptr; }
-    unsigned sizeInBytes() const { return m_holder ? m_holder->sizeInBytes() : 0; }
-    bool isShared() const { return m_holder ? m_holder->isShared() : false; }
-
-    void transfer(ArrayBufferContents& other);
-    void shareWith(ArrayBufferContents& other);
-    void copyTo(ArrayBufferContents& other);
-
-    static void allocateMemory(size_t, InitializationPolicy, void*&);
-    static void allocateMemoryOrNull(size_t, InitializationPolicy, void*&);
-    static void freeMemory(void*, size_t);
-    static void setAdjustAmoutOfExternalAllocatedMemoryFunction(AdjustAmountOfExternalAllocatedMemoryFunction function)
-    {
-        ASSERT(!s_adjustAmountOfExternalAllocatedMemoryFunction);
-        s_adjustAmountOfExternalAllocatedMemoryFunction = function;
-    }
-
-private:
-    static void allocateMemoryWithFlags(size_t, InitializationPolicy, int, void*&);
-    class DataHolder : public ThreadSafeRefCounted<DataHolder> {
-        WTF_MAKE_NONCOPYABLE(DataHolder);
-    public:
-        DataHolder();
-        ~DataHolder();
-
-        void allocateNew(unsigned sizeInBytes, SharingType isShared, InitializationPolicy);
-        void adopt(void* data, unsigned sizeInBytes, SharingType isShared);
-        void copyMemoryTo(DataHolder& other);
-
-        void* data() const { return m_data; }
-        unsigned sizeInBytes() const { return m_sizeInBytes; }
-        bool isShared() const { return m_isShared == Shared; }
-
-    private:
-        void* m_data;
-        unsigned m_sizeInBytes;
-        SharingType m_isShared;
-    };
-
-    RefPtr<DataHolder> m_holder;
-    static AdjustAmountOfExternalAllocatedMemoryFunction s_adjustAmountOfExternalAllocatedMemoryFunction;
+  WTF_MAKE_NONCOPYABLE(ArrayBufferContents);
+  DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
+
+ public:
+  enum InitializationPolicy { ZeroInitialize, DontInitialize };
+
+  enum SharingType {
+    NotShared,
+    Shared,
+  };
+
+  ArrayBufferContents();
+  ArrayBufferContents(unsigned numElements,
+                      unsigned elementByteSize,
+                      SharingType isShared,
+                      ArrayBufferContents::InitializationPolicy);
+
+  // Use with care. data must be allocated with allocateMemory.
+  // ArrayBufferContents will take ownership of the data and free it (using freeMemory)
+  // upon destruction.
+  // This constructor will not call observer->StartObserving(), so it is a responsibility
+  // of the caller to make sure JS knows about external memory.
+  ArrayBufferContents(void* data, unsigned sizeInBytes, SharingType isShared);
+
+  ~ArrayBufferContents();
+
+  void neuter();
+
+  void* data() const { return m_holder ? m_holder->data() : nullptr; }
+  unsigned sizeInBytes() const {
+    return m_holder ? m_holder->sizeInBytes() : 0;
+  }
+  bool isShared() const { return m_holder ? m_holder->isShared() : false; }
+
+  void transfer(ArrayBufferContents& other);
+  void shareWith(ArrayBufferContents& other);
+  void copyTo(ArrayBufferContents& other);
+
+  static void allocateMemory(size_t, InitializationPolicy, void*&);
+  static void allocateMemoryOrNull(size_t, InitializationPolicy, void*&);
+  static void freeMemory(void*, size_t);
+  static void setAdjustAmoutOfExternalAllocatedMemoryFunction(
+      AdjustAmountOfExternalAllocatedMemoryFunction function) {
+    ASSERT(!s_adjustAmountOfExternalAllocatedMemoryFunction);
+    s_adjustAmountOfExternalAllocatedMemoryFunction = function;
+  }
+
+ private:
+  static void allocateMemoryWithFlags(size_t,
+                                      InitializationPolicy,
+                                      int,
+                                      void*&);
+  class DataHolder : public ThreadSafeRefCounted<DataHolder> {
+    WTF_MAKE_NONCOPYABLE(DataHolder);
+
+   public:
+    DataHolder();
+    ~DataHolder();
+
+    void allocateNew(unsigned sizeInBytes,
+                     SharingType isShared,
+                     InitializationPolicy);
+    void adopt(void* data, unsigned sizeInBytes, SharingType isShared);
+    void copyMemoryTo(DataHolder& other);
+
+    void* data() const { return m_data; }
+    unsigned sizeInBytes() const { return m_sizeInBytes; }
+    bool isShared() const { return m_isShared == Shared; }
+
+   private:
+    void* m_data;
+    unsigned m_sizeInBytes;
+    SharingType m_isShared;
+  };
+
+  RefPtr<DataHolder> m_holder;
+  static AdjustAmountOfExternalAllocatedMemoryFunction
+      s_adjustAmountOfExternalAllocatedMemoryFunction;
 };
 
-} // namespace WTF
+}  // namespace WTF
 
-#endif // ArrayBufferContents_h
+#endif  // ArrayBufferContents_h