Add clang-format integration for 'git cl format'.

.clang-format

+# Defines the ANGLE style for automatic reformatting.
+# https://code.google.com/p/angleproject/wiki/CodingStandard
+# See Clang docs: http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+BasedOnStyle: Chromium
+
+# Allow double brackets such as std::vector<std::vector<int>>.
+Standard: Cpp11
+
+# Indent 4 spaces at a time.
+IndentWidth: 4
+
+# Keep lines under 100 columns long.
+ColumnLimit: 100
+
+# Always break before braces
+BreakBeforeBraces: Allman
+
+# Indent case labels.
+IndentCaseLabels: true
+
+# Right-align pointers and references
+PointerAlignment: Right
+
+# ANGLE likes to align things as much as possible.
+AlignOperands: true
+AlignConsecutiveAssignments: true
+
+# Use 2 space negative offset for access modifiers
+AccessModifierOffset: -2
+
+# TODO(jmadill): Decide if we want this on. Doesn't have an "all or none" mode.
+AllowShortCaseLabelsOnASingleLine: false

.gitignore

@@ -39,3 +39,4 @@ TestResults.qpa
 *.psess
 *.vsp
 *.nvuser
+buildtools/

DEPS

+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+}
+
 deps = {
   "third_party/gyp":
-      "http://chromium.googlesource.com/external/gyp@b4781fc38236b0fb1238969c918a75a200cfffdb",
+      Var('chromium_git') + "/external/gyp@b4781fc38236b0fb1238969c918a75a200cfffdb",
 
   # TODO(kbr): figure out how to better stay in sync with Chromium's
   # versions of googletest and googlemock.
   "src/tests/third_party/googletest":
-      "http://chromium.googlesource.com/external/googletest.git@23574bf2333f834ff665f894c97bef8a5b33a0a9",
+      Var('chromium_git') + "/external/googletest.git@23574bf2333f834ff665f894c97bef8a5b33a0a9",
 
   "src/tests/third_party/googlemock":
-      "http://chromium.googlesource.com/external/googlemock.git@b2cb211e49d872101d991201362d7b97d7d69910",
+      Var('chromium_git') + "/external/googlemock.git@b2cb211e49d872101d991201362d7b97d7d69910",
 
   "third_party/deqp/src":
       "https://android.googlesource.com/platform/external/deqp@92f7752da82925ca5e7288c5b4814efa7a381d89",
@@ -17,10 +21,47 @@ deps = {
       "https://android.googlesource.com/platform/external/libpng@094e181e79a3d6c23fd005679025058b7df1ad6c",
 
   "third_party/zlib":
-      "https://chromium.googlesource.com/chromium/src/third_party/zlib@afd8c4593c010c045902f6c0501718f1823064a3",
+      Var('chromium_git') + "/chromium/src/third_party/zlib@afd8c4593c010c045902f6c0501718f1823064a3",
+
+  "buildtools":
+      Var('chromium_git') + '/chromium/buildtools.git@125d157607de4d7c95bf8b02dd580aae17962f19',
 }
 
 hooks = [
+  # Pull clang-format binaries using checked-in hashes.
+  {
+    'name': 'clang_format_win',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=win32',
+                '--no_auth',
+                '--bucket', 'chromium-clang-format',
+                '-s', 'buildtools/win/clang-format.exe.sha1',
+    ],
+  },
+  {
+    'name': 'clang_format_mac',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=darwin',
+                '--no_auth',
+                '--bucket', 'chromium-clang-format',
+                '-s', 'buildtools/mac/clang-format.sha1',
+    ],
+  },
+  {
+    'name': 'clang_format_linux',
+    'pattern': '.',
+    'action': [ 'download_from_google_storage',
+                '--no_resume',
+                '--platform=linux*',
+                '--no_auth',
+                '--bucket', 'chromium-clang-format',
+                '-s', 'buildtools/linux64/clang-format.sha1',
+    ],
+  },
   {
     # A change to a .gyp, .gypi, or to GYP itself should run the generator.
     "pattern": ".",

src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp

@@ -21,25 +21,24 @@ namespace
 template <typename T>
 GLuint ReadIndexValueFromIndices(const uint8_t *data, size_t index)
 {
-    return reinterpret_cast<const T*>(data)[index];
+    return reinterpret_cast<const T *>(data)[index];
 }
-typedef GLuint(*ReadIndexValueFunction)(const uint8_t *data, size_t index);
-
+typedef GLuint (*ReadIndexValueFunction)(const uint8_t *data, size_t index);
 }
 
 namespace rx
 {
-
 PackPixelsParams::PackPixelsParams()
-  : format(GL_NONE),
-    type(GL_NONE),
-    outputPitch(0),
-    packBuffer(nullptr),
-    offset(0)
-{}
-
-PackPixelsParams::PackPixelsParams(const gl::Rectangle &areaIn, GLenum formatIn, GLenum typeIn, GLuint outputPitchIn,
-                                   const gl::PixelPackState &packIn, ptrdiff_t offsetIn)
+    : format(GL_NONE), type(GL_NONE), outputPitch(0), packBuffer(nullptr), offset(0)
+{
+}
+
+PackPixelsParams::PackPixelsParams(const gl::Rectangle &areaIn,
+                                   GLenum formatIn,
+                                   GLenum typeIn,
+                                   GLuint outputPitchIn,
+                                   const gl::PixelPackState &packIn,
+                                   ptrdiff_t offsetIn)
     : area(areaIn),
       format(formatIn),
       type(typeIn),
@@ -47,7 +46,8 @@ PackPixelsParams::PackPixelsParams(const gl::Rectangle &areaIn, GLenum formatIn,
       packBuffer(packIn.pixelBuffer.get()),
       pack(packIn.alignment, packIn.reverseRowOrder),
       offset(offsetIn)
-{}
+{
+}
 
 namespace gl_d3d11
 {
@@ -80,7 +80,6 @@ D3D11_MAP GetD3DMapTypeFromBits(GLbitfield access)
         return D3D11_MAP_READ;
     }
 }
-
 }
 
 // Each instance of Buffer11::BufferStorage is specialized for a class of D3D binding points
