Apply clang-format with Chromium-style without column limit.

third_party/WebKit/Source/wtf/ArrayBufferContents.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 19 matching lines @@
 #include "wtf/Assertions.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/WTF.h"
 #include "wtf/WTFExport.h"
 
 namespace WTF {
 
 class WTF_EXPORT ArrayBufferContents {
-    WTF_MAKE_NONCOPYABLE(ArrayBufferContents);
-public:
-    enum InitializationPolicy {
-        ZeroInitialize,
-        DontInitialize
-    };
+  WTF_MAKE_NONCOPYABLE(ArrayBufferContents);
 
-    enum SharingType {
-        NotShared,
-        Shared,
-    };
+ public:
+  enum InitializationPolicy {
+    ZeroInitialize,
+    DontInitialize
+  };
 
-    ArrayBufferContents();
-    ArrayBufferContents(unsigned numElements, unsigned elementByteSize, SharingType isShared, ArrayBufferContents::InitializationPolicy);
+  enum SharingType {
+    NotShared,
+    Shared,
+  };
 
-    // 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();
+  ArrayBufferContents(unsigned numElements, unsigned elementByteSize, SharingType isShared, ArrayBufferContents::InitializationPolicy);
 
-    ~ArrayBufferContents();
+  // 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);
 
-    void neuter();
+  ~ArrayBufferContents();
 
-    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 neuter();
 
-    void transfer(ArrayBufferContents& other);
-    void shareWith(ArrayBufferContents& other);
-    void copyTo(ArrayBufferContents& other);
+  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; }
 
-    static void allocateMemory(size_t, InitializationPolicy, void*&);
-    static void freeMemory(void*, size_t);
-    static void setAdjustAmoutOfExternalAllocatedMemoryFunction(AdjustAmountOfExternalAllocatedMemoryFunction function)
-    {
-        ASSERT(!s_adjustAmountOfExternalAllocatedMemoryFunction);
-        s_adjustAmountOfExternalAllocatedMemoryFunction = function;
-    }
+  void transfer(ArrayBufferContents& other);
+  void shareWith(ArrayBufferContents& other);
+  void copyTo(ArrayBufferContents& other);
 
-private:
-    class DataHolder : public ThreadSafeRefCounted<DataHolder> {
-        WTF_MAKE_NONCOPYABLE(DataHolder);
-    public:
-        DataHolder();
-        ~DataHolder();
+  static void allocateMemory(size_t, InitializationPolicy, void*&);
+  static void freeMemory(void*, size_t);
+  static void setAdjustAmoutOfExternalAllocatedMemoryFunction(AdjustAmountOfExternalAllocatedMemoryFunction function) {
+    ASSERT(!s_adjustAmountOfExternalAllocatedMemoryFunction);
+    s_adjustAmountOfExternalAllocatedMemoryFunction = function;
+  }
 
-        void allocateNew(unsigned sizeInBytes, SharingType isShared, InitializationPolicy);
-        void adopt(void* data, unsigned sizeInBytes, SharingType isShared);
-        void copyMemoryTo(DataHolder& other);
+ private:
+  class DataHolder : public ThreadSafeRefCounted<DataHolder> {
+    WTF_MAKE_NONCOPYABLE(DataHolder);
 
-        void* data() const { return m_data; }
-        unsigned sizeInBytes() const { return m_sizeInBytes; }
-        bool isShared() const { return m_isShared == Shared; }
+   public:
+    DataHolder();
+    ~DataHolder();
 
-    private:
-        void* m_data;
-        unsigned m_sizeInBytes;
-        SharingType m_isShared;
-    };
+    void allocateNew(unsigned sizeInBytes, SharingType isShared, InitializationPolicy);
+    void adopt(void* data, unsigned sizeInBytes, SharingType isShared);
+    void copyMemoryTo(DataHolder& other);
 
-    RefPtr<DataHolder> m_holder;
-    static AdjustAmountOfExternalAllocatedMemoryFunction s_adjustAmountOfExternalAllocatedMemoryFunction;
+    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