diff --git a/libs/hwui/renderthread/CacheManager.cpp b/libs/hwui/renderthread/CacheManager.cpp
index 0572a8d..a33b287 100644
--- a/libs/hwui/renderthread/CacheManager.cpp
+++ b/libs/hwui/renderthread/CacheManager.cpp
@@ -20,9 +20,9 @@
 #include "RenderThread.h"
 #include "renderstate/RenderState.h"
 
-#include <gui/Surface.h>
 #include <GrContextOptions.h>
 #include <SkExecutor.h>
+#include <gui/Surface.h>
 #include <math.h>
 #include <set>
 
@@ -42,9 +42,9 @@
 #define FONT_CACHE_MIN_MB (0.5f)
 #define FONT_CACHE_MAX_MB (4.0f)
 
-CacheManager::CacheManager(const DisplayInfo& display)
-        : mMaxSurfaceArea(display.w * display.h) {
-    mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(mMaxSurfaceArea/2,
+CacheManager::CacheManager(const DisplayInfo& display) : mMaxSurfaceArea(display.w * display.h) {
+    mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(
+            mMaxSurfaceArea / 2,
             skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);
 }
 
@@ -63,8 +63,9 @@
 void CacheManager::destroy() {
     // cleanup any caches here as the GrContext is about to go away...
     mGrContext.reset(nullptr);
-    mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(mMaxSurfaceArea/2,
-             skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);
+    mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(
+            mMaxSurfaceArea / 2,
+            skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);
 }
 
 void CacheManager::updateContextCacheSizes() {
@@ -137,7 +138,7 @@
 
     switch (mode) {
         case TrimMemoryMode::Complete:
-            mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(mMaxSurfaceArea/2);
+            mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(mMaxSurfaceArea / 2);
             mGrContext->freeGpuResources();
             break;
         case TrimMemoryMode::UiHidden:
@@ -175,8 +176,8 @@
 
     log.appendFormat("Caches:\n");
     log.appendFormat("                         Current / Maximum\n");
-    log.appendFormat("  VectorDrawableAtlas  %6.2f kB / %6.2f kB (entries = %zu)\n",
-            0.0f, 0.0f, (size_t)0);
+    log.appendFormat("  VectorDrawableAtlas  %6.2f kB / %6.2f kB (entries = %zu)\n", 0.0f, 0.0f,
+                     (size_t)0);
 
     if (renderState) {
         if (renderState->mActiveLayers.size() > 0) {
@@ -185,24 +186,21 @@
 
         size_t layerMemoryTotal = 0;
         for (std::set<Layer*>::iterator it = renderState->mActiveLayers.begin();
-                it != renderState->mActiveLayers.end(); it++) {
+             it != renderState->mActiveLayers.end(); it++) {
             const Layer* layer = *it;
             const char* layerType = layer->getApi() == Layer::Api::OpenGL ? "GlLayer" : "VkLayer";
-            log.appendFormat("    %s size %dx%d\n", layerType,
-                    layer->getWidth(), layer->getHeight());
+            log.appendFormat("    %s size %dx%d\n", layerType, layer->getWidth(),
+                             layer->getHeight());
             layerMemoryTotal += layer->getWidth() * layer->getHeight() * 4;
         }
         log.appendFormat("  Layers Total         %6.2f kB (numLayers = %zu)\n",
                          layerMemoryTotal / 1024.0f, renderState->mActiveLayers.size());
     }
 
-
     log.appendFormat("Total memory usage:\n");
-    log.appendFormat("  %zu bytes, %.2f MB (%.2f MB is purgeable)\n",
-                     bytesCached, bytesCached / 1024.0f / 1024.0f,
+    log.appendFormat("  %zu bytes, %.2f MB (%.2f MB is purgeable)\n", bytesCached,
+                     bytesCached / 1024.0f / 1024.0f,
                      mGrContext->getResourceCachePurgeableBytes() / 1024.0f / 1024.0f);
-
-
 }
 
 } /* namespace renderthread */
diff --git a/libs/hwui/renderthread/CacheManager.h b/libs/hwui/renderthread/CacheManager.h
index 3ba2690..d037045 100644
--- a/libs/hwui/renderthread/CacheManager.h
+++ b/libs/hwui/renderthread/CacheManager.h
@@ -42,10 +42,7 @@
 
 class CacheManager {
 public:
-    enum class TrimMemoryMode {
-        Complete,
-        UiHidden
-    };
+    enum class TrimMemoryMode { Complete, UiHidden };
 
     void configureContext(GrContextOptions* context);
     void trimMemory(TrimMemoryMode mode);
@@ -58,12 +55,12 @@
     size_t getBackgroundCacheSize() const { return mBackgroundResourceBytes; }
 
     TaskManager* getTaskManager() { return &mTaskManager; }
+
 private:
     friend class RenderThread;
 
     CacheManager(const DisplayInfo& display);
 
-
     void reset(GrContext* grContext);
     void destroy();
     void updateContextCacheSizes();
@@ -92,4 +89,3 @@
 } /* namespace android */
 
 #endif /* CACHEMANAGER_H */
-
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index 36a0da1..b7bb2d15 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -14,24 +14,24 @@
  * limitations under the License.
  */
 
-#include <GpuMemoryTracker.h>
 #include "CanvasContext.h"
+#include <GpuMemoryTracker.h>
 
 #include "AnimationContext.h"
 #include "Caches.h"
 #include "EglManager.h"
 #include "Frame.h"
 #include "LayerUpdateQueue.h"
+#include "OpenGLPipeline.h"
 #include "Properties.h"
 #include "RenderThread.h"
 #include "hwui/Canvas.h"
-#include "renderstate/RenderState.h"
-#include "renderstate/Stencil.h"
-#include "protos/hwui.pb.h"
-#include "OpenGLPipeline.h"
 #include "pipeline/skia/SkiaOpenGLPipeline.h"
 #include "pipeline/skia/SkiaPipeline.h"
 #include "pipeline/skia/SkiaVulkanPipeline.h"
+#include "protos/hwui.pb.h"
+#include "renderstate/RenderState.h"
+#include "renderstate/Stencil.h"
 #include "utils/GLUtils.h"
 #include "utils/TimeUtils.h"
 
@@ -40,9 +40,9 @@
 #include <private/hwui/DrawGlInfo.h>
 #include <strings.h>
 
-#include <algorithm>
 #include <fcntl.h>
 #include <sys/stat.h>
+#include <algorithm>
 
 #include <cstdlib>
 
@@ -63,23 +63,22 @@
 namespace uirenderer {
 namespace renderthread {
 
-CanvasContext* CanvasContext::create(RenderThread& thread,
-        bool translucent, RenderNode* rootRenderNode, IContextFactory* contextFactory) {
-
+CanvasContext* CanvasContext::create(RenderThread& thread, bool translucent,
+                                     RenderNode* rootRenderNode, IContextFactory* contextFactory) {
     auto renderType = Properties::getRenderPipelineType();
 
     switch (renderType) {
         case RenderPipelineType::OpenGL:
             return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
-                    std::make_unique<OpenGLPipeline>(thread));
+                                     std::make_unique<OpenGLPipeline>(thread));
         case RenderPipelineType::SkiaGL:
             return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
-                    std::make_unique<skiapipeline::SkiaOpenGLPipeline>(thread));
+                                     std::make_unique<skiapipeline::SkiaOpenGLPipeline>(thread));
         case RenderPipelineType::SkiaVulkan:
             return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
-                                std::make_unique<skiapipeline::SkiaVulkanPipeline>(thread));
+                                     std::make_unique<skiapipeline::SkiaVulkanPipeline>(thread));
         default:
-            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
             break;
     }
     return nullptr;
@@ -96,7 +95,7 @@
             skiapipeline::SkiaPipeline::destroyLayer(node);
             break;
         default:
-            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
             break;
     }
 }
@@ -115,7 +114,7 @@
             skiapipeline::SkiaVulkanPipeline::invokeFunctor(thread, functor);
             break;
         default:
-            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
             break;
     }
 }
@@ -131,14 +130,14 @@
             skiapipeline::SkiaPipeline::prepareToDraw(thread, bitmap);
             break;
         default:
-            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
             break;
     }
 }
 
-CanvasContext::CanvasContext(RenderThread& thread, bool translucent,
-        RenderNode* rootRenderNode, IContextFactory* contextFactory,
-        std::unique_ptr<IRenderPipeline> renderPipeline)
+CanvasContext::CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
+                             IContextFactory* contextFactory,
+                             std::unique_ptr<IRenderPipeline> renderPipeline)
         : mRenderThread(thread)
         , mOpaque(!translucent)
         , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))
@@ -170,7 +169,7 @@
 void CanvasContext::removeRenderNode(RenderNode* node) {
     node->clearRoot();
     mRenderNodes.erase(std::remove(mRenderNodes.begin(), mRenderNodes.end(), node),
-            mRenderNodes.end());
+                       mRenderNodes.end());
 }
 
 void CanvasContext::destroy() {
@@ -192,10 +191,10 @@
     mFrameNumber = -1;
 
     if (hasSurface) {
-         mHaveNewSurface = true;
-         mSwapHistory.clear();
+        mHaveNewSurface = true;
+        mSwapHistory.clear();
     } else {
-         mRenderThread.removeFrameCallback(this);
+        mRenderThread.removeFrameCallback(this);
     }
 }
 
@@ -219,8 +218,7 @@
     }
 }
 
-void CanvasContext::setup(float lightRadius,
-        uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
+void CanvasContext::setup(float lightRadius, uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
     mLightGeometry.radius = lightRadius;
     mLightInfo.ambientShadowAlpha = ambientShadowAlpha;
     mLightInfo.spotShadowAlpha = spotShadowAlpha;
@@ -254,7 +252,7 @@
             return true;
         default:
             LOG_ALWAYS_FATAL("unexpected result %d from IRenderPipeline::makeCurrent",
-                    (int32_t) result);
+                             (int32_t)result);
     }
 
     return true;
@@ -277,8 +275,7 @@
 
     // Was there a happy queue & dequeue time? If so, don't
     // consider it stuffed
-    if (swapA.dequeueDuration < SLOW_THRESHOLD
-            && swapA.queueDuration < SLOW_THRESHOLD) {
+    if (swapA.dequeueDuration < SLOW_THRESHOLD && swapA.queueDuration < SLOW_THRESHOLD) {
         return false;
     }
 
@@ -293,8 +290,7 @@
 
         // Was there a happy queue & dequeue time? If so, don't
         // consider it stuffed
-        if (swapB.dequeueDuration < SLOW_THRESHOLD
-                && swapB.queueDuration < SLOW_THRESHOLD) {
+        if (swapB.dequeueDuration < SLOW_THRESHOLD && swapB.queueDuration < SLOW_THRESHOLD) {
             return false;
         }
 
@@ -306,8 +302,8 @@
     return true;
 }
 
-void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo,
-        int64_t syncQueued, RenderNode* target) {
+void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued,
+                                RenderNode* target) {
     mRenderThread.removeFrameCallback(this);
 
     // If the previous frame was dropped we don't need to hold onto it, so
@@ -358,8 +354,8 @@
             // Already drew for this vsync pulse, UI draw request missed
             // the deadline for RT animations
             info.out.canDrawThisFrame = false;
-        } else if (vsyncDelta >= mRenderThread.timeLord().frameIntervalNanos() * 3
-                || (latestVsync - mLastDropVsync) < 500_ms) {
+        } else if (vsyncDelta >= mRenderThread.timeLord().frameIntervalNanos() * 3 ||
+                   (latestVsync - mLastDropVsync) < 500_ms) {
             // It's been several frame intervals, assume the buffer queue is fine
             // or the last drop was too recent
             info.out.canDrawThisFrame = true;
@@ -402,10 +398,10 @@
     mDamageAccumulator.finish(&dirty);
 
     // TODO: Re-enable after figuring out cause of b/22592975
-//    if (dirty.isEmpty() && Properties::skipEmptyFrames) {
-//        mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
-//        return;
-//    }
+    //    if (dirty.isEmpty() && Properties::skipEmptyFrames) {
+    //        mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
+    //        return;
+    //    }
 
     mCurrentFrameInfo->markIssueDrawCommandsStart();
 
@@ -414,18 +410,19 @@
     SkRect windowDirty = computeDirtyRect(frame, &dirty);
 
     bool drew = mRenderPipeline->draw(frame, windowDirty, dirty, mLightGeometry, &mLayerUpdateQueue,
-            mContentDrawBounds, mOpaque, mWideColorGamut, mLightInfo, mRenderNodes, &(profiler()));
+                                      mContentDrawBounds, mOpaque, mWideColorGamut, mLightInfo,
+                                      mRenderNodes, &(profiler()));
 
     waitOnFences();
 
     bool requireSwap = false;
-    bool didSwap = mRenderPipeline->swapBuffers(frame, drew, windowDirty, mCurrentFrameInfo,
-            &requireSwap);
+    bool didSwap =
+            mRenderPipeline->swapBuffers(frame, drew, windowDirty, mCurrentFrameInfo, &requireSwap);
 
     mIsDirty = false;
 
     if (requireSwap) {
-        if (!didSwap) { //some error happened
+        if (!didSwap) {  // some error happened
             setSurface(nullptr);
         }
         SwapHistory& swap = mSwapHistory.next();
@@ -449,10 +446,8 @@
             swap.dequeueDuration = 0;
             swap.queueDuration = 0;
         }
-        mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration)
-                = swap.dequeueDuration;
-        mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration)
-                = swap.queueDuration;
+        mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration) = swap.dequeueDuration;
+        mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration) = swap.queueDuration;
         mHaveNewSurface = false;
         mFrameNumber = -1;
     } else {
@@ -464,9 +459,9 @@
     mCurrentFrameInfo->markFrameCompleted();
 
 #if LOG_FRAMETIME_MMA
-    float thisFrame = mCurrentFrameInfo->duration(
-            FrameInfoIndex::IssueDrawCommandsStart,
-            FrameInfoIndex::FrameCompleted) / NANOS_PER_MILLIS_F;
+    float thisFrame = mCurrentFrameInfo->duration(FrameInfoIndex::IssueDrawCommandsStart,
+                                                  FrameInfoIndex::FrameCompleted) /
+                      NANOS_PER_MILLIS_F;
     if (sFrameCount) {
         sBenchMma = ((9 * sBenchMma) + thisFrame) / 10;
     } else {
@@ -491,7 +486,6 @@
         caches.fontRenderer.getFontRenderer().historyTracker().frameCompleted();
     }
 #endif
-
 }
 
 // Called by choreographer to do an RT-driven animation
@@ -505,9 +499,7 @@
 
     nsecs_t vsync = mRenderThread.timeLord().computeFrameTimeNanos();
     int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
-    UiFrameInfoBuilder(frameInfo)
-        .addFlag(FrameInfoFlags::RTAnimation)
-        .setVsync(vsync, vsync);
+    UiFrameInfoBuilder(frameInfo).addFlag(FrameInfoFlags::RTAnimation).setVsync(vsync, vsync);
 
     TreeInfo info(TreeInfo::MODE_RT_ONLY, *this);
     prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node);