@@ -100,8 +99,10 @@ class Buffer11::BufferStorage : angle::NonCopyable
 
     virtual bool isMappable() const = 0;
 
-    virtual bool copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                                 size_t size, size_t destOffset) = 0;
+    virtual bool copyFromStorage(BufferStorage *source,
+                                 size_t sourceOffset,
+                                 size_t size,
+                                 size_t destOffset) = 0;
     virtual gl::Error resize(size_t size, bool preserveData) = 0;
 
     virtual uint8_t *map(size_t offset, size_t length, GLbitfield access) = 0;
@@ -129,16 +130,20 @@ class Buffer11::NativeStorage : public Buffer11::BufferStorage
     bool isMappable() const override { return mUsage == BUFFER_USAGE_STAGING; }
 
     ID3D11Buffer *getNativeStorage() const { return mNativeStorage; }
-
-    bool copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                         size_t size, size_t destOffset) override;
+    bool copyFromStorage(BufferStorage *source,
+                         size_t sourceOffset,
+                         size_t size,
+                         size_t destOffset) override;
     gl::Error resize(size_t size, bool preserveData) override;
 
     uint8_t *map(size_t offset, size_t length, GLbitfield access) override;
     void unmap() override;
 
   private:
-    static void fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Renderer11 *renderer, BufferUsage usage, unsigned int bufferSize);
+    static void fillBufferDesc(D3D11_BUFFER_DESC *bufferDesc,
+                               Renderer11 *renderer,
+                               BufferUsage usage,
+                               unsigned int bufferSize);
 
     ID3D11Buffer *mNativeStorage;
 };
@@ -156,8 +161,10 @@ class Buffer11::EmulatedIndexedStorage : public Buffer11::BufferStorage
 
     ID3D11Buffer *getNativeStorage();
 
-    bool copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                         size_t size, size_t destOffset) override;
+    bool copyFromStorage(BufferStorage *source,
+                         size_t sourceOffset,
+                         size_t size,
+                         size_t destOffset) override;
 
     gl::Error resize(size_t size, bool preserveData) override;
 
@@ -183,15 +190,18 @@ class Buffer11::PackStorage : public Buffer11::BufferStorage
     ~PackStorage() override;
 
     bool isMappable() const override { return true; }
-
-    bool copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                         size_t size, size_t destOffset) override;
+    bool copyFromStorage(BufferStorage *source,
+                         size_t sourceOffset,
+                         size_t size,
+                         size_t destOffset) override;
     gl::Error resize(size_t size, bool preserveData) override;
 
     uint8_t *map(size_t offset, size_t length, GLbitfield access) override;
     void unmap() override;
 
-    gl::Error packPixels(ID3D11Texture2D *srcTexure, UINT srcSubresource, const PackPixelsParams &params);
+    gl::Error packPixels(ID3D11Texture2D *srcTexure,
+                         UINT srcSubresource,
+                         const PackPixelsParams &params);
 
   private:
     gl::Error flushQueuedPackCommand();
@@ -215,9 +225,10 @@ class Buffer11::SystemMemoryStorage : public Buffer11::BufferStorage
     ~SystemMemoryStorage() override {}
 
     bool isMappable() const override { return true; }
-
-    bool copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                         size_t size, size_t destOffset) override;
+    bool copyFromStorage(BufferStorage *source,
+                         size_t sourceOffset,
+                         size_t size,
+                         size_t destOffset) override;
     gl::Error resize(size_t size, bool preserveData) override;
 
     uint8_t *map(size_t offset, size_t length, GLbitfield access) override;