@@ -529,7 +521,7 @@
     if (mPrefetchedLayers.size()) {
         for (auto& node : mPrefetchedLayers) {
             ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...",
-                    node->getName());
+                  node->getName());
             node->destroyLayers();
             node->decStrong(nullptr);
         }
@@ -555,8 +547,8 @@
     // purposes when the frame is actually drawn
     node->setPropertyFieldsDirty(RenderNode::GENERIC);
 
-    mRenderPipeline->renderLayers(mLightGeometry, &mLayerUpdateQueue,
-            mOpaque, mWideColorGamut, mLightInfo);
+    mRenderPipeline->renderLayers(mLightGeometry, &mLayerUpdateQueue, mOpaque, mWideColorGamut,
+                                  mLightInfo);
 
     node->incStrong(nullptr);
     mPrefetchedLayers.insert(node);
@@ -607,7 +599,7 @@
             break;
         }
         default:
-            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
             break;
     }
 }
@@ -634,7 +626,7 @@
     using namespace google::protobuf::io;
     char package[128];
     // Check whether tracing is enabled for this process.
-    FILE * file = fopen("/proc/self/cmdline", "r");
+    FILE* file = fopen("/proc/self/cmdline", "r");
     if (file) {
         if (!fgets(package, 128, file)) {
             ALOGE("Error reading cmdline: %s (%d)", strerror(errno), errno);
@@ -643,8 +635,7 @@
         }
         fclose(file);
     } else {
-        ALOGE("Error opening /proc/self/cmdline: %s (%d)", strerror(errno),
-                errno);
+        ALOGE("Error opening /proc/self/cmdline: %s (%d)", strerror(errno), errno);
         return;
     }
     char path[1024];
@@ -675,8 +666,7 @@
 
 class CanvasContext::FuncTaskProcessor : public TaskProcessor<bool> {
 public:
-    explicit FuncTaskProcessor(TaskManager* taskManager)
-            : TaskProcessor<bool>(taskManager) {}
+    explicit FuncTaskProcessor(TaskManager* taskManager) : TaskProcessor<bool>(taskManager) {}
 
     virtual void onProcess(const sp<Task<bool> >& task) override {
         FuncTask* t = static_cast<FuncTask*>(task.get());
@@ -714,8 +704,8 @@
         dirty->setEmpty();
     } else {
         if (!dirty->isEmpty() && !dirty->intersect(0, 0, frame.width(), frame.height())) {
-            ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?",
-                    SK_RECT_ARGS(*dirty), frame.width(), frame.height());
+            ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?", SK_RECT_ARGS(*dirty),
+                  frame.width(), frame.height());
             dirty->setEmpty();
         }
         profiler().unionDirty(dirty);
@@ -735,7 +725,7 @@
     // last frame so there's nothing to union() against
     // Therefore we only care about the > 1 case.
     if (frame.bufferAge() > 1) {
-        if (frame.bufferAge() > (int) mSwapHistory.size()) {
+        if (frame.bufferAge() > (int)mSwapHistory.size()) {
             // We don't have enough history to handle this old of a buffer
             // Just do a full-draw
             dirty->set(0, 0, frame.width(), frame.height());
@@ -744,7 +734,7 @@
             // to the damage history (happens below)
             // So we need to damage
             for (int i = mSwapHistory.size() - 1;
-                    i > ((int) mSwapHistory.size()) - frame.bufferAge(); i--) {
+                 i > ((int)mSwapHistory.size()) - frame.bufferAge(); i--) {
                 dirty->join(mSwapHistory[i].damage);
             }
         }
diff --git a/libs/hwui/renderthread/CanvasContext.h b/libs/hwui/renderthread/CanvasContext.h
index f8a8775..d80a247 100644
--- a/libs/hwui/renderthread/CanvasContext.h
+++ b/libs/hwui/renderthread/CanvasContext.h
@@ -27,17 +27,17 @@
 #include "IRenderPipeline.h"
 #include "LayerUpdateQueue.h"
 #include "RenderNode.h"
-#include "thread/Task.h"
-#include "thread/TaskProcessor.h"
 #include "renderthread/RenderTask.h"
 #include "renderthread/RenderThread.h"
+#include "thread/Task.h"
+#include "thread/TaskProcessor.h"
 
-#include <cutils/compiler.h>
 #include <EGL/egl.h>
 #include <SkBitmap.h>
 #include <SkRect.h>
-#include <utils/Functor.h>
+#include <cutils/compiler.h>
 #include <gui/Surface.h>
+#include <utils/Functor.h>
 
 #include <functional>
 #include <set>
@@ -63,8 +63,8 @@
 // TODO: Rename to Renderer or some other per-window, top-level manager
 class CanvasContext : public IFrameCallback {
 public:
-    static CanvasContext* create(RenderThread& thread, bool translucent,
-            RenderNode* rootRenderNode, IContextFactory* contextFactory);
+    static CanvasContext* create(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
+                                 IContextFactory* contextFactory);
     virtual ~CanvasContext();
 
     /**
@@ -89,9 +89,7 @@
     bool pinImages(std::vector<SkImage*>& mutableImages) {
         return mRenderPipeline->pinImages(mutableImages);
     }
-    bool pinImages(LsaVector<sk_sp<Bitmap>>& images) {
-        return mRenderPipeline->pinImages(images);
-    }
+    bool pinImages(LsaVector<sk_sp<Bitmap>>& images) { return mRenderPipeline->pinImages(images); }
 
     /**
      * Unpin any image that had be previously pinned to the GPU cache
@@ -122,14 +120,12 @@
     void setStopped(bool stopped);
     bool hasSurface() { return mNativeSurface.get(); }
 
-    void setup(float lightRadius,
-            uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
+    void setup(float lightRadius, uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
     void setLightCenter(const Vector3& lightCenter);
     void setOpaque(bool opaque);
     void setWideGamut(bool wideGamut);
     bool makeCurrent();
-    void prepareTree(TreeInfo& info, int64_t* uiFrameInfo,
-            int64_t syncQueued, RenderNode* target);
+    void prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued, RenderNode* target);
     void draw();
     void destroy();
 
@@ -161,13 +157,9 @@
     void addRenderNode(RenderNode* node, bool placeFront);
     void removeRenderNode(RenderNode* node);
 
-    void setContentDrawBounds(const Rect& bounds) {
-        mContentDrawBounds = bounds;
-    }
+    void setContentDrawBounds(const Rect& bounds) { mContentDrawBounds = bounds; }
 
-    RenderState& getRenderState() {
-        return mRenderThread.renderState();
-    }
+    RenderState& getRenderState() { return mRenderThread.renderState(); }
 
     void addFrameMetricsObserver(FrameMetricsObserver* observer) {
         if (mFrameMetricsReporter.get() == nullptr) {
@@ -197,7 +189,7 @@
 
 private:
     CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
-            IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline);
+                  IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline);
 
     friend class RegisterFrameCallbackTask;
     // TODO: Replace with something better for layer & other GL object
@@ -239,14 +231,14 @@
     bool mOpaque;
     bool mWideColorGamut = false;
     BakedOpRenderer::LightInfo mLightInfo;
-    FrameBuilder::LightGeometry mLightGeometry = { {0, 0, 0}, 0 };
+    FrameBuilder::LightGeometry mLightGeometry = {{0, 0, 0}, 0};
 
     bool mHaveNewSurface = false;
     DamageAccumulator mDamageAccumulator;
     LayerUpdateQueue mLayerUpdateQueue;
     std::unique_ptr<AnimationContext> mAnimationContext;
 
-    std::vector< sp<RenderNode> > mRenderNodes;
+    std::vector<sp<RenderNode>> mRenderNodes;
 
     FrameInfo* mCurrentFrameInfo = nullptr;
     std::string mName;
@@ -266,8 +258,8 @@
     };
     class FuncTaskProcessor;
 
-    std::vector< sp<FuncTask> > mFrameFences;
-    sp<TaskProcessor<bool> > mFrameWorkProcessor;
+    std::vector<sp<FuncTask>> mFrameFences;
+    sp<TaskProcessor<bool>> mFrameWorkProcessor;
     std::unique_ptr<IRenderPipeline> mRenderPipeline;
 };
 
diff --git a/libs/hwui/renderthread/DrawFrameTask.cpp b/libs/hwui/renderthread/DrawFrameTask.cpp
index 0a94678..8372331 100644
--- a/libs/hwui/renderthread/DrawFrameTask.cpp
+++ b/libs/hwui/renderthread/DrawFrameTask.cpp
@@ -33,21 +33,20 @@
         : mRenderThread(nullptr)
         , mContext(nullptr)
         , mContentDrawBounds(0, 0, 0, 0)
-        , mSyncResult(SyncResult::OK) {
-}
+        , mSyncResult(SyncResult::OK) {}
 
-DrawFrameTask::~DrawFrameTask() {
-}
+DrawFrameTask::~DrawFrameTask() {}
 
 void DrawFrameTask::setContext(RenderThread* thread, CanvasContext* context,
-        RenderNode* targetNode) {
+                               RenderNode* targetNode) {
     mRenderThread = thread;
     mContext = context;
     mTargetNode = targetNode;
 }
 
 void DrawFrameTask::pushLayerUpdate(DeferredLayerUpdater* layer) {
-    LOG_ALWAYS_FATAL_IF(!mContext, "Lifecycle violation, there's no context to pushLayerUpdate with!");
+    LOG_ALWAYS_FATAL_IF(!mContext,
+                        "Lifecycle violation, there's no context to pushLayerUpdate with!");
 
     for (size_t i = 0; i < mLayers.size(); i++) {
         if (mLayers[i].get() == layer) {
diff --git a/libs/hwui/renderthread/DrawFrameTask.h b/libs/hwui/renderthread/DrawFrameTask.h
index 4e4b6da..ea51ae4 100644
--- a/libs/hwui/renderthread/DrawFrameTask.h
+++ b/libs/hwui/renderthread/DrawFrameTask.h
@@ -24,8 +24,8 @@
 
 #include "RenderTask.h"
 
-#include "../Rect.h"
 #include "../FrameInfo.h"
+#include "../Rect.h"
 #include "../TreeInfo.h"
 
 namespace android {
@@ -90,7 +90,7 @@
     /*********************************************
      *  Single frame data
      *********************************************/
-    std::vector< sp<DeferredLayerUpdater> > mLayers;
+    std::vector<sp<DeferredLayerUpdater> > mLayers;
 
     int mSyncResult;
     int64_t mSyncQueued;
diff --git a/libs/hwui/renderthread/EglManager.cpp b/libs/hwui/renderthread/EglManager.cpp
index 87e5bfd..4df7caf 100644
--- a/libs/hwui/renderthread/EglManager.cpp
+++ b/libs/hwui/renderthread/EglManager.cpp
@@ -18,17 +18,17 @@
 
 #include <string>
 
-#include "utils/StringUtils.h"
 #include <cutils/properties.h>
 #include <log/log.h>
+#include "utils/StringUtils.h"
 
 #include "Caches.h"
 #include "DeviceInfo.h"
 #include "Frame.h"
 #include "Properties.h"
 #include "RenderThread.h"
-#include "renderstate/RenderState.h"
 #include "Texture.h"
+#include "renderstate/RenderState.h"
 
 #include <EGL/eglext.h>
 #include <GrContextOptions.h>
@@ -47,7 +47,9 @@
 namespace uirenderer {
 namespace renderthread {
 
-#define ERROR_CASE(x) case x: return #x;
+#define ERROR_CASE(x) \
+    case x:           \
+        return #x;
 static const char* egl_error_str(EGLint error) {
     switch (error) {
         ERROR_CASE(EGL_SUCCESS)
@@ -65,8 +67,8 @@
         ERROR_CASE(EGL_BAD_PARAMETER)
         ERROR_CASE(EGL_BAD_SURFACE)
         ERROR_CASE(EGL_CONTEXT_LOST)
-    default:
-        return "Unknown error";
+        default:
+            return "Unknown error";
     }
 }
 const char* EglManager::eglErrorString() {
@@ -89,8 +91,7 @@
         , mEglConfigWideGamut(nullptr)
         , mEglContext(EGL_NO_CONTEXT)
         , mPBufferSurface(EGL_NO_SURFACE)
-        , mCurrentSurface(EGL_NO_SURFACE) {
-}
+        , mCurrentSurface(EGL_NO_SURFACE) {}
 
 void EglManager::initialize() {
     if (hasEglContext()) return;
@@ -98,12 +99,12 @@
     ATRACE_NAME("Creating EGLContext");
 
     mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY,
-            "Failed to get EGL_DEFAULT_DISPLAY! err=%s", eglErrorString());
+    LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY, "Failed to get EGL_DEFAULT_DISPLAY! err=%s",
+                        eglErrorString());
 
     EGLint major, minor;
     LOG_ALWAYS_FATAL_IF(eglInitialize(mEglDisplay, &major, &minor) == EGL_FALSE,
-            "Failed to initialize display %p! err=%s", mEglDisplay, eglErrorString());
+                        "Failed to initialize display %p! err=%s", mEglDisplay, eglErrorString());
 
     ALOGI("Initialized EGL, version %d.%d", (int)major, (int)minor);
 
@@ -141,23 +142,22 @@
         options.fDisableDistanceFieldPaths = true;
         mRenderThread.cacheManager().configureContext(&options);
         mRenderThread.setGrContext(GrContext::Create(GrBackend::kOpenGL_GrBackend,
-                (GrBackendContext)glInterface.get(), options));
+                                                     (GrBackendContext)glInterface.get(), options));
     }
 }
 
 void EglManager::initExtensions() {
-    auto extensions = StringUtils::split(
-            eglQueryString(mEglDisplay, EGL_EXTENSIONS));
+    auto extensions = StringUtils::split(eglQueryString(mEglDisplay, EGL_EXTENSIONS));
 
     // For our purposes we don't care if EGL_BUFFER_AGE is a result of
     // EGL_EXT_buffer_age or EGL_KHR_partial_update as our usage is covered
     // under EGL_KHR_partial_update and we don't need the expanded scope
     // that EGL_EXT_buffer_age provides.
-    EglExtensions.bufferAge = extensions.has("EGL_EXT_buffer_age")
-            || extensions.has("EGL_KHR_partial_update");
+    EglExtensions.bufferAge =
+            extensions.has("EGL_EXT_buffer_age") || extensions.has("EGL_KHR_partial_update");
     EglExtensions.setDamage = extensions.has("EGL_KHR_partial_update");
     LOG_ALWAYS_FATAL_IF(!extensions.has("EGL_KHR_swap_buffers_with_damage"),
-            "Missing required extension EGL_KHR_swap_buffers_with_damage");
+                        "Missing required extension EGL_KHR_swap_buffers_with_damage");
 
     EglExtensions.glColorSpace = extensions.has("EGL_KHR_gl_colorspace");
     EglExtensions.noConfigContext = extensions.has("EGL_KHR_no_config_context");
@@ -175,30 +175,37 @@
 
 void EglManager::loadConfigs() {
     ALOGD("Swap behavior %d", static_cast<int>(mSwapBehavior));
-    EGLint swapBehavior = (mSwapBehavior == SwapBehavior::Preserved)
-            ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0;
-    EGLint attribs[] = {
-            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-            EGL_RED_SIZE, 8,
-            EGL_GREEN_SIZE, 8,
-            EGL_BLUE_SIZE, 8,
-            EGL_ALPHA_SIZE, 8,
-            EGL_DEPTH_SIZE, 0,
-            EGL_CONFIG_CAVEAT, EGL_NONE,
-            EGL_STENCIL_SIZE, Stencil::getStencilSize(),
-            EGL_SURFACE_TYPE, EGL_WINDOW_BIT | swapBehavior,
-            EGL_NONE
-    };
+    EGLint swapBehavior =
+            (mSwapBehavior == SwapBehavior::Preserved) ? EGL_SWAP_BEHAVIOR_PRESERVED_BIT : 0;
+    EGLint attribs[] = {EGL_RENDERABLE_TYPE,
+                        EGL_OPENGL_ES2_BIT,
+                        EGL_RED_SIZE,
+                        8,
+                        EGL_GREEN_SIZE,
+                        8,
+                        EGL_BLUE_SIZE,
+                        8,
+                        EGL_ALPHA_SIZE,
+                        8,
+                        EGL_DEPTH_SIZE,
+                        0,
+                        EGL_CONFIG_CAVEAT,
+                        EGL_NONE,
+                        EGL_STENCIL_SIZE,
+                        Stencil::getStencilSize(),
+                        EGL_SURFACE_TYPE,
+                        EGL_WINDOW_BIT | swapBehavior,
+                        EGL_NONE};
 
     EGLint numConfigs = 1;
-    if (!eglChooseConfig(mEglDisplay, attribs, &mEglConfig, numConfigs, &numConfigs)
-            || numConfigs != 1) {
+    if (!eglChooseConfig(mEglDisplay, attribs, &mEglConfig, numConfigs, &numConfigs) ||
+        numConfigs != 1) {
         if (mSwapBehavior == SwapBehavior::Preserved) {
             // Try again without dirty regions enabled
             ALOGW("Failed to choose config with EGL_SWAP_BEHAVIOR_PRESERVED, retrying without...");
             mSwapBehavior = SwapBehavior::Discard;
             loadConfigs();
-            return; // the call to loadConfigs() we just made picks the wide gamut config
+            return;  // the call to loadConfigs() we just made picks the wide gamut config
         } else {
             // Failed to get a valid config
             LOG_ALWAYS_FATAL("Failed to choose config, error = %s", eglErrorString());
@@ -207,22 +214,30 @@
 
     if (EglExtensions.pixelFormatFloat) {
         // If we reached this point, we have a valid swap behavior
-        EGLint attribs16F[] = {
-                EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-                EGL_COLOR_COMPONENT_TYPE_EXT, EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
-                EGL_RED_SIZE, 16,
-                EGL_GREEN_SIZE, 16,
-                EGL_BLUE_SIZE, 16,
-                EGL_ALPHA_SIZE, 16,
-                EGL_DEPTH_SIZE, 0,
-                EGL_STENCIL_SIZE, Stencil::getStencilSize(),
-                EGL_SURFACE_TYPE, EGL_WINDOW_BIT | swapBehavior,
-                EGL_NONE
-        };
+        EGLint attribs16F[] = {EGL_RENDERABLE_TYPE,
+                               EGL_OPENGL_ES2_BIT,
+                               EGL_COLOR_COMPONENT_TYPE_EXT,
+                               EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT,
+                               EGL_RED_SIZE,
+                               16,
+                               EGL_GREEN_SIZE,
+                               16,
+                               EGL_BLUE_SIZE,
+                               16,
+                               EGL_ALPHA_SIZE,
+                               16,
+                               EGL_DEPTH_SIZE,
+                               0,
+                               EGL_STENCIL_SIZE,
+                               Stencil::getStencilSize(),
+                               EGL_SURFACE_TYPE,
+                               EGL_WINDOW_BIT | swapBehavior,
+                               EGL_NONE};
 
         numConfigs = 1;
-        if (!eglChooseConfig(mEglDisplay, attribs16F, &mEglConfigWideGamut, numConfigs, &numConfigs)
-                || numConfigs != 1) {
+        if (!eglChooseConfig(mEglDisplay, attribs16F, &mEglConfigWideGamut, numConfigs,
+                             &numConfigs) ||
+            numConfigs != 1) {
             LOG_ALWAYS_FATAL(
                     "Device claims wide gamut support, cannot find matching config, error = %s",
                     eglErrorString());
@@ -231,23 +246,20 @@
 }
 
 void EglManager::createContext() {
-    EGLint attribs[] = {
-            EGL_CONTEXT_CLIENT_VERSION, GLES_VERSION,
-            EGL_NONE
-    };
-    mEglContext = eglCreateContext(mEglDisplay,
-            EglExtensions.noConfigContext ? ((EGLConfig) nullptr) : mEglConfig,
+    EGLint attribs[] = {EGL_CONTEXT_CLIENT_VERSION, GLES_VERSION, EGL_NONE};
+    mEglContext = eglCreateContext(
+            mEglDisplay, EglExtensions.noConfigContext ? ((EGLConfig) nullptr) : mEglConfig,
             EGL_NO_CONTEXT, attribs);
-    LOG_ALWAYS_FATAL_IF(mEglContext == EGL_NO_CONTEXT,
-        "Failed to create context, error = %s", eglErrorString());
+    LOG_ALWAYS_FATAL_IF(mEglContext == EGL_NO_CONTEXT, "Failed to create context, error = %s",
+                        eglErrorString());
 }
 
 void EglManager::createPBufferSurface() {
     LOG_ALWAYS_FATAL_IF(mEglDisplay == EGL_NO_DISPLAY,
-            "usePBufferSurface() called on uninitialized GlobalContext!");
+                        "usePBufferSurface() called on uninitialized GlobalContext!");
 
     if (mPBufferSurface == EGL_NO_SURFACE) {
-        EGLint attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
+        EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
         mPBufferSurface = eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs);
     }
 }
@@ -255,8 +267,8 @@
 EGLSurface EglManager::createSurface(EGLNativeWindowType window, bool wideColorGamut) {
     initialize();
 
-    wideColorGamut = wideColorGamut && EglExtensions.glColorSpace && EglExtensions.scRGB
-            && EglExtensions.pixelFormatFloat && EglExtensions.noConfigContext;
+    wideColorGamut = wideColorGamut && EglExtensions.glColorSpace && EglExtensions.scRGB &&
+                     EglExtensions.pixelFormatFloat && EglExtensions.noConfigContext;
 
     // The color space we want to use depends on whether linear blending is turned
     // on and whether the app has requested wide color gamut rendering. When wide
@@ -280,10 +292,7 @@
     // We insert to placeholders to set EGL_GL_COLORSPACE_KHR and its value.
     // According to section 3.4.1 of the EGL specification, the attributes
     // list is considered empty if the first entry is EGL_NONE
-    EGLint attribs[] = {
-            EGL_NONE, EGL_NONE,
-            EGL_NONE
-    };
+    EGLint attribs[] = {EGL_NONE, EGL_NONE, EGL_NONE};
 
     if (EglExtensions.glColorSpace) {
         attribs[0] = EGL_GL_COLORSPACE_KHR;
@@ -302,16 +311,17 @@
 #endif
     }
 
-    EGLSurface surface = eglCreateWindowSurface(mEglDisplay,
-            wideColorGamut ? mEglConfigWideGamut : mEglConfig, window, attribs);
+    EGLSurface surface = eglCreateWindowSurface(
+            mEglDisplay, wideColorGamut ? mEglConfigWideGamut : mEglConfig, window, attribs);
     LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE,
-            "Failed to create EGLSurface for window %p, eglErr = %s",
-            (void*) window, eglErrorString());
+                        "Failed to create EGLSurface for window %p, eglErr = %s", (void*)window,
+                        eglErrorString());
 
     if (mSwapBehavior != SwapBehavior::Preserved) {
-        LOG_ALWAYS_FATAL_IF(eglSurfaceAttrib(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED) == EGL_FALSE,
+        LOG_ALWAYS_FATAL_IF(eglSurfaceAttrib(mEglDisplay, surface, EGL_SWAP_BEHAVIOR,
+                                             EGL_BUFFER_DESTROYED) == EGL_FALSE,
                             "Failed to set swap behavior to destroyed for window %p, eglErr = %s",
-                            (void*) window, eglErrorString());
+                            (void*)window, eglErrorString());
     }
 
     return surface;
@@ -353,11 +363,11 @@
     if (!eglMakeCurrent(mEglDisplay, surface, surface, mEglContext)) {
         if (errOut) {
             *errOut = eglGetError();
-            ALOGW("Failed to make current on surface %p, error=%s",
-                    (void*)surface, egl_error_str(*errOut));
+            ALOGW("Failed to make current on surface %p, error=%s", (void*)surface,
+                  egl_error_str(*errOut));
         } else {
-            LOG_ALWAYS_FATAL("Failed to make current on surface %p, error=%s",
-                    (void*)surface, eglErrorString());
+            LOG_ALWAYS_FATAL("Failed to make current on surface %p, error=%s", (void*)surface,
+                             eglErrorString());
         }
     }
     mCurrentSurface = surface;
@@ -369,21 +379,20 @@
 
 EGLint EglManager::queryBufferAge(EGLSurface surface) {
     switch (mSwapBehavior) {
-    case SwapBehavior::Discard:
-        return 0;
-    case SwapBehavior::Preserved:
-        return 1;
-    case SwapBehavior::BufferAge:
-        EGLint bufferAge;
-        eglQuerySurface(mEglDisplay, surface, EGL_BUFFER_AGE_EXT, &bufferAge);
-        return bufferAge;
+        case SwapBehavior::Discard:
+            return 0;
+        case SwapBehavior::Preserved:
+            return 1;
+        case SwapBehavior::BufferAge:
+            EGLint bufferAge;
+            eglQuerySurface(mEglDisplay, surface, EGL_BUFFER_AGE_EXT, &bufferAge);
+            return bufferAge;
     }
     return 0;
 }
 
 Frame EglManager::beginFrame(EGLSurface surface) {
-    LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE,
-            "Tried to beginFrame on EGL_NO_SURFACE!");
+    LOG_ALWAYS_FATAL_IF(surface == EGL_NO_SURFACE, "Tried to beginFrame on EGL_NO_SURFACE!");
     makeCurrent(surface);
     Frame frame;
     frame.mSurface = surface;
@@ -401,7 +410,7 @@
         frame.map(dirty, rects);
         if (!eglSetDamageRegionKHR(mEglDisplay, frame.mSurface, rects, 1)) {
             LOG_ALWAYS_FATAL("Failed to set damage region on surface %p, error=%s",
-                    (void*)frame.mSurface, eglErrorString());
+                             (void*)frame.mSurface, eglErrorString());
         }
     }
 #endif
@@ -412,7 +421,6 @@
 }
 
 bool EglManager::swapBuffers(const Frame& frame, const SkRect& screenDirty) {
-
     if (CC_UNLIKELY(Properties::waitForGpuCompletion)) {
         ATRACE_NAME("Finishing GPU work");
         fence();
@@ -420,8 +428,7 @@
 
     EGLint rects[4];
     frame.map(screenDirty, rects);
-    eglSwapBuffersWithDamageKHR(mEglDisplay, frame.mSurface, rects,
-            screenDirty.isEmpty() ? 0 : 1);
+    eglSwapBuffersWithDamageKHR(mEglDisplay, frame.mSurface, rects, screenDirty.isEmpty() ? 0 : 1);
 
     EGLint err = eglGetError();
     if (CC_LIKELY(err == EGL_SUCCESS)) {
@@ -431,20 +438,18 @@
         // For some reason our surface was destroyed out from under us
         // This really shouldn't happen, but if it does we can recover easily
         // by just not trying to use the surface anymore
-        ALOGW("swapBuffers encountered EGL error %d on %p, halting rendering...",
-                err, frame.mSurface);
+        ALOGW("swapBuffers encountered EGL error %d on %p, halting rendering...", err,
+              frame.mSurface);
         return false;
     }
-    LOG_ALWAYS_FATAL("Encountered EGL error %d %s during rendering",
-            err, egl_error_str(err));
+    LOG_ALWAYS_FATAL("Encountered EGL error %d %s during rendering", err, egl_error_str(err));
     // Impossible to hit this, but the compiler doesn't know that
     return false;
 }
 
 void EglManager::fence() {
     EGLSyncKHR fence = eglCreateSyncKHR(mEglDisplay, EGL_SYNC_FENCE_KHR, NULL);
-    eglClientWaitSyncKHR(mEglDisplay, fence,
-            EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
+    eglClientWaitSyncKHR(mEglDisplay, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
     eglDestroySyncKHR(mEglDisplay, fence);
 }
 
@@ -452,17 +457,17 @@
     if (mSwapBehavior != SwapBehavior::Preserved) return false;
 
     bool preserved = eglSurfaceAttrib(mEglDisplay, surface, EGL_SWAP_BEHAVIOR,
-            preserve ? EGL_BUFFER_PRESERVED : EGL_BUFFER_DESTROYED);
+                                      preserve ? EGL_BUFFER_PRESERVED : EGL_BUFFER_DESTROYED);
     if (!preserved) {
-        ALOGW("Failed to set EGL_SWAP_BEHAVIOR on surface %p, error=%s",
-                (void*) surface, eglErrorString());
+        ALOGW("Failed to set EGL_SWAP_BEHAVIOR on surface %p, error=%s", (void*)surface,
+              eglErrorString());
         // Maybe it's already set?
         EGLint swapBehavior;
         if (eglQuerySurface(mEglDisplay, surface, EGL_SWAP_BEHAVIOR, &swapBehavior)) {
             preserved = (swapBehavior == EGL_BUFFER_PRESERVED);
         } else {
-            ALOGW("Failed to query EGL_SWAP_BEHAVIOR on surface %p, error=%p",
-                                (void*) surface, eglErrorString());
+            ALOGW("Failed to query EGL_SWAP_BEHAVIOR on surface %p, error=%p", (void*)surface,
+                  eglErrorString());
         }
     }
 
diff --git a/libs/hwui/renderthread/EglManager.h b/libs/hwui/renderthread/EglManager.h
index 2982c23..ef9effb 100644
--- a/libs/hwui/renderthread/EglManager.h
+++ b/libs/hwui/renderthread/EglManager.h
@@ -16,9 +16,9 @@
 #ifndef EGLMANAGER_H
 #define EGLMANAGER_H
 
-#include <cutils/compiler.h>
 #include <EGL/egl.h>
 #include <SkRect.h>
+#include <cutils/compiler.h>
 #include <ui/GraphicBuffer.h>
 #include <utils/StrongPointer.h>
 
diff --git a/libs/hwui/renderthread/Frame.h b/libs/hwui/renderthread/Frame.h
index 99996fe..d266faa 100644
--- a/libs/hwui/renderthread/Frame.h
+++ b/libs/hwui/renderthread/Frame.h
@@ -19,7 +19,7 @@
 #include <stdint.h>
 
 struct SkRect;
-typedef void *EGLSurface;
+typedef void* EGLSurface;
 
 namespace android {
 namespace uirenderer {
@@ -28,9 +28,7 @@
 class Frame {
 public:
     Frame(int32_t width, int32_t height, int32_t bufferAge)
-            : mWidth(width)
-            , mHeight(height)
-            , mBufferAge(bufferAge) { }
+            : mWidth(width), mHeight(height), mBufferAge(bufferAge) {}
 
     int32_t width() const { return mWidth; }
     int32_t height() const { return mHeight; }
@@ -57,4 +55,3 @@
 } /* namespace renderthread */
 } /* namespace uirenderer */
 } /* namespace android */
-
diff --git a/libs/hwui/renderthread/IRenderPipeline.h b/libs/hwui/renderthread/IRenderPipeline.h
index cfc71cb..246ab26 100644
--- a/libs/hwui/renderthread/IRenderPipeline.h
+++ b/libs/hwui/renderthread/IRenderPipeline.h
@@ -34,11 +34,7 @@
 
 namespace renderthread {
 
-enum class MakeCurrentResult {
-    AlreadyCurrent,
-    Failed,
-    Succeeded
-};
+enum class MakeCurrentResult { AlreadyCurrent, Failed, Succeeded };
 
 enum class ColorMode {
     Srgb,
@@ -53,14 +49,13 @@
     virtual MakeCurrentResult makeCurrent() = 0;
     virtual Frame getFrame() = 0;
     virtual bool draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
-            const FrameBuilder::LightGeometry& lightGeometry,
-            LayerUpdateQueue* layerUpdateQueue,
-            const Rect& contentDrawBounds, bool opaque, bool wideColorGamut,
-            const BakedOpRenderer::LightInfo& lightInfo,
-            const std::vector< sp<RenderNode> >& renderNodes,
-            FrameInfoVisualizer* profiler) = 0;
+                      const FrameBuilder::LightGeometry& lightGeometry,
+                      LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
+                      bool opaque, bool wideColorGamut, const BakedOpRenderer::LightInfo& lightInfo,
+                      const std::vector<sp<RenderNode>>& renderNodes,
+                      FrameInfoVisualizer* profiler) = 0;
     virtual bool swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
-            FrameInfo* currentFrameInfo, bool* requireSwap) = 0;
+                             FrameInfo* currentFrameInfo, bool* requireSwap) = 0;
     virtual bool copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) = 0;
     virtual DeferredLayerUpdater* createTextureLayer() = 0;
     virtual bool setSurface(Surface* window, SwapBehavior swapBehavior, ColorMode colorMode) = 0;
@@ -69,11 +64,11 @@
     virtual bool isContextReady() = 0;
     virtual void onDestroyHardwareResources() = 0;
     virtual void renderLayers(const FrameBuilder::LightGeometry& lightGeometry,
-            LayerUpdateQueue* layerUpdateQueue, bool opaque, bool wideColorGamut,
-            const BakedOpRenderer::LightInfo& lightInfo) = 0;
+                              LayerUpdateQueue* layerUpdateQueue, bool opaque, bool wideColorGamut,
+                              const BakedOpRenderer::LightInfo& lightInfo) = 0;
     virtual TaskManager* getTaskManager() = 0;
-    virtual bool createOrUpdateLayer(RenderNode* node,
-            const DamageAccumulator& damageAccumulator, bool wideColorGamut) = 0;
+    virtual bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& damageAccumulator,
+                                     bool wideColorGamut) = 0;
     virtual bool pinImages(std::vector<SkImage*>& mutableImages) = 0;
     virtual bool pinImages(LsaVector<sk_sp<Bitmap>>& images) = 0;
     virtual void unpinImages() = 0;
diff --git a/libs/hwui/renderthread/OpenGLPipeline.cpp b/libs/hwui/renderthread/OpenGLPipeline.cpp
index 7283eb1..f3103fd 100644
--- a/libs/hwui/renderthread/OpenGLPipeline.cpp
+++ b/libs/hwui/renderthread/OpenGLPipeline.cpp
@@ -20,9 +20,9 @@
 #include "EglManager.h"
 #include "Frame.h"
 #include "GlLayer.h"
+#include "OpenGLReadback.h"
 #include "ProfileRenderer.h"
 #include "renderstate/RenderState.h"
-#include "OpenGLReadback.h"
 
 #include <cutils/properties.h>
 #include <strings.h>
@@ -32,9 +32,7 @@
 namespace renderthread {
 
 OpenGLPipeline::OpenGLPipeline(RenderThread& thread)
-        :  mEglManager(thread.eglManager())
-        , mRenderThread(thread) {
-}
+        : mEglManager(thread.eglManager()), mRenderThread(thread) {}
 
 MakeCurrentResult OpenGLPipeline::makeCurrent() {
     // TODO: Figure out why this workaround is needed, see b/13913604
@@ -51,23 +49,21 @@
 
 Frame OpenGLPipeline::getFrame() {
     LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE,
-                "drawRenderNode called on a context with no surface!");
+                        "drawRenderNode called on a context with no surface!");
     return mEglManager.beginFrame(mEglSurface);
 }
 
 bool OpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
-        const FrameBuilder::LightGeometry& lightGeometry,
-        LayerUpdateQueue* layerUpdateQueue,
-        const Rect& contentDrawBounds, bool opaque, bool wideColorGamut,
-        const BakedOpRenderer::LightInfo& lightInfo,
-        const std::vector< sp<RenderNode> >& renderNodes,
-        FrameInfoVisualizer* profiler) {
-
+                          const FrameBuilder::LightGeometry& lightGeometry,
+                          LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
+                          bool opaque, bool wideColorGamut,
+                          const BakedOpRenderer::LightInfo& lightInfo,
+                          const std::vector<sp<RenderNode>>& renderNodes,
+                          FrameInfoVisualizer* profiler) {
     mEglManager.damageFrame(frame, dirty);
 
     bool drew = false;
 
-
     auto& caches = Caches::getInstance();
     FrameBuilder frameBuilder(dirty, frame.width(), frame.height(), lightGeometry, caches);
 
@@ -76,8 +72,8 @@
 
     frameBuilder.deferRenderNodeScene(renderNodes, contentDrawBounds);
 
-    BakedOpRenderer renderer(caches, mRenderThread.renderState(),
-            opaque, wideColorGamut, lightInfo);
+    BakedOpRenderer renderer(caches, mRenderThread.renderState(), opaque, wideColorGamut,
+                             lightInfo);
     frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
     ProfileRenderer profileRenderer(renderer);
     profiler->draw(profileRenderer);
@@ -100,8 +96,7 @@
 }
 
 bool OpenGLPipeline::swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
-        FrameInfo* currentFrameInfo, bool* requireSwap) {
-
+                                 FrameInfo* currentFrameInfo, bool* requireSwap) {
     GL_CHECKPOINT(LOW);
 
     // Even if we decided to cancel the frame, from the perspective of jank
@@ -123,13 +118,13 @@
     layer->updateTexImage();
     layer->apply();
     return OpenGLReadbackImpl::copyLayerInto(mRenderThread,
-            static_cast<GlLayer&>(*layer->backingLayer()), bitmap);
+                                             static_cast<GlLayer&>(*layer->backingLayer()), bitmap);
 }
 
 static Layer* createLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
-        SkColorFilter* colorFilter, int alpha, SkBlendMode mode, bool blend) {
-    GlLayer* layer = new GlLayer(renderState, layerWidth, layerHeight, colorFilter, alpha,
-            mode, blend);
+                          SkColorFilter* colorFilter, int alpha, SkBlendMode mode, bool blend) {
+    GlLayer* layer =
+            new GlLayer(renderState, layerWidth, layerHeight, colorFilter, alpha, mode, blend);
     Caches::getInstance().textureState().activateTexture(0);
     layer->generateTexture();
     return layer;
@@ -147,7 +142,6 @@
 }
 
 bool OpenGLPipeline::setSurface(Surface* surface, SwapBehavior swapBehavior, ColorMode colorMode) {
-
     if (mEglSurface != EGL_NO_SURFACE) {
         mEglManager.destroySurface(mEglSurface);
         mEglSurface = EGL_NO_SURFACE;
@@ -184,14 +178,16 @@
 }
 
 void OpenGLPipeline::renderLayers(const FrameBuilder::LightGeometry& lightGeometry,
-        LayerUpdateQueue* layerUpdateQueue, bool opaque, bool wideColorGamut,
-        const BakedOpRenderer::LightInfo& lightInfo) {
-    static const std::vector< sp<RenderNode> > emptyNodeList;
+                                  LayerUpdateQueue* layerUpdateQueue, bool opaque,
+                                  bool wideColorGamut,
+                                  const BakedOpRenderer::LightInfo& lightInfo) {
+    static const std::vector<sp<RenderNode>> emptyNodeList;
     auto& caches = Caches::getInstance();
     FrameBuilder frameBuilder(*layerUpdateQueue, lightGeometry, caches);
     layerUpdateQueue->clear();
     // TODO: Handle wide color gamut contexts
-    BakedOpRenderer renderer(caches, mRenderThread.renderState(), opaque, wideColorGamut, lightInfo);
+    BakedOpRenderer renderer(caches, mRenderThread.renderState(), opaque, wideColorGamut,
+                             lightInfo);
     LOG_ALWAYS_FATAL_IF(renderer.didDraw(), "shouldn't draw in buildlayer case");
     frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
 }
@@ -205,13 +201,14 @@
 }
 
 bool OpenGLPipeline::createOrUpdateLayer(RenderNode* node,
-        const DamageAccumulator& damageAccumulator, bool wideColorGamut) {
+                                         const DamageAccumulator& damageAccumulator,
+                                         bool wideColorGamut) {
     RenderState& renderState = mRenderThread.renderState();
     OffscreenBufferPool& layerPool = renderState.layerPool();
     bool transformUpdateNeeded = false;
     if (node->getLayer() == nullptr) {
-        node->setLayer(layerPool.get(renderState,
-                node->getWidth(), node->getHeight(), wideColorGamut));
+        node->setLayer(
+                layerPool.get(renderState, node->getWidth(), node->getHeight(), wideColorGamut));
         transformUpdateNeeded = true;
     } else if (!layerMatchesWH(node->getLayer(), node->getWidth(), node->getHeight())) {
         // TODO: remove now irrelevant, currently enqueued damage (respecting damage ordering)
@@ -273,8 +270,7 @@
 
 class AutoEglFence {
 public:
-    AutoEglFence(EGLDisplay display)
-            : mDisplay(display) {
+    AutoEglFence(EGLDisplay display) : mDisplay(display) {
         fence = eglCreateSyncKHR(mDisplay, EGL_SYNC_FENCE_KHR, NULL);
     }
 
@@ -285,17 +281,17 @@
     }
 
     EGLSyncKHR fence = EGL_NO_SYNC_KHR;
+
 private:
     EGLDisplay mDisplay = EGL_NO_DISPLAY;
 };
 
 class AutoEglImage {
 public:
-    AutoEglImage(EGLDisplay display, EGLClientBuffer clientBuffer)
-            : mDisplay(display) {
-        EGLint imageAttrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
-        image = eglCreateImageKHR(display, EGL_NO_CONTEXT,
-                EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
+    AutoEglImage(EGLDisplay display, EGLClientBuffer clientBuffer) : mDisplay(display) {
+        EGLint imageAttrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
+        image = eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, clientBuffer,
+                                  imageAttrs);
     }
 
     ~AutoEglImage() {
@@ -305,21 +301,19 @@
     }
 
     EGLImageKHR image = EGL_NO_IMAGE_KHR;
+
 private:
     EGLDisplay mDisplay = EGL_NO_DISPLAY;
 };
 
 class AutoGlTexture {
 public:
-    AutoGlTexture(uirenderer::Caches& caches)
-            : mCaches(caches) {
+    AutoGlTexture(uirenderer::Caches& caches) : mCaches(caches) {
         glGenTextures(1, &mTexture);
         caches.textureState().bindTexture(mTexture);
     }
 
-    ~AutoGlTexture() {
-        mCaches.textureState().deleteTexture(mTexture);
-    }
+    ~AutoGlTexture() { mCaches.textureState().deleteTexture(mTexture); }
 
 private:
     uirenderer::Caches& mCaches;
@@ -327,18 +321,17 @@
 };
 
 static bool uploadBitmapToGraphicBuffer(uirenderer::Caches& caches, SkBitmap& bitmap,
-        GraphicBuffer& buffer, GLint format, GLint type) {
+                                        GraphicBuffer& buffer, GLint format, GLint type) {
     EGLDisplay display = eglGetCurrentDisplay();
-    LOG_ALWAYS_FATAL_IF(display == EGL_NO_DISPLAY,
-                "Failed to get EGL_DEFAULT_DISPLAY! err=%s",
-                uirenderer::renderthread::EglManager::eglErrorString());
+    LOG_ALWAYS_FATAL_IF(display == EGL_NO_DISPLAY, "Failed to get EGL_DEFAULT_DISPLAY! err=%s",
+                        uirenderer::renderthread::EglManager::eglErrorString());
     // We use an EGLImage to access the content of the GraphicBuffer
     // The EGL image is later bound to a 2D texture
-    EGLClientBuffer clientBuffer = (EGLClientBuffer) buffer.getNativeBuffer();
+    EGLClientBuffer clientBuffer = (EGLClientBuffer)buffer.getNativeBuffer();
     AutoEglImage autoImage(display, clientBuffer);
     if (autoImage.image == EGL_NO_IMAGE_KHR) {
         ALOGW("Could not create EGL image, err =%s",
-                uirenderer::renderthread::EglManager::eglErrorString());
+              uirenderer::renderthread::EglManager::eglErrorString());
         return false;
     }
     AutoGlTexture glTexture(caches);
@@ -346,8 +339,8 @@
 
     GL_CHECKPOINT(MODERATE);
 
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width(), bitmap.height(),
-            format, type, bitmap.getPixels());
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, bitmap.width(), bitmap.height(), format, type,
+                    bitmap.getPixels());
 
     GL_CHECKPOINT(MODERATE);
 
@@ -362,7 +355,7 @@
     // The flag EGL_SYNC_FLUSH_COMMANDS_BIT_KHR will trigger a
     // pipeline flush (similar to what a glFlush() would do.)
     EGLint waitStatus = eglClientWaitSyncKHR(display, autoFence.fence,
-            EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, FENCE_TIMEOUT);
+                                             EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, FENCE_TIMEOUT);
     if (waitStatus != EGL_CONDITION_SATISFIED_KHR) {
         LOG_ALWAYS_FATAL("Failed to wait for the fence %#x", eglGetError());
         return false;
@@ -373,24 +366,24 @@
 // TODO: handle SRGB sanely
 static PixelFormat internalFormatToPixelFormat(GLint internalFormat) {
     switch (internalFormat) {
-    case GL_LUMINANCE:
-        return PIXEL_FORMAT_RGBA_8888;
-    case GL_SRGB8_ALPHA8:
-        return PIXEL_FORMAT_RGBA_8888;
-    case GL_RGBA:
-        return PIXEL_FORMAT_RGBA_8888;
-    case GL_RGB:
-        return PIXEL_FORMAT_RGB_565;
-    case GL_RGBA16F:
-        return PIXEL_FORMAT_RGBA_FP16;
-    default:
-        LOG_ALWAYS_FATAL("Unsupported bitmap colorType: %d", internalFormat);
-        return PIXEL_FORMAT_UNKNOWN;
+        case GL_LUMINANCE:
+            return PIXEL_FORMAT_RGBA_8888;
+        case GL_SRGB8_ALPHA8:
+            return PIXEL_FORMAT_RGBA_8888;
+        case GL_RGBA:
+            return PIXEL_FORMAT_RGBA_8888;
+        case GL_RGB:
+            return PIXEL_FORMAT_RGB_565;
+        case GL_RGBA16F:
+            return PIXEL_FORMAT_RGBA_FP16;
+        default:
+            LOG_ALWAYS_FATAL("Unsupported bitmap colorType: %d", internalFormat);
+            return PIXEL_FORMAT_UNKNOWN;
     }
 }
 
 sk_sp<Bitmap> OpenGLPipeline::allocateHardwareBitmap(RenderThread& renderThread,
-        SkBitmap& skBitmap) {
+                                                     SkBitmap& skBitmap) {
     renderThread.eglManager().initialize();
     uirenderer::Caches& caches = uirenderer::Caches::getInstance();
 
@@ -404,13 +397,14 @@
     bool hasLinearBlending = caches.extensions().hasLinearBlending();
     GLint format, type, internalFormat;
     uirenderer::Texture::colorTypeToGlFormatAndType(caches, skBitmap.colorType(),
-            needSRGB && hasLinearBlending, &internalFormat, &format, &type);
+                                                    needSRGB && hasLinearBlending, &internalFormat,
+                                                    &format, &type);
 
     PixelFormat pixelFormat = internalFormatToPixelFormat(internalFormat);
-    sp<GraphicBuffer> buffer = new GraphicBuffer(info.width(), info.height(), pixelFormat,
-            GraphicBuffer::USAGE_HW_TEXTURE |
-            GraphicBuffer::USAGE_SW_WRITE_NEVER |
-            GraphicBuffer::USAGE_SW_READ_NEVER,
+    sp<GraphicBuffer> buffer = new GraphicBuffer(
+            info.width(), info.height(), pixelFormat,
+            GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::USAGE_SW_WRITE_NEVER |
+                    GraphicBuffer::USAGE_SW_READ_NEVER,
             std::string("Bitmap::allocateHardwareBitmap pid [") + std::to_string(getpid()) + "]");
 
     status_t error = buffer->initCheck();
@@ -420,8 +414,8 @@
     }
 
     SkBitmap bitmap;
-    if (CC_UNLIKELY(uirenderer::Texture::hasUnsupportedColorType(skBitmap.info(),
-            hasLinearBlending))) {
+    if (CC_UNLIKELY(
+                uirenderer::Texture::hasUnsupportedColorType(skBitmap.info(), hasLinearBlending))) {
         sk_sp<SkColorSpace> sRGB = SkColorSpace::MakeSRGB();
         bitmap = uirenderer::Texture::uploadToN32(skBitmap, hasLinearBlending, std::move(sRGB));
     } else {
diff --git a/libs/hwui/renderthread/OpenGLPipeline.h b/libs/hwui/renderthread/OpenGLPipeline.h
index 1f467c1..118007c 100644
--- a/libs/hwui/renderthread/OpenGLPipeline.h
+++ b/libs/hwui/renderthread/OpenGLPipeline.h
@@ -16,9 +16,9 @@
 
 #pragma once
 
-#include "CanvasContext.h"
 #include "BakedOpDispatcher.h"
 #include "BakedOpRenderer.h"
+#include "CanvasContext.h"
 #include "FrameBuilder.h"
 #include "IRenderPipeline.h"
 
@@ -34,14 +34,13 @@
     MakeCurrentResult makeCurrent() override;
     Frame getFrame() override;
     bool draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
-            const FrameBuilder::LightGeometry& lightGeometry,
-            LayerUpdateQueue* layerUpdateQueue,
-            const Rect& contentDrawBounds, bool opaque, bool wideColorGamut,
-            const BakedOpRenderer::LightInfo& lightInfo,
-            const std::vector< sp<RenderNode> >& renderNodes,
-            FrameInfoVisualizer* profiler) override;
+              const FrameBuilder::LightGeometry& lightGeometry, LayerUpdateQueue* layerUpdateQueue,
+              const Rect& contentDrawBounds, bool opaque, bool wideColorGamut,
+              const BakedOpRenderer::LightInfo& lightInfo,
+              const std::vector<sp<RenderNode>>& renderNodes,
+              FrameInfoVisualizer* profiler) override;
     bool swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
-            FrameInfo* currentFrameInfo, bool* requireSwap) override;
+                     FrameInfo* currentFrameInfo, bool* requireSwap) override;
     bool copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) override;
     DeferredLayerUpdater* createTextureLayer() override;
     bool setSurface(Surface* window, SwapBehavior swapBehavior, ColorMode colorMode) override;
@@ -50,11 +49,11 @@
     bool isContextReady() override;
     void onDestroyHardwareResources() override;
     void renderLayers(const FrameBuilder::LightGeometry& lightGeometry,
-            LayerUpdateQueue* layerUpdateQueue, bool opaque, bool wideColorGamut,
-            const BakedOpRenderer::LightInfo& lightInfo) override;
+                      LayerUpdateQueue* layerUpdateQueue, bool opaque, bool wideColorGamut,
+                      const BakedOpRenderer::LightInfo& lightInfo) override;
     TaskManager* getTaskManager() override;
-    bool createOrUpdateLayer(RenderNode* node,
-            const DamageAccumulator& damageAccumulator, bool wideColorGamut) override;
+    bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& damageAccumulator,
+                             bool wideColorGamut) override;
     bool pinImages(std::vector<SkImage*>& mutableImages) override { return false; }
     bool pinImages(LsaVector<sk_sp<Bitmap>>& images) override;
     void unpinImages() override;
@@ -62,8 +61,7 @@
     static void destroyLayer(RenderNode* node);
     static void prepareToDraw(const RenderThread& thread, Bitmap* bitmap);
     static void invokeFunctor(const RenderThread& thread, Functor* functor);
-    static sk_sp<Bitmap> allocateHardwareBitmap(RenderThread& thread,
-            SkBitmap& skBitmap);
+    static sk_sp<Bitmap> allocateHardwareBitmap(RenderThread& thread, SkBitmap& skBitmap);
 
 private:
     EglManager& mEglManager;
diff --git a/libs/hwui/renderthread/RenderProxy.cpp b/libs/hwui/renderthread/RenderProxy.cpp
index 2f406da..79e46ed 100644
--- a/libs/hwui/renderthread/RenderProxy.cpp
+++ b/libs/hwui/renderthread/RenderProxy.cpp
@@ -22,11 +22,11 @@
 #include "Readback.h"
 #include "Rect.h"
 #include "pipeline/skia/VectorDrawableAtlas.h"
+#include "renderstate/RenderState.h"
 #include "renderthread/CanvasContext.h"
 #include "renderthread/EglManager.h"
 #include "renderthread/RenderTask.h"
 #include "renderthread/RenderThread.h"
-#include "renderstate/RenderState.h"
 #include "utils/Macros.h"
 #include "utils/TimeUtils.h"
 
@@ -36,9 +36,9 @@
 namespace uirenderer {
 namespace renderthread {
 
-RenderProxy::RenderProxy(bool translucent, RenderNode* rootRenderNode, IContextFactory* contextFactory)
-        : mRenderThread(RenderThread::getInstance())
-        , mContext(nullptr) {
+RenderProxy::RenderProxy(bool translucent, RenderNode* rootRenderNode,
+                         IContextFactory* contextFactory)
+        : mRenderThread(RenderThread::getInstance()), mContext(nullptr) {
     mContext = mRenderThread.queue().runSync([&]() -> CanvasContext* {
         return CanvasContext::create(mRenderThread, translucent, rootRenderNode, contextFactory);
     });
@@ -54,17 +54,13 @@
         mDrawFrameTask.setContext(nullptr, nullptr, nullptr);
         // This is also a fence as we need to be certain that there are no
         // outstanding mDrawFrame tasks posted before it is destroyed
-        mRenderThread.queue().runSync([this]() {
-            delete mContext;
-        });
+        mRenderThread.queue().runSync([this]() { delete mContext; });
         mContext = nullptr;
     }
 }
 
 void RenderProxy::setSwapBehavior(SwapBehavior swapBehavior) {
-    mRenderThread.queue().post([this, swapBehavior]() {
-        mContext->setSwapBehavior(swapBehavior);
-    });
+    mRenderThread.queue().post([this, swapBehavior]() { mContext->setSwapBehavior(swapBehavior); });
 }
 
 bool RenderProxy::loadSystemProperties() {
@@ -83,57 +79,42 @@
 void RenderProxy::setName(const char* name) {
     // block since name/value pointers owned by caller
     // TODO: Support move arguments
-    mRenderThread.queue().runSync([this, name]() {
-        mContext->setName(std::string(name));
-    });
+    mRenderThread.queue().runSync([this, name]() { mContext->setName(std::string(name)); });
 }
 
 void RenderProxy::initialize(const sp<Surface>& surface) {
-    mRenderThread.queue().post([this, surf = surface]() mutable {
-        mContext->setSurface(std::move(surf));
-    });
+    mRenderThread.queue().post(
+            [ this, surf = surface ]() mutable { mContext->setSurface(std::move(surf)); });
 }
 
 void RenderProxy::updateSurface(const sp<Surface>& surface) {
-    mRenderThread.queue().post([this, surf = surface]() mutable {
-        mContext->setSurface(std::move(surf));
-    });
+    mRenderThread.queue().post(
+            [ this, surf = surface ]() mutable { mContext->setSurface(std::move(surf)); });
 }
 
 bool RenderProxy::pauseSurface(const sp<Surface>& surface) {
-    return mRenderThread.queue().runSync([this]() -> bool {
-        return mContext->pauseSurface();
-    });
+    return mRenderThread.queue().runSync([this]() -> bool { return mContext->pauseSurface(); });
 }
 
 void RenderProxy::setStopped(bool stopped) {
-    mRenderThread.queue().runSync([this, stopped]() {
-        mContext->setStopped(stopped);
-    });
+    mRenderThread.queue().runSync([this, stopped]() { mContext->setStopped(stopped); });
 }
 
 void RenderProxy::setup(float lightRadius, uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
-    mRenderThread.queue().post([=]() {
-        mContext->setup(lightRadius, ambientShadowAlpha, spotShadowAlpha);
-    });
+    mRenderThread.queue().post(
+            [=]() { mContext->setup(lightRadius, ambientShadowAlpha, spotShadowAlpha); });
 }
 
 void RenderProxy::setLightCenter(const Vector3& lightCenter) {
-    mRenderThread.queue().post([=]() {
-        mContext->setLightCenter(lightCenter);
-    });
+    mRenderThread.queue().post([=]() { mContext->setLightCenter(lightCenter); });
 }
 
 void RenderProxy::setOpaque(bool opaque) {
-    mRenderThread.queue().post([=]() {
-        mContext->setOpaque(opaque);
-    });
+    mRenderThread.queue().post([=]() { mContext->setOpaque(opaque); });
 }
 
 void RenderProxy::setWideGamut(bool wideGamut) {
-    mRenderThread.queue().post([=]() {
-        mContext->setWideGamut(wideGamut);
-    });
+    mRenderThread.queue().post([=]() { mContext->setWideGamut(wideGamut); });
 }
 
 int64_t* RenderProxy::frameInfo() {
@@ -148,9 +129,7 @@
     // destroyCanvasAndSurface() needs a fence as when it returns the
     // underlying BufferQueue is going to be released from under
     // the render thread.
-    mRenderThread.queue().runSync([=]() {
-        mContext->destroy();
-    });
+    mRenderThread.queue().runSync([=]() { mContext->destroy(); });
 }
 
 void RenderProxy::invokeFunctor(Functor* functor, bool waitForCompletion) {
@@ -174,15 +153,12 @@
 }
 
 void RenderProxy::buildLayer(RenderNode* node) {
-    mRenderThread.queue().runSync([&]() {
-        mContext->buildLayer(node);
-    });
+    mRenderThread.queue().runSync([&]() { mContext->buildLayer(node); });
 }
 
 bool RenderProxy::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap& bitmap) {
-    return mRenderThread.queue().runSync([&]() -> bool {
-        return mContext->copyLayerInto(layer, &bitmap);
-    });
+    return mRenderThread.queue().runSync(
+            [&]() -> bool { return mContext->copyLayerInto(layer, &bitmap); });
 }
 
 void RenderProxy::pushLayerUpdate(DeferredLayerUpdater* layer) {
@@ -194,52 +170,41 @@
 }
 
 void RenderProxy::detachSurfaceTexture(DeferredLayerUpdater* layer) {
-    return mRenderThread.queue().runSync([&]() {
-        layer->detachSurfaceTexture();
-    });
+    return mRenderThread.queue().runSync([&]() { layer->detachSurfaceTexture(); });
 }
 
 void RenderProxy::destroyHardwareResources() {
-    return mRenderThread.queue().runSync([&]() {
-        mContext->destroyHardwareResources();
-    });
+    return mRenderThread.queue().runSync([&]() { mContext->destroyHardwareResources(); });
 }
 
 void RenderProxy::trimMemory(int level) {
     // Avoid creating a RenderThread to do a trimMemory.
     if (RenderThread::hasInstance()) {
         RenderThread& thread = RenderThread::getInstance();
-        thread.queue().post([&thread, level]() {
-            CanvasContext::trimMemory(thread, level);
-        });
+        thread.queue().post([&thread, level]() { CanvasContext::trimMemory(thread, level); });
     }
 }
 
 void RenderProxy::overrideProperty(const char* name, const char* value) {
     // expensive, but block here since name/value pointers owned by caller
-    RenderThread::getInstance().queue().runSync([&]() {
-        Properties::overrideProperty(name, value);
-    });
+    RenderThread::getInstance().queue().runSync(
+            [&]() { Properties::overrideProperty(name, value); });
 }
 
 void RenderProxy::fence() {
-    mRenderThread.queue().runSync([](){});
+    mRenderThread.queue().runSync([]() {});
 }
 
 void RenderProxy::staticFence() {
-    RenderThread::getInstance().queue().runSync([](){});
+    RenderThread::getInstance().queue().runSync([]() {});
 }
 
 void RenderProxy::stopDrawing() {
-    mRenderThread.queue().runSync([this]() {
-        mContext->stopDrawing();
-    });
+    mRenderThread.queue().runSync([this]() { mContext->stopDrawing(); });
 }
 
 void RenderProxy::notifyFramePending() {
-    mRenderThread.queue().post([this]() {
-        mContext->notifyFramePending();
-    });
+    mRenderThread.queue().post([this]() { mContext->notifyFramePending(); });
 }
 
 void RenderProxy::dumpProfileInfo(int fd, int dumpFlags) {
@@ -258,9 +223,7 @@
 }
 
 void RenderProxy::resetProfileInfo() {
-    mRenderThread.queue().runSync([=]() {
-        mContext->resetFrameStats();
-    });
+    mRenderThread.queue().runSync([=]() { mContext->resetFrameStats(); });
 }
 
 uint32_t RenderProxy::frameTimePercentile(int percentile) {
@@ -271,14 +234,12 @@
 
 void RenderProxy::dumpGraphicsMemory(int fd) {
     auto& thread = RenderThread::getInstance();
-    thread.queue().runSync([&]() {
-        thread.dumpGraphicsMemory(fd);
-    });
+    thread.queue().runSync([&]() { thread.dumpGraphicsMemory(fd); });
 }
 
 void RenderProxy::setProcessStatsBuffer(int fd) {
     auto& rt = RenderThread::getInstance();
-    rt.queue().post([&rt, fd = dup(fd)]() {
+    rt.queue().post([&rt, fd = dup(fd) ]() {
         rt.globalProfileData().switchStorageToAshmem(fd);
         close(fd);
     });
@@ -286,9 +247,7 @@
 
 void RenderProxy::rotateProcessStatsBuffer() {
     auto& rt = RenderThread::getInstance();
-    rt.queue().post([&rt]() {
-        rt.globalProfileData().rotateStorage();
-    });
+    rt.queue().post([&rt]() { rt.globalProfileData().rotateStorage(); });
 }
 
 int RenderProxy::getRenderThreadTid() {
@@ -296,21 +255,15 @@
 }
 
 void RenderProxy::addRenderNode(RenderNode* node, bool placeFront) {
-    mRenderThread.queue().post([=]() {
-        mContext->addRenderNode(node, placeFront);
-    });
+    mRenderThread.queue().post([=]() { mContext->addRenderNode(node, placeFront); });
 }
 
 void RenderProxy::removeRenderNode(RenderNode* node) {
-    mRenderThread.queue().post([=]() {
-        mContext->removeRenderNode(node);
-    });
+    mRenderThread.queue().post([=]() { mContext->removeRenderNode(node); });
 }
 
 void RenderProxy::drawRenderNode(RenderNode* node) {
-    mRenderThread.queue().runSync([=]() {
-        mContext->prepareAndDraw(node);
-    });
+    mRenderThread.queue().runSync([=]() { mContext->prepareAndDraw(node); });
 }
 
 void RenderProxy::setContentDrawBounds(int left, int top, int right, int bottom) {
@@ -318,25 +271,23 @@
 }
 
 void RenderProxy::serializeDisplayListTree() {
-    mRenderThread.queue().post([=]() {
-        mContext->serializeDisplayListTree();
-    });
+    mRenderThread.queue().post([=]() { mContext->serializeDisplayListTree(); });
 }
 
 void RenderProxy::addFrameMetricsObserver(FrameMetricsObserver* observerPtr) {
-    mRenderThread.queue().post([this, observer = sp{observerPtr}]() {
+    mRenderThread.queue().post([ this, observer = sp{observerPtr} ]() {
         mContext->addFrameMetricsObserver(observer.get());
     });
 }
 
 void RenderProxy::removeFrameMetricsObserver(FrameMetricsObserver* observerPtr) {
-    mRenderThread.queue().post([this, observer = sp{observerPtr}]() {
+    mRenderThread.queue().post([ this, observer = sp{observerPtr} ]() {
         mContext->removeFrameMetricsObserver(observer.get());
     });
 }
 
-int RenderProxy::copySurfaceInto(sp<Surface>& surface, int left, int top,
-        int right, int bottom,  SkBitmap* bitmap) {
+int RenderProxy::copySurfaceInto(sp<Surface>& surface, int left, int top, int right, int bottom,
+                                 SkBitmap* bitmap) {
     auto& thread = RenderThread::getInstance();
     return static_cast<int>(thread.queue().runSync([&]() -> auto {
         return thread.readback().copySurfaceInto(*surface, Rect(left, top, right, bottom), bitmap);
@@ -372,19 +323,17 @@
 
 sk_sp<Bitmap> RenderProxy::allocateHardwareBitmap(SkBitmap& bitmap) {
     auto& thread = RenderThread::getInstance();
-    return thread.queue().runSync([&]() -> auto {
-        return thread.allocateHardwareBitmap(bitmap);
-    });
+    return thread.queue().runSync([&]() -> auto { return thread.allocateHardwareBitmap(bitmap); });
 }
 
 int RenderProxy::copyGraphicBufferInto(GraphicBuffer* buffer, SkBitmap* bitmap) {
     RenderThread& thread = RenderThread::getInstance();
     if (Properties::isSkiaEnabled() && gettid() == thread.getTid()) {
-        //TODO: fix everything that hits this. We should never be triggering a readback ourselves.
-        return (int) thread.readback().copyGraphicBufferInto(buffer, bitmap);
+        // TODO: fix everything that hits this. We should never be triggering a readback ourselves.
+        return (int)thread.readback().copyGraphicBufferInto(buffer, bitmap);
     } else {
         return thread.queue().runSync([&]() -> int {
-            return (int) thread.readback().copyGraphicBufferInto(buffer, bitmap);
+            return (int)thread.readback().copyGraphicBufferInto(buffer, bitmap);
         });
     }
 }
@@ -392,9 +341,8 @@
 void RenderProxy::onBitmapDestroyed(uint32_t pixelRefId) {
     if (!RenderThread::hasInstance()) return;
     RenderThread& thread = RenderThread::getInstance();
-    thread.queue().post([&thread, pixelRefId]() {
-        thread.renderState().onBitmapDestroyed(pixelRefId);
-    });
+    thread.queue().post(
+            [&thread, pixelRefId]() { thread.renderState().onBitmapDestroyed(pixelRefId); });
 }
 
 void RenderProxy::disableVsync() {
diff --git a/libs/hwui/renderthread/RenderProxy.h b/libs/hwui/renderthread/RenderProxy.h
index b46d9cc..bc57d92 100644
--- a/libs/hwui/renderthread/RenderProxy.h
+++ b/libs/hwui/renderthread/RenderProxy.h
@@ -17,16 +17,16 @@
 #ifndef RENDERPROXY_H_
 #define RENDERPROXY_H_
 
-#include <cutils/compiler.h>
 #include <SkBitmap.h>
-#include <utils/Functor.h>
+#include <cutils/compiler.h>
 #include <gui/Surface.h>
+#include <utils/Functor.h>
 
 #include "../FrameMetricsObserver.h"
 #include "../IContextFactory.h"
-#include "hwui/Bitmap.h"
 #include "DrawFrameTask.h"
 #include "SwapBehavior.h"
+#include "hwui/Bitmap.h"
 
 namespace android {
 class GraphicBuffer;
@@ -44,11 +44,11 @@
 class RenderProxyBridge;
 
 namespace DumpFlags {
-    enum {
-        FrameStats = 1 << 0,
-        Reset      = 1 << 1,
-        JankStats  = 1 << 2,
-    };
+enum {
+    FrameStats = 1 << 0,
+    Reset = 1 << 1,
+    JankStats = 1 << 2,
+};
 };
 
 /*
@@ -73,8 +73,7 @@
     ANDROID_API void updateSurface(const sp<Surface>& surface);
     ANDROID_API bool pauseSurface(const sp<Surface>& surface);
     ANDROID_API void setStopped(bool stopped);
-    ANDROID_API void setup(float lightRadius,
-            uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
+    ANDROID_API void setup(float lightRadius, uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
     ANDROID_API void setLightCenter(const Vector3& lightCenter);
     ANDROID_API void setOpaque(bool opaque);
     ANDROID_API void setWideGamut(bool wideGamut);
@@ -121,8 +120,8 @@
     ANDROID_API void removeFrameMetricsObserver(FrameMetricsObserver* observer);
     ANDROID_API long getDroppedFrameReportCount();
 
-    ANDROID_API static int copySurfaceInto(sp<Surface>& surface,
-            int left, int top, int right, int bottom, SkBitmap* bitmap);
+    ANDROID_API static int copySurfaceInto(sp<Surface>& surface, int left, int top, int right,
+                                           int bottom, SkBitmap* bitmap);
     ANDROID_API static void prepareToDraw(Bitmap& bitmap);
 
     static sk_sp<Bitmap> allocateHardwareBitmap(SkBitmap& bitmap);
diff --git a/libs/hwui/renderthread/RenderTask.h b/libs/hwui/renderthread/RenderTask.h
index a7acf91..c56a357 100644
--- a/libs/hwui/renderthread/RenderTask.h
+++ b/libs/hwui/renderthread/RenderTask.h
@@ -53,7 +53,7 @@
     ANDROID_API virtual void run() = 0;
 
     RenderTask* mNext;
-    nsecs_t mRunAt; // nano-seconds on the SYSTEM_TIME_MONOTONIC clock
+    nsecs_t mRunAt;  // nano-seconds on the SYSTEM_TIME_MONOTONIC clock
 };
 
 class SignalingRenderTask : public RenderTask {
@@ -75,8 +75,7 @@
 
 class MethodInvokeRenderTask : public RenderTask {
 public:
-    explicit MethodInvokeRenderTask(RunnableMethod method)
-        : mMethod(method), mReturnPtr(nullptr) {}
+    explicit MethodInvokeRenderTask(RunnableMethod method) : mMethod(method), mReturnPtr(nullptr) {}
 
     void* payload() { return mData; }
     void setReturnPtr(void** retptr) { mReturnPtr = retptr; }
@@ -89,6 +88,7 @@
         // Commit suicide
         delete this;
     }
+
 private:
     RunnableMethod mMethod;
     char mData[METHOD_INVOKE_PAYLOAD_SIZE];
diff --git a/libs/hwui/renderthread/RenderThread.cpp b/libs/hwui/renderthread/RenderThread.cpp
index f3bb120..c117cb8 100644
--- a/libs/hwui/renderthread/RenderThread.cpp
+++ b/libs/hwui/renderthread/RenderThread.cpp
@@ -16,17 +16,17 @@
 
 #include "RenderThread.h"
 
-#include "hwui/Bitmap.h"
-#include "renderstate/RenderState.h"
-#include "renderthread/OpenGLPipeline.h"
-#include "pipeline/skia/SkiaOpenGLReadback.h"
-#include "pipeline/skia/SkiaOpenGLPipeline.h"
-#include "pipeline/skia/SkiaVulkanPipeline.h"
 #include "CanvasContext.h"
 #include "EglManager.h"
 #include "OpenGLReadback.h"
 #include "RenderProxy.h"
 #include "VulkanManager.h"
+#include "hwui/Bitmap.h"
+#include "pipeline/skia/SkiaOpenGLPipeline.h"
+#include "pipeline/skia/SkiaOpenGLReadback.h"
+#include "pipeline/skia/SkiaVulkanPipeline.h"
+#include "renderstate/RenderState.h"
+#include "renderthread/OpenGLPipeline.h"
 #include "utils/FatVector.h"
 
 #include <gui/DisplayEventReceiver.h>
@@ -64,7 +64,8 @@
     return *sInstance;
 }
 
-RenderThread::RenderThread() : ThreadBase()
+RenderThread::RenderThread()
+        : ThreadBase()
         , mDisplayEventReceiver(nullptr)
         , mVsyncRequested(false)
         , mFrameCallbackTaskPending(false)
@@ -83,17 +84,18 @@
     LOG_ALWAYS_FATAL_IF(mDisplayEventReceiver, "Initializing a second DisplayEventReceiver?");
     mDisplayEventReceiver = new DisplayEventReceiver();
     status_t status = mDisplayEventReceiver->initCheck();
-    LOG_ALWAYS_FATAL_IF(status != NO_ERROR, "Initialization of DisplayEventReceiver "
-            "failed with status: %d", status);
+    LOG_ALWAYS_FATAL_IF(status != NO_ERROR,
+                        "Initialization of DisplayEventReceiver "
+                        "failed with status: %d",
+                        status);
 
     // Register the FD
-    mLooper->addFd(mDisplayEventReceiver->getFd(), 0,
-            Looper::EVENT_INPUT, RenderThread::displayEventReceiverCallback, this);
+    mLooper->addFd(mDisplayEventReceiver->getFd(), 0, Looper::EVENT_INPUT,
+                   RenderThread::displayEventReceiverCallback, this);
 }
 
 void RenderThread::initThreadLocals() {
-    sp<IBinder> dtoken(SurfaceComposerClient::getBuiltInDisplay(
-            ISurfaceComposer::eDisplayIdMain));
+    sp<IBinder> dtoken(SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain));
     status_t status = SurfaceComposerClient::getDisplayInfo(dtoken, &mDisplayInfo);
     LOG_ALWAYS_FATAL_IF(status, "Failed to get display info\n");
     nsecs_t frameIntervalNanos = static_cast<nsecs_t>(1000000000 / mDisplayInfo.fps);
@@ -133,18 +135,17 @@
             break;
         }
         default:
-            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
             break;
     }
 
-    FILE *file = fdopen(fd, "a");
+    FILE* file = fdopen(fd, "a");
     fprintf(file, "\n%s\n", cachesOutput.string());
     fprintf(file, "\nPipeline=%s\n", pipeline.string());
     fflush(file);
 }
 
 Readback& RenderThread::readback() {
-
     if (!mReadback) {
         auto renderType = Properties::getRenderPipelineType();
         switch (renderType) {
@@ -159,7 +160,7 @@
                 mReadback = new skiapipeline::SkiaOpenGLReadback(*this);
                 break;
             default:
-                LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+                LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
                 break;
         }
     }
@@ -178,19 +179,21 @@
 int RenderThread::displayEventReceiverCallback(int fd, int events, void* data) {
     if (events & (Looper::EVENT_ERROR | Looper::EVENT_HANGUP)) {
         ALOGE("Display event receiver pipe was closed or an error occurred.  "
-                "events=0x%x", events);
-        return 0; // remove the callback
+              "events=0x%x",
+              events);
+        return 0;  // remove the callback
     }
 
     if (!(events & Looper::EVENT_INPUT)) {
         ALOGW("Received spurious callback for unhandled poll event.  "
-                "events=0x%x", events);
-        return 1; // keep the callback
+              "events=0x%x",
+              events);
+        return 1;  // keep the callback
     }
 
     reinterpret_cast<RenderThread*>(data)->drainDisplayEventQueue();
 
-    return 1; // keep the callback
+    return 1;  // keep the callback
 }
 
 static nsecs_t latestVsyncEvent(DisplayEventReceiver* receiver) {
@@ -201,9 +204,9 @@
         for (ssize_t i = 0; i < n; i++) {
             const DisplayEventReceiver::Event& ev = buf[i];
             switch (ev.header.type) {
-            case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:
-                latest = ev.header.timestamp;
-                break;
+                case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:
+                    latest = ev.header.timestamp;
+                    break;
             }
         }
     }
@@ -222,9 +225,7 @@
             ATRACE_NAME("queue mFrameCallbackTask");
             mFrameCallbackTaskPending = true;
             nsecs_t runAt = (vsyncEvent + DISPATCH_FRAME_CALLBACKS_DELAY);
-            queue().postAt(runAt, [this]() {
-                dispatchFrameCallbacks();
-            });
+            queue().postAt(runAt, [this]() { dispatchFrameCallbacks(); });
         }
     }
 }
@@ -240,7 +241,8 @@
         // Assume one of them will probably animate again so preemptively
         // request the next vsync in case it occurs mid-frame
         requestVsync();
-        for (std::set<IFrameCallback*>::iterator it = callbacks.begin(); it != callbacks.end(); it++) {
+        for (std::set<IFrameCallback*>::iterator it = callbacks.begin(); it != callbacks.end();
+             it++) {
             (*it)->doFrame();
         }
     }
@@ -250,8 +252,7 @@
     if (!mVsyncRequested) {
         mVsyncRequested = true;
         status_t status = mDisplayEventReceiver->requestNextVsync();
-        LOG_ALWAYS_FATAL_IF(status != NO_ERROR,
-                "requestNextVsync failed with status: %d", status);
+        LOG_ALWAYS_FATAL_IF(status != NO_ERROR, "requestNextVsync failed with status: %d", status);
     }
 }
 
@@ -265,8 +266,8 @@
 
         if (mPendingRegistrationFrameCallbacks.size() && !mFrameCallbackTaskPending) {
             drainDisplayEventQueue();
-            mFrameCallbacks.insert(
-                    mPendingRegistrationFrameCallbacks.begin(), mPendingRegistrationFrameCallbacks.end());
+            mFrameCallbacks.insert(mPendingRegistrationFrameCallbacks.begin(),
+                                   mPendingRegistrationFrameCallbacks.end());
             mPendingRegistrationFrameCallbacks.clear();
             requestVsync();
         }
@@ -310,7 +311,7 @@
         case RenderPipelineType::SkiaVulkan:
             return skiapipeline::SkiaVulkanPipeline::allocateHardwareBitmap(*this, skBitmap);
         default:
-            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t) renderType);
+            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
             break;
     }
     return nullptr;
diff --git a/libs/hwui/renderthread/RenderThread.h b/libs/hwui/renderthread/RenderThread.h
index e1d61c5..d17a509 100644
--- a/libs/hwui/renderthread/RenderThread.h
+++ b/libs/hwui/renderthread/RenderThread.h
@@ -25,16 +25,16 @@
 #include "thread/ThreadBase.h"
 
 #include <GrContext.h>
-#include <cutils/compiler.h>
 #include <SkBitmap.h>
+#include <cutils/compiler.h>
 #include <ui/DisplayInfo.h>
 #include <utils/Looper.h>
 #include <utils/Thread.h>
 
+#include <thread/ThreadBase.h>
 #include <memory>
 #include <mutex>
 #include <set>
-#include <thread/ThreadBase.h>
 
 namespace android {
 
@@ -65,8 +65,8 @@
 
 class RenderThread : private ThreadBase {
     PREVENT_COPY_AND_ASSIGN(RenderThread);
-public:
 
+public:
     WorkQueue& queue() { return ThreadBase::queue(); }
 
     // Mimics android.view.Choreographer
diff --git a/libs/hwui/renderthread/TimeLord.cpp b/libs/hwui/renderthread/TimeLord.cpp
index 6c2575f..b82c5d1 100644
--- a/libs/hwui/renderthread/TimeLord.cpp
+++ b/libs/hwui/renderthread/TimeLord.cpp
@@ -19,10 +19,7 @@
 namespace uirenderer {
 namespace renderthread {
 
-TimeLord::TimeLord()
-        : mFrameIntervalNanos(milliseconds_to_nanoseconds(16))
-        , mFrameTimeNanos(0) {
-}
+TimeLord::TimeLord() : mFrameIntervalNanos(milliseconds_to_nanoseconds(16)), mFrameTimeNanos(0) {}
 
 bool TimeLord::vsyncReceived(nsecs_t vsync) {
     if (vsync > mFrameTimeNanos) {
diff --git a/libs/hwui/renderthread/VulkanManager.cpp b/libs/hwui/renderthread/VulkanManager.cpp
index 2195143..3272d69 100644
--- a/libs/hwui/renderthread/VulkanManager.cpp
+++ b/libs/hwui/renderthread/VulkanManager.cpp
@@ -31,11 +31,10 @@
 namespace uirenderer {
 namespace renderthread {
 
-#define GET_PROC(F) m ## F = (PFN_vk ## F) vkGetInstanceProcAddr(instance, "vk" #F)
-#define GET_DEV_PROC(F) m ## F = (PFN_vk ## F) vkGetDeviceProcAddr(device, "vk" #F)
+#define GET_PROC(F) m##F = (PFN_vk##F)vkGetInstanceProcAddr(instance, "vk" #F)
+#define GET_DEV_PROC(F) m##F = (PFN_vk##F)vkGetDeviceProcAddr(device, "vk" #F)
 
-VulkanManager::VulkanManager(RenderThread& thread) : mRenderThread(thread) {
-}
+VulkanManager::VulkanManager(RenderThread& thread) : mRenderThread(thread) {}
 
 void VulkanManager::destroy() {
     if (!hasVkContext()) return;
@@ -51,12 +50,14 @@
 }
 
 void VulkanManager::initialize() {
-    if (hasVkContext()) { return; }
+    if (hasVkContext()) {
+        return;
+    }
 
     auto canPresent = [](VkInstance, VkPhysicalDevice, uint32_t) { return true; };
 
     mBackendContext.reset(GrVkBackendContext::Create(vkGetInstanceProcAddr, vkGetDeviceProcAddr,
-            &mPresentQueueIndex, canPresent));
+                                                     &mPresentQueueIndex, canPresent));
 
     // Get all the addresses of needed vulkan functions
     VkInstance instance = mBackendContext->fInstance;
@@ -99,15 +100,15 @@
         // this needs to be on the render queue
         commandPoolInfo.queueFamilyIndex = mBackendContext->fGraphicsQueueIndex;
         commandPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-        SkDEBUGCODE(VkResult res =) mCreateCommandPool(mBackendContext->fDevice,
-                &commandPoolInfo, nullptr, &mCommandPool);
+        SkDEBUGCODE(VkResult res =) mCreateCommandPool(mBackendContext->fDevice, &commandPoolInfo,
+                                                       nullptr, &mCommandPool);
         SkASSERT(VK_SUCCESS == res);
     }
 
     mGetDeviceQueue(mBackendContext->fDevice, mPresentQueueIndex, 0, &mPresentQueue);
 
-    mRenderThread.setGrContext(GrContext::Create(kVulkan_GrBackend,
-            (GrBackendContext) mBackendContext.get()));
+    mRenderThread.setGrContext(
+            GrContext::Create(kVulkan_GrBackend, (GrBackendContext)mBackendContext.get()));
     DeviceInfo::initialize(mRenderThread.getGrContext()->caps()->maxRenderTargetSize());
 
     if (Properties::enablePartialUpdates && Properties::useBufferAge) {
@@ -127,13 +128,13 @@
         surface->mCurrentBackbufferIndex = 0;
     }
 
-    VulkanSurface::BackbufferInfo* backbuffer = surface->mBackbuffers +
-            surface->mCurrentBackbufferIndex;
+    VulkanSurface::BackbufferInfo* backbuffer =
+            surface->mBackbuffers + surface->mCurrentBackbufferIndex;
 
     // Before we reuse a backbuffer, make sure its fences have all signaled so that we can safely
     // reuse its commands buffers.
-    VkResult res = mWaitForFences(mBackendContext->fDevice, 2, backbuffer->mUsageFences,
-            true, UINT64_MAX);
+    VkResult res =
+            mWaitForFences(mBackendContext->fDevice, 2, backbuffer->mUsageFences, true, UINT64_MAX);
     if (res != VK_SUCCESS) {
         return nullptr;
     }
@@ -141,7 +142,6 @@
     return backbuffer;
 }
 
-
 SkSurface* VulkanManager::getBackbufferSurface(VulkanSurface* surface) {
     VulkanSurface::BackbufferInfo* backbuffer = getAvailableBackbuffer(surface);
     SkASSERT(backbuffer);
@@ -154,7 +154,8 @@
     // The acquire will signal the attached mAcquireSemaphore. We use this to know the image has
     // finished presenting and that it is safe to begin sending new commands to the returned image.
     res = mAcquireNextImageKHR(mBackendContext->fDevice, surface->mSwapchain, UINT64_MAX,
-            backbuffer->mAcquireSemaphore, VK_NULL_HANDLE, &backbuffer->mImageIndex);
+                               backbuffer->mAcquireSemaphore, VK_NULL_HANDLE,
+                               &backbuffer->mImageIndex);
 
     if (VK_ERROR_SURFACE_LOST_KHR == res) {
         // need to figure out how to create a new vkSurface without the platformData*
@@ -172,7 +173,8 @@
 
         // acquire the image
         res = mAcquireNextImageKHR(mBackendContext->fDevice, surface->mSwapchain, UINT64_MAX,
-                backbuffer->mAcquireSemaphore, VK_NULL_HANDLE, &backbuffer->mImageIndex);
+                                   backbuffer->mAcquireSemaphore, VK_NULL_HANDLE,
+                                   &backbuffer->mImageIndex);
 
         if (VK_SUCCESS != res) {
             return nullptr;
@@ -182,25 +184,25 @@
     // set up layout transfer from initial to color attachment
     VkImageLayout layout = surface->mImageInfos[backbuffer->mImageIndex].mImageLayout;
     SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED == layout || VK_IMAGE_LAYOUT_PRESENT_SRC_KHR == layout);
-    VkPipelineStageFlags srcStageMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ?
-                                        VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT :
-                                        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    VkPipelineStageFlags srcStageMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout)
+                                                ? VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
+                                                : VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-    VkAccessFlags srcAccessMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ?
-                                  0 : VK_ACCESS_MEMORY_READ_BIT;
+    VkAccessFlags srcAccessMask =
+            (VK_IMAGE_LAYOUT_UNDEFINED == layout) ? 0 : VK_ACCESS_MEMORY_READ_BIT;
     VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 
     VkImageMemoryBarrier imageMemoryBarrier = {
-        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,    // sType
-        NULL,                                      // pNext
-        srcAccessMask,                             // outputMask
-        dstAccessMask,                             // inputMask
-        layout,                                    // oldLayout
-        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,  // newLayout
-        mPresentQueueIndex,                        // srcQueueFamilyIndex
-        mBackendContext->fGraphicsQueueIndex,      // dstQueueFamilyIndex
-        surface->mImages[backbuffer->mImageIndex], // image
-        { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }  // subresourceRange
+            VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // sType
+            NULL,                                       // pNext
+            srcAccessMask,                              // outputMask
+            dstAccessMask,                              // inputMask
+            layout,                                     // oldLayout
+            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,   // newLayout
+            mPresentQueueIndex,                         // srcQueueFamilyIndex
+            mBackendContext->fGraphicsQueueIndex,       // dstQueueFamilyIndex
+            surface->mImages[backbuffer->mImageIndex],  // image
+            {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}     // subresourceRange
     };
     mResetCommandBuffer(backbuffer->mTransitionCmdBuffers[0], 0);
 
@@ -210,8 +212,8 @@
     info.flags = 0;
     mBeginCommandBuffer(backbuffer->mTransitionCmdBuffers[0], &info);
 
-    mCmdPipelineBarrier(backbuffer->mTransitionCmdBuffers[0], srcStageMask, dstStageMask, 0,
-            0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
+    mCmdPipelineBarrier(backbuffer->mTransitionCmdBuffers[0], srcStageMask, dstStageMask, 0, 0,
+                        nullptr, 0, nullptr, 1, &imageMemoryBarrier);
 
     mEndCommandBuffer(backbuffer->mTransitionCmdBuffers[0]);
 
@@ -235,7 +237,7 @@
     GrVkImageInfo* imageInfo;
     sk_sp<SkSurface> skSurface = surface->mImageInfos[backbuffer->mImageIndex].mSurface;
     skSurface->getRenderTargetHandle((GrBackendObject*)&imageInfo,
-            SkSurface::kFlushRead_BackendHandleAccess);
+                                     SkSurface::kFlushRead_BackendHandleAccess);
     imageInfo->updateImageLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
 
     surface->mBackbuffer = std::move(skSurface);
@@ -246,14 +248,14 @@
     if (surface->mBackbuffers) {
         for (uint32_t i = 0; i < surface->mImageCount + 1; ++i) {
             mWaitForFences(mBackendContext->fDevice, 2, surface->mBackbuffers[i].mUsageFences, true,
-                    UINT64_MAX);
+                           UINT64_MAX);
             surface->mBackbuffers[i].mImageIndex = -1;
             mDestroySemaphore(mBackendContext->fDevice, surface->mBackbuffers[i].mAcquireSemaphore,
-                    nullptr);
+                              nullptr);
             mDestroySemaphore(mBackendContext->fDevice, surface->mBackbuffers[i].mRenderSemaphore,
-                    nullptr);
+                              nullptr);
             mFreeCommandBuffers(mBackendContext->fDevice, mCommandPool, 2,
-                    surface->mBackbuffers[i].mTransitionCmdBuffers);
+                                surface->mBackbuffers[i].mTransitionCmdBuffers);
             mDestroyFence(mBackendContext->fDevice, surface->mBackbuffers[i].mUsageFences[0], 0);
             mDestroyFence(mBackendContext->fDevice, surface->mBackbuffers[i].mUsageFences[1], 0);
         }
@@ -290,11 +292,11 @@
 
 void VulkanManager::createBuffers(VulkanSurface* surface, VkFormat format, VkExtent2D extent) {
     mGetSwapchainImagesKHR(mBackendContext->fDevice, surface->mSwapchain, &surface->mImageCount,
-            nullptr);
+                           nullptr);
     SkASSERT(surface->mImageCount);
     surface->mImages = new VkImage[surface->mImageCount];
-    mGetSwapchainImagesKHR(mBackendContext->fDevice, surface->mSwapchain,
-            &surface->mImageCount, surface->mImages);
+    mGetSwapchainImagesKHR(mBackendContext->fDevice, surface->mSwapchain, &surface->mImageCount,
+                           surface->mImages);
 
     SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
 
@@ -303,7 +305,7 @@
     for (uint32_t i = 0; i < surface->mImageCount; ++i) {
         GrVkImageInfo info;
         info.fImage = surface->mImages[i];
-        info.fAlloc = { VK_NULL_HANDLE, 0, 0, 0 };
+        info.fAlloc = {VK_NULL_HANDLE, 0, 0, 0};
         info.fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
         info.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
         info.fFormat = format;
@@ -312,8 +314,8 @@
         GrBackendRenderTarget backendRT(extent.width, extent.height, 0, 0, info);
 
         VulkanSurface::ImageInfo& imageInfo = surface->mImageInfos[i];
-        imageInfo.mSurface = SkSurface::MakeFromBackendRenderTarget(mRenderThread.getGrContext(),
-                backendRT, kTopLeft_GrSurfaceOrigin, nullptr, &props);
+        imageInfo.mSurface = SkSurface::MakeFromBackendRenderTarget(
+                mRenderThread.getGrContext(), backendRT, kTopLeft_GrSurfaceOrigin, nullptr, &props);
     }
 
     SkASSERT(mCommandPool != VK_NULL_HANDLE);
@@ -343,16 +345,16 @@
     for (uint32_t i = 0; i < surface->mImageCount + 1; ++i) {
         SkDEBUGCODE(VkResult res);
         surface->mBackbuffers[i].mImageIndex = -1;
-        SkDEBUGCODE(res = ) mCreateSemaphore(mBackendContext->fDevice, &semaphoreInfo, nullptr,
-                &surface->mBackbuffers[i].mAcquireSemaphore);
-        SkDEBUGCODE(res = ) mCreateSemaphore(mBackendContext->fDevice, &semaphoreInfo, nullptr,
-                &surface->mBackbuffers[i].mRenderSemaphore);
-        SkDEBUGCODE(res = ) mAllocateCommandBuffers(mBackendContext->fDevice, &commandBuffersInfo,
-                surface->mBackbuffers[i].mTransitionCmdBuffers);
-        SkDEBUGCODE(res = ) mCreateFence(mBackendContext->fDevice, &fenceInfo, nullptr,
-                &surface->mBackbuffers[i].mUsageFences[0]);
-        SkDEBUGCODE(res = ) mCreateFence(mBackendContext->fDevice, &fenceInfo, nullptr,
-                &surface->mBackbuffers[i].mUsageFences[1]);
+        SkDEBUGCODE(res =) mCreateSemaphore(mBackendContext->fDevice, &semaphoreInfo, nullptr,
+                                            &surface->mBackbuffers[i].mAcquireSemaphore);
+        SkDEBUGCODE(res =) mCreateSemaphore(mBackendContext->fDevice, &semaphoreInfo, nullptr,
+                                            &surface->mBackbuffers[i].mRenderSemaphore);
+        SkDEBUGCODE(res =) mAllocateCommandBuffers(mBackendContext->fDevice, &commandBuffersInfo,
+                                                   surface->mBackbuffers[i].mTransitionCmdBuffers);
+        SkDEBUGCODE(res =) mCreateFence(mBackendContext->fDevice, &fenceInfo, nullptr,
+                                        &surface->mBackbuffers[i].mUsageFences[0]);
+        SkDEBUGCODE(res =) mCreateFence(mBackendContext->fDevice, &fenceInfo, nullptr,
+                                        &surface->mBackbuffers[i].mUsageFences[1]);
         SkASSERT(VK_SUCCESS == res);
     }
     surface->mCurrentBackbufferIndex = surface->mImageCount;
@@ -362,35 +364,36 @@
     // check for capabilities
     VkSurfaceCapabilitiesKHR caps;
     VkResult res = mGetPhysicalDeviceSurfaceCapabilitiesKHR(mBackendContext->fPhysicalDevice,
-            surface->mVkSurface, &caps);
+                                                            surface->mVkSurface, &caps);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     uint32_t surfaceFormatCount;
     res = mGetPhysicalDeviceSurfaceFormatsKHR(mBackendContext->fPhysicalDevice, surface->mVkSurface,
-            &surfaceFormatCount, nullptr);
+                                              &surfaceFormatCount, nullptr);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     FatVector<VkSurfaceFormatKHR, 4> surfaceFormats(surfaceFormatCount);
     res = mGetPhysicalDeviceSurfaceFormatsKHR(mBackendContext->fPhysicalDevice, surface->mVkSurface,
-            &surfaceFormatCount, surfaceFormats.data());
+                                              &surfaceFormatCount, surfaceFormats.data());
     if (VK_SUCCESS != res) {
         return false;
     }
 
     uint32_t presentModeCount;
     res = mGetPhysicalDeviceSurfacePresentModesKHR(mBackendContext->fPhysicalDevice,
-            surface->mVkSurface, &presentModeCount, nullptr);
+                                                   surface->mVkSurface, &presentModeCount, nullptr);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     FatVector<VkPresentModeKHR, VK_PRESENT_MODE_RANGE_SIZE_KHR> presentModes(presentModeCount);
     res = mGetPhysicalDeviceSurfacePresentModesKHR(mBackendContext->fPhysicalDevice,
-            surface->mVkSurface, &presentModeCount, presentModes.data());
+                                                   surface->mVkSurface, &presentModeCount,
+                                                   presentModes.data());
     if (VK_SUCCESS != res) {
         return false;
     }
@@ -420,12 +423,12 @@
                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     SkASSERT((caps.supportedUsageFlags & usageFlags) == usageFlags);
     SkASSERT(caps.supportedTransforms & caps.currentTransform);
-    SkASSERT(caps.supportedCompositeAlpha & (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
-                                             VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR));
+    SkASSERT(caps.supportedCompositeAlpha &
+             (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR));
     VkCompositeAlphaFlagBitsKHR composite_alpha =
-        (caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) ?
-                                        VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR :
-                                        VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+            (caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR)
+                    ? VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
+                    : VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
 
     // Pick our surface format. For now, just make sure it matches our sRGB request:
     VkFormat surfaceFormat = VK_FORMAT_UNDEFINED;
@@ -470,7 +473,7 @@
     swapchainCreateInfo.imageArrayLayers = 1;
     swapchainCreateInfo.imageUsage = usageFlags;
 
-    uint32_t queueFamilies[] = { mBackendContext->fGraphicsQueueIndex, mPresentQueueIndex };
+    uint32_t queueFamilies[] = {mBackendContext->fGraphicsQueueIndex, mPresentQueueIndex};
     if (mBackendContext->fGraphicsQueueIndex != mPresentQueueIndex) {
         swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
         swapchainCreateInfo.queueFamilyIndexCount = 2;
@@ -488,7 +491,7 @@
     swapchainCreateInfo.oldSwapchain = surface->mSwapchain;
 
     res = mCreateSwapchainKHR(mBackendContext->fDevice, &swapchainCreateInfo, nullptr,
-            &surface->mSwapchain);
+                              &surface->mSwapchain);
     if (VK_SUCCESS != res) {
         return false;
     }
@@ -507,7 +510,6 @@
     return true;
 }
 
-
 VulkanSurface* VulkanManager::createSurface(ANativeWindow* window) {
     initialize();
 
@@ -524,21 +526,20 @@
     surfaceCreateInfo.flags = 0;
     surfaceCreateInfo.window = window;
 
-    VkResult res = mCreateAndroidSurfaceKHR(mBackendContext->fInstance, &surfaceCreateInfo,
-            nullptr, &surface->mVkSurface);
+    VkResult res = mCreateAndroidSurfaceKHR(mBackendContext->fInstance, &surfaceCreateInfo, nullptr,
+                                            &surface->mVkSurface);
     if (VK_SUCCESS != res) {
         delete surface;
         return nullptr;
     }
 
-SkDEBUGCODE(
-    VkBool32 supported;
-    res = mGetPhysicalDeviceSurfaceSupportKHR(mBackendContext->fPhysicalDevice,
-            mPresentQueueIndex, surface->mVkSurface, &supported);
-    // All physical devices and queue families on Android must be capable of presentation with any
-    // native window.
-    SkASSERT(VK_SUCCESS == res && supported);
-);
+    SkDEBUGCODE(VkBool32 supported; res = mGetPhysicalDeviceSurfaceSupportKHR(
+                                            mBackendContext->fPhysicalDevice, mPresentQueueIndex,
+                                            surface->mVkSurface, &supported);
+                // All physical devices and queue families on Android must be capable of
+                // presentation with any
+                // native window.
+                SkASSERT(VK_SUCCESS == res && supported););
 
     if (!createSwapchain(surface)) {
         destroySurface(surface);
@@ -573,11 +574,9 @@
     VkAccessFlags flags = 0;
     if (VK_IMAGE_LAYOUT_GENERAL == layout) {
         flags = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
-                VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
-                VK_ACCESS_TRANSFER_WRITE_BIT |
-                VK_ACCESS_TRANSFER_READ_BIT |
-                VK_ACCESS_SHADER_READ_BIT |
-                VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_HOST_READ_BIT;
+                VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT |
+                VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_HOST_WRITE_BIT |
+                VK_ACCESS_HOST_READ_BIT;
     } else if (VK_IMAGE_LAYOUT_PREINITIALIZED == layout) {
         flags = VK_ACCESS_HOST_WRITE_BIT;
     } else if (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == layout) {
@@ -600,12 +599,12 @@
         mDeviceWaitIdle(mBackendContext->fDevice);
     }
 
-    VulkanSurface::BackbufferInfo* backbuffer = surface->mBackbuffers +
-            surface->mCurrentBackbufferIndex;
+    VulkanSurface::BackbufferInfo* backbuffer =
+            surface->mBackbuffers + surface->mCurrentBackbufferIndex;
     GrVkImageInfo* imageInfo;
     SkSurface* skSurface = surface->mImageInfos[backbuffer->mImageIndex].mSurface.get();
     skSurface->getRenderTargetHandle((GrBackendObject*)&imageInfo,
-            SkSurface::kFlushRead_BackendHandleAccess);
+                                     SkSurface::kFlushRead_BackendHandleAccess);
     // Check to make sure we never change the actually wrapped image
     SkASSERT(imageInfo->fImage == surface->mImages[backbuffer->mImageIndex]);
 
@@ -618,16 +617,16 @@
     VkAccessFlags dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
 
     VkImageMemoryBarrier imageMemoryBarrier = {
-        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,    // sType
-        NULL,                                      // pNext
-        srcAccessMask,                             // outputMask
-        dstAccessMask,                             // inputMask
-        layout,                                    // oldLayout
-        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,           // newLayout
-        mBackendContext->fGraphicsQueueIndex,      // srcQueueFamilyIndex
-        mPresentQueueIndex,                        // dstQueueFamilyIndex
-        surface->mImages[backbuffer->mImageIndex], // image
-        { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }  // subresourceRange
+            VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // sType
+            NULL,                                       // pNext
+            srcAccessMask,                              // outputMask
+            dstAccessMask,                              // inputMask
+            layout,                                     // oldLayout
+            VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,            // newLayout
+            mBackendContext->fGraphicsQueueIndex,       // srcQueueFamilyIndex
+            mPresentQueueIndex,                         // dstQueueFamilyIndex
+            surface->mImages[backbuffer->mImageIndex],  // image
+            {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}     // subresourceRange
     };
 
     mResetCommandBuffer(backbuffer->mTransitionCmdBuffers[1], 0);
@@ -636,8 +635,8 @@
     info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.flags = 0;
     mBeginCommandBuffer(backbuffer->mTransitionCmdBuffers[1], &info);
-    mCmdPipelineBarrier(backbuffer->mTransitionCmdBuffers[1], srcStageMask, dstStageMask, 0,
-            0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
+    mCmdPipelineBarrier(backbuffer->mTransitionCmdBuffers[1], srcStageMask, dstStageMask, 0, 0,
+                        nullptr, 0, nullptr, 1, &imageMemoryBarrier);
     mEndCommandBuffer(backbuffer->mTransitionCmdBuffers[1]);
 
     surface->mImageInfos[backbuffer->mImageIndex].mImageLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
@@ -661,16 +660,15 @@
     // Submit present operation to present queue. We use a semaphore here to make sure all rendering
     // to the image is complete and that the layout has been change to present on the graphics
     // queue.
-    const VkPresentInfoKHR presentInfo =
-    {
-        VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, // sType
-        NULL, // pNext
-        1, // waitSemaphoreCount
-        &backbuffer->mRenderSemaphore, // pWaitSemaphores
-        1, // swapchainCount
-        &surface->mSwapchain, // pSwapchains
-        &backbuffer->mImageIndex, // pImageIndices
-        NULL // pResults
+    const VkPresentInfoKHR presentInfo = {
+            VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,  // sType
+            NULL,                                // pNext
+            1,                                   // waitSemaphoreCount
+            &backbuffer->mRenderSemaphore,       // pWaitSemaphores
+            1,                                   // swapchainCount
+            &surface->mSwapchain,                // pSwapchains
+            &backbuffer->mImageIndex,            // pImageIndices
+            NULL                                 // pResults
     };
 
     mQueuePresentKHR(mPresentQueue, &presentInfo);
@@ -682,10 +680,10 @@
 }
 
 int VulkanManager::getAge(VulkanSurface* surface) {
-    VulkanSurface::BackbufferInfo* backbuffer = surface->mBackbuffers +
-            surface->mCurrentBackbufferIndex;
-    if (mSwapBehavior == SwapBehavior::Discard
-            || surface->mImageInfos[backbuffer->mImageIndex].mInvalid) {
+    VulkanSurface::BackbufferInfo* backbuffer =
+            surface->mBackbuffers + surface->mCurrentBackbufferIndex;
+    if (mSwapBehavior == SwapBehavior::Discard ||
+        surface->mImageInfos[backbuffer->mImageIndex].mInvalid) {
         return 0;
     }
     uint16_t lastUsed = surface->mImageInfos[backbuffer->mImageIndex].mLastUsed;
diff --git a/libs/hwui/renderthread/VulkanManager.h b/libs/hwui/renderthread/VulkanManager.h
index d225b3f..b9898a7 100644
--- a/libs/hwui/renderthread/VulkanManager.h
+++ b/libs/hwui/renderthread/VulkanManager.h
@@ -37,13 +37,14 @@
 private:
     friend class VulkanManager;
     struct BackbufferInfo {
-        uint32_t        mImageIndex;          // image this is associated with
-        VkSemaphore     mAcquireSemaphore;    // we signal on this for acquisition of image
-        VkSemaphore     mRenderSemaphore;     // we wait on this for rendering to be done
-        VkCommandBuffer mTransitionCmdBuffers[2]; // to transition layout between present and render
+        uint32_t mImageIndex;           // image this is associated with
+        VkSemaphore mAcquireSemaphore;  // we signal on this for acquisition of image
+        VkSemaphore mRenderSemaphore;   // we wait on this for rendering to be done
+        VkCommandBuffer
+                mTransitionCmdBuffers[2];  // to transition layout between present and render
         // We use these fences to make sure the above Command buffers have finished their work
         // before attempting to reuse them or destroy them.
-        VkFence         mUsageFences[2];
+        VkFence mUsageFences[2];
     };
 
     struct ImageInfo {
@@ -118,11 +119,16 @@
     VulkanSurface::BackbufferInfo* getAvailableBackbuffer(VulkanSurface* surface);
 
     // simple wrapper class that exists only to initialize a pointer to NULL
-    template <typename FNPTR_TYPE> class VkPtr {
+    template <typename FNPTR_TYPE>
+    class VkPtr {
     public:
         VkPtr() : fPtr(NULL) {}
-        VkPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
+        VkPtr operator=(FNPTR_TYPE ptr) {
+            fPtr = ptr;
+            return *this;
+        }
         operator FNPTR_TYPE() const { return fPtr; }
+
     private:
         FNPTR_TYPE fPtr;
     };
@@ -183,4 +189,3 @@
 } /* namespace android */
 
 #endif /* VULKANMANAGER_H */
-