@@ -359,7 +370,10 @@ gl::Error Buffer11::setSubData(const void *data, size_t size, size_t offset)
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Buffer11::copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size)
+gl::Error Buffer11::copySubData(BufferImpl *source,
+                                GLintptr sourceOffset,
+                                GLintptr destOffset,
+                                GLsizeiptr size)
 {
     Buffer11 *sourceBuffer = GetAs<Buffer11>(source);
     ASSERT(sourceBuffer != nullptr);
@@ -425,8 +439,7 @@ gl::Error Buffer11::mapRange(size_t offset, size_t length, GLbitfield access, GL
     ASSERT(!mMappedStorage);
 
     BufferStorage *latestStorage = getLatestBufferStorage();
-    if (latestStorage &&
-        (latestStorage->getUsage() == BUFFER_USAGE_PIXEL_PACK ||
+    if (latestStorage && (latestStorage->getUsage() == BUFFER_USAGE_PIXEL_PACK ||
                           latestStorage->getUsage() == BUFFER_USAGE_STAGING))
     {
         // Latest storage is mappable.
@@ -475,7 +488,8 @@ gl::Error Buffer11::unmap(GLboolean *result)
 
 void Buffer11::markTransformFeedbackUsage()
 {
-    BufferStorage *transformFeedbackStorage = getBufferStorage(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
+    BufferStorage *transformFeedbackStorage =
+        getBufferStorage(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK);
 
     if (transformFeedbackStorage)
     {
@@ -517,7 +531,8 @@ ID3D11Buffer *Buffer11::getBuffer(BufferUsage usage)
     return GetAs<NativeStorage>(bufferStorage)->getNativeStorage();
 }
 
-ID3D11Buffer *Buffer11::getEmulatedIndexedBuffer(SourceIndexData *indexInfo, const TranslatedAttribute *attribute)
+ID3D11Buffer *Buffer11::getEmulatedIndexedBuffer(SourceIndexData *indexInfo,
+                                                 const TranslatedAttribute *attribute)
 {
     markBufferUsage();
 
@@ -612,7 +627,9 @@ ID3D11ShaderResourceView *Buffer11::getSRV(DXGI_FORMAT srvFormat)
     return bufferSRV;
 }
 
-gl::Error Buffer11::packPixels(ID3D11Texture2D *srcTexture, UINT srcSubresource, const PackPixelsParams &params)
+gl::Error Buffer11::packPixels(ID3D11Texture2D *srcTexture,
+                               UINT srcSubresource,
+                               const PackPixelsParams &params)
 {
     PackStorage *packStorage     = getPackStorage();
     BufferStorage *latestStorage = getLatestBufferStorage();
@@ -689,7 +706,8 @@ Buffer11::BufferStorage *Buffer11::getConstantBufferRangeStorage(GLintptr offset
     BufferStorage *newStorage;
 
     {
-        // Keep the cacheEntry in a limited scope because it may be invalidated later in the code if we need to reclaim some space.
+        // Keep the cacheEntry in a limited scope because it may be invalidated later in the code if
+        // we need to reclaim some space.
         ConstantBufferCacheEntry *cacheEntry = &mConstantBufferRangeStoragesCache[offset];
 
         if (!cacheEntry->storage)
@@ -710,8 +728,10 @@ Buffer11::BufferStorage *Buffer11::getConstantBufferRangeStorage(GLintptr offset
 
         while (mConstantBufferStorageAdditionalSize + sizeDelta > maximumAllowedAdditionalSize)
         {
-            auto iter = std::min_element(std::begin(mConstantBufferRangeStoragesCache), std::end(mConstantBufferRangeStoragesCache),
-                [](const ConstantBufferCache::value_type &a, const ConstantBufferCache::value_type &b)
+            auto iter = std::min_element(std::begin(mConstantBufferRangeStoragesCache),
+                                         std::end(mConstantBufferRangeStoragesCache),
+                                         [](const ConstantBufferCache::value_type &a,
+                                            const ConstantBufferCache::value_type &b)
                                          {
                                              return a.second.lruCount < b.second.lruCount;
                                          });
@@ -732,8 +752,9 @@ Buffer11::BufferStorage *Buffer11::getConstantBufferRangeStorage(GLintptr offset
 
         mConstantBufferStorageAdditionalSize += sizeDelta;
 
-        // We don't copy the old data when resizing the constant buffer because the data may be out-of-date
-        // therefore we reset the data revision and let updateBufferStorage() handle the copy.
+        // We don't copy the old data when resizing the constant buffer because the data may be
+        // out-of-date therefore we reset the data revision and let updateBufferStorage() handle the
+        // copy.
         newStorage->setDataRevision(0);
     }
 
@@ -835,10 +856,7 @@ bool Buffer11::supportsDirectBinding() const
 }
 
 Buffer11::BufferStorage::BufferStorage(Renderer11 *renderer, BufferUsage usage)
-    : mRenderer(renderer),
-      mRevision(0),
-      mUsage(usage),
-      mBufferSize(0)
+    : mRenderer(renderer), mRevision(0), mUsage(usage), mBufferSize(0)
 {
 }
 
@@ -860,8 +878,7 @@ gl::Error Buffer11::BufferStorage::setData(const uint8_t *data, size_t offset, s
 }
 
 Buffer11::NativeStorage::NativeStorage(Renderer11 *renderer, BufferUsage usage)
-    : BufferStorage(renderer, usage),
-      mNativeStorage(nullptr)
+    : BufferStorage(renderer, usage), mNativeStorage(nullptr)
 {
 }
 
@@ -871,8 +888,10 @@ Buffer11::NativeStorage::~NativeStorage()
 }
 
 // Returns true if it recreates the direct buffer
-bool Buffer11::NativeStorage::copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                                               size_t size, size_t destOffset)
+bool Buffer11::NativeStorage::copyFromStorage(BufferStorage *source,
+                                              size_t sourceOffset,
+                                              size_t size,
+                                              size_t destOffset)
 {
     ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
@@ -923,7 +942,8 @@ bool Buffer11::NativeStorage::copyFromStorage(BufferStorage *source, size_t sour
 
         ID3D11Buffer *sourceBuffer = GetAs<NativeStorage>(source)->getNativeStorage();
 
-        context->CopySubresourceRegion(mNativeStorage, 0, destOffset, 0, 0, sourceBuffer, 0, &srcBox);
+        context->CopySubresourceRegion(mNativeStorage, 0, destOffset, 0, 0, sourceBuffer, 0,
+                                       &srcBox);
     }
 
     return createBuffer;
@@ -942,7 +962,8 @@ gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData)
 
     if (FAILED(result))
     {
-        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer, result: 0x%X.", result);
+        return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer, result: 0x%X.",
+                         result);
     }
 
     d3d11::SetDebugName(newBuffer, "Buffer11::NativeStorage");
@@ -972,8 +993,10 @@ gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData)
     return gl::Error(GL_NO_ERROR);
 }
 
-void Buffer11::NativeStorage::fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Renderer11 *renderer,
-                                                     BufferUsage usage, unsigned int bufferSize)
+void Buffer11::NativeStorage::fillBufferDesc(D3D11_BUFFER_DESC *bufferDesc,
+                                             Renderer11 *renderer,
+                                             BufferUsage usage,
+                                             unsigned int bufferSize)
 {
     bufferDesc->ByteWidth           = bufferSize;
     bufferDesc->MiscFlags           = 0;
@@ -1019,7 +1042,9 @@ void Buffer11::NativeStorage::fillBufferDesc(D3D11_BUFFER_DESC* bufferDesc, Rend
             // Constant buffers must be of a limited size, and aligned to 16 byte boundaries
             // For our purposes we ignore any buffer data past the maximum constant buffer size
             bufferDesc->ByteWidth = roundUp(bufferDesc->ByteWidth, 16u);
-        bufferDesc->ByteWidth = std::min<UINT>(bufferDesc->ByteWidth, static_cast<UINT>(renderer->getRendererCaps().maxUniformBlockSize));
+            bufferDesc->ByteWidth =
+                std::min<UINT>(bufferDesc->ByteWidth,
+                               static_cast<UINT>(renderer->getRendererCaps().maxUniformBlockSize));
             break;
 
         default:
@@ -1042,7 +1067,7 @@ uint8_t *Buffer11::NativeStorage::map(size_t offset, size_t length, GLbitfield a
     {
         return nullptr;
     }
-    return static_cast<uint8_t*>(mappedResource.pData) + offset;
+    return static_cast<uint8_t *>(mappedResource.pData) + offset;
 }
 
 void Buffer11::NativeStorage::unmap()
@@ -1053,8 +1078,7 @@ void Buffer11::NativeStorage::unmap()
 }
 
 Buffer11::EmulatedIndexedStorage::EmulatedIndexedStorage(Renderer11 *renderer)
-    : BufferStorage(renderer, BUFFER_USAGE_EMULATED_INDEXED_VERTEX),
-      mNativeStorage(nullptr)
+    : BufferStorage(renderer, BUFFER_USAGE_EMULATED_INDEXED_VERTEX), mNativeStorage(nullptr)
 {
 }
 
@@ -1079,19 +1103,25 @@ ID3D11Buffer *Buffer11::EmulatedIndexedStorage::getNativeStorage()
         ZeroMemory(expandedData.data(), expandedDataSize);
 
         uint8_t *curr      = expandedData.data();
-        const uint8_t *ptr = static_cast<const uint8_t*>(mIndexInfo.srcIndices);
+        const uint8_t *ptr = static_cast<const uint8_t *>(mIndexInfo.srcIndices);
 
-        // Ensure that we start in the correct place for the emulated data copy operation to maintain
-        // offset behaviors.
+        // Ensure that we start in the correct place for the emulated data copy operation to
+        // maintain offset behaviors.
         curr += mAttributeOffset;
 
         ReadIndexValueFunction readIndexValue = ReadIndexValueFromIndices<GLushort>;
 
         switch (mIndexInfo.srcIndexType)
         {
-          case GL_UNSIGNED_INT: readIndexValue = ReadIndexValueFromIndices<GLuint>; break;
-          case GL_UNSIGNED_SHORT: readIndexValue = ReadIndexValueFromIndices<GLushort>; break;
-          case GL_UNSIGNED_BYTE: readIndexValue = ReadIndexValueFromIndices<GLubyte>; break;
+            case GL_UNSIGNED_INT:
+                readIndexValue = ReadIndexValueFromIndices<GLuint>;
+                break;
+            case GL_UNSIGNED_SHORT:
+                readIndexValue = ReadIndexValueFromIndices<GLushort>;
+                break;
+            case GL_UNSIGNED_BYTE:
+                readIndexValue = ReadIndexValueFromIndices<GLubyte>;
+                break;
         }
 
         // Iterate over the cached index data and copy entries indicated into the emulated buffer.
@@ -1102,8 +1132,8 @@ ID3D11Buffer *Buffer11::EmulatedIndexedStorage::getNativeStorage()
             curr += mAttributeStride;
         }
 
-        // Finally, initialize the emulated indexed native storage object with the newly copied data and free
-        // the temporary buffers used.
+        // Finally, initialize the emulated indexed native storage object with the newly copied data
+        // and free the temporary buffers used.
         ID3D11Device *device = mRenderer->getDevice();
 
         D3D11_BUFFER_DESC bufferDesc;
@@ -1114,7 +1144,7 @@ ID3D11Buffer *Buffer11::EmulatedIndexedStorage::getNativeStorage()
         bufferDesc.BindFlags           = D3D11_BIND_VERTEX_BUFFER;
         bufferDesc.CPUAccessFlags      = 0;
 
-        D3D11_SUBRESOURCE_DATA subResourceData = { expandedData.data(), 0, 0 };
+        D3D11_SUBRESOURCE_DATA subResourceData = {expandedData.data(), 0, 0};
 
         HRESULT result = device->CreateBuffer(&bufferDesc, &subResourceData, &mNativeStorage);
         if (FAILED(result))
@@ -1128,7 +1158,8 @@ ID3D11Buffer *Buffer11::EmulatedIndexedStorage::getNativeStorage()
     return mNativeStorage;
 }
 
-bool Buffer11::EmulatedIndexedStorage::update(SourceIndexData *indexInfo, const TranslatedAttribute *attribute)
+bool Buffer11::EmulatedIndexedStorage::update(SourceIndexData *indexInfo,
+                                              const TranslatedAttribute *attribute)
 {
     // If a change in the indices applied from the last draw call is detected, then the emulated
     // indexed buffer needs to be invalidated.  After invalidation, the change detected flag should
@@ -1146,10 +1177,18 @@ bool Buffer11::EmulatedIndexedStorage::update(SourceIndexData *indexInfo, const
         size_t indicesDataSize = 0;
         switch (indexInfo->srcIndexType)
         {
-          case GL_UNSIGNED_INT: indicesDataSize = sizeof(GLuint) * indexInfo->srcCount; break;
-          case GL_UNSIGNED_SHORT: indicesDataSize = sizeof(GLushort) * indexInfo->srcCount; break;
-          case GL_UNSIGNED_BYTE: indicesDataSize = sizeof(GLubyte) * indexInfo->srcCount; break;
-          default: indicesDataSize = sizeof(GLushort) * indexInfo->srcCount; break;
+            case GL_UNSIGNED_INT:
+                indicesDataSize = sizeof(GLuint) * indexInfo->srcCount;
+                break;
+            case GL_UNSIGNED_SHORT:
+                indicesDataSize = sizeof(GLushort) * indexInfo->srcCount;
+                break;
+            case GL_UNSIGNED_BYTE:
+                indicesDataSize = sizeof(GLubyte) * indexInfo->srcCount;
+                break;
+            default:
+                indicesDataSize = sizeof(GLushort) * indexInfo->srcCount;
+                break;
         }
 
         if (!mIndicesMemoryBuffer.resize(indicesDataSize))
@@ -1169,8 +1208,10 @@ bool Buffer11::EmulatedIndexedStorage::update(SourceIndexData *indexInfo, const
     return true;
 }
 
-bool Buffer11::EmulatedIndexedStorage::copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                                                       size_t size, size_t destOffset)
+bool Buffer11::EmulatedIndexedStorage::copyFromStorage(BufferStorage *source,
+                                                       size_t sourceOffset,
+                                                       size_t size,
+                                                       size_t destOffset)
 {
     ASSERT(source->isMappable());
     const uint8_t *sourceData = source->map(sourceOffset, size, GL_MAP_READ_BIT);
@@ -1220,8 +1261,10 @@ Buffer11::PackStorage::~PackStorage()
     SafeDelete(mQueuedPackCommand);
 }
 
-bool Buffer11::PackStorage::copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                                              size_t size, size_t destOffset)
+bool Buffer11::PackStorage::copyFromStorage(BufferStorage *source,
+                                            size_t sourceOffset,
+                                            size_t size,
+                                            size_t destOffset)
 {
     // We copy through a staging buffer when drawing with a pack buffer,
     // or for other cases where we access the pack buffer
@@ -1267,7 +1310,9 @@ void Buffer11::PackStorage::unmap()
     // No-op
 }
 
-gl::Error Buffer11::PackStorage::packPixels(ID3D11Texture2D *srcTexure, UINT srcSubresource, const PackPixelsParams &params)
+gl::Error Buffer11::PackStorage::packPixels(ID3D11Texture2D *srcTexure,
+                                            UINT srcSubresource,
+                                            const PackPixelsParams &params)
 {
     gl::Error error = flushQueuedPackCommand();
     if (error.isError())
@@ -1281,8 +1326,7 @@ gl::Error Buffer11::PackStorage::packPixels(ID3D11Texture2D *srcTexure, UINT src
     srcTexure->GetDesc(&textureDesc);
 
     if (mStagingTexture != nullptr &&
-        (mTextureFormat != textureDesc.Format ||
-         mTextureSize.width != params.area.width ||
+        (mTextureFormat != textureDesc.Format || mTextureSize.width != params.area.width ||
          mTextureSize.height != params.area.height))
     {
         SafeRelease(mStagingTexture);
@@ -1334,7 +1378,8 @@ gl::Error Buffer11::PackStorage::packPixels(ID3D11Texture2D *srcTexure, UINT src
     srcBox.back   = 1;
 
     // Asynchronous copy
-    immediateContext->CopySubresourceRegion(mStagingTexture, 0, 0, 0, 0, srcTexure, srcSubresource, &srcBox);
+    immediateContext->CopySubresourceRegion(mStagingTexture, 0, 0, 0, 0, srcTexure, srcSubresource,
+                                            &srcBox);
 
     return gl::Error(GL_NO_ERROR);
 }
@@ -1345,7 +1390,8 @@ gl::Error Buffer11::PackStorage::flushQueuedPackCommand()
 
     if (mQueuedPackCommand)
     {
-        gl::Error error = mRenderer->packPixels(mStagingTexture, *mQueuedPackCommand, mMemoryBuffer.data());
+        gl::Error error =
+            mRenderer->packPixels(mStagingTexture, *mQueuedPackCommand, mMemoryBuffer.data());
         SafeDelete(mQueuedPackCommand);
         if (error.isError())
         {
@@ -1358,10 +1404,13 @@ gl::Error Buffer11::PackStorage::flushQueuedPackCommand()
 
 Buffer11::SystemMemoryStorage::SystemMemoryStorage(Renderer11 *renderer)
     : Buffer11::BufferStorage(renderer, BUFFER_USAGE_SYSTEM_MEMORY)
-{}
+{
+}
 
-bool Buffer11::SystemMemoryStorage::copyFromStorage(BufferStorage *source, size_t sourceOffset,
-                                                    size_t size, size_t destOffset)
+bool Buffer11::SystemMemoryStorage::copyFromStorage(BufferStorage *source,
+                                                    size_t sourceOffset,
+                                                    size_t size,
+                                                    size_t destOffset)
 {
     ASSERT(source->isMappable());
     const uint8_t *sourceData = source->map(sourceOffset, size, GL_MAP_READ_BIT);
@@ -1395,5 +1444,4 @@ void Buffer11::SystemMemoryStorage::unmap()
 {
     // No-op
 }
-
 }