wtf reformat test

third_party/WebKit/Source/wtf/Functional.h

Index: third_party/WebKit/Source/wtf/Functional.h
diff --git a/third_party/WebKit/Source/wtf/Functional.h b/third_party/WebKit/Source/wtf/Functional.h
index 16644a18d151acad5c5e97ee46d4fb9e40660da4..2d8f2caf2375980c70a8c05f8653e7a833f6cd63 100644
--- a/third_party/WebKit/Source/wtf/Functional.h
+++ b/third_party/WebKit/Source/wtf/Functional.h
@@ -44,320 +44,417 @@ namespace WTF {
 
 // A FunctionWrapper is a class template that can wrap a function pointer or a member function pointer and
 // provide a unified interface for calling that function.
-template<typename>
+template <typename>
 class FunctionWrapper;
 
 // Bound static functions:
-template<typename R, typename... Params>
-class FunctionWrapper<R(*)(Params...)> {
-    DISALLOW_NEW();
-public:
-    typedef R ResultType;
-
-    explicit FunctionWrapper(R(*function)(Params...))
-        : m_function(function)
-    {
-    }
-
-    R operator()(Params... params)
-    {
-        return m_function(params...);
-    }
-
-private:
-    R(*m_function)(Params...);
+template <typename R, typename... Params>
+class FunctionWrapper<R (*)(Params...)> {
+  DISALLOW_NEW();
+
+ public:
+  typedef R ResultType;
+
+  explicit FunctionWrapper(R (*function)(Params...)) : m_function(function) {}
+
+  R operator()(Params... params) { return m_function(params...); }
+
+ private:
+  R (*m_function)(Params...);
 };
 
 // Bound member functions:
 
-template<typename R, typename C, typename... Params>
-class FunctionWrapper<R(C::*)(Params...)> {
-    DISALLOW_NEW();
-public:
-    typedef R ResultType;
-
-    explicit FunctionWrapper(R(C::*function)(Params...))
-        : m_function(function)
-    {
-    }
-
-    R operator()(C* c, Params... params)
-    {
-        return (c->*m_function)(params...);
-    }
-
-    R operator()(PassOwnPtr<C> c, Params... params)
-    {
-        return (c.get()->*m_function)(params...);
-    }
-
-    R operator()(const WeakPtr<C>& c, Params... params)
-    {
-        C* obj = c.get();
-        if (!obj)
-            return R();
-        return (obj->*m_function)(params...);
-    }
-
-private:
-    R(C::*m_function)(Params...);
+template <typename R, typename C, typename... Params>
+class FunctionWrapper<R (C::*)(Params...)> {
+  DISALLOW_NEW();
+
+ public:
+  typedef R ResultType;
+
+  explicit FunctionWrapper(R (C::*function)(Params...))
+      : m_function(function) {}
+
+  R operator()(C* c, Params... params) { return (c->*m_function)(params...); }
+
+  R operator()(PassOwnPtr<C> c, Params... params) {
+    return (c.get()->*m_function)(params...);
+  }
+
+  R operator()(const WeakPtr<C>& c, Params... params) {
+    C* obj = c.get();
+    if (!obj)
+      return R();
+    return (obj->*m_function)(params...);
+  }
+
+ private:
+  R (C::*m_function)(Params...);
 };
 
-template<typename T> struct ParamStorageTraits {
-    typedef T StorageType;
+template <typename T>
+struct ParamStorageTraits {
+  typedef T StorageType;
 
-    static StorageType wrap(const T& value) { return value; }
-    static const T& unwrap(const StorageType& value) { return value; }
+  static StorageType wrap(const T& value) { return value; }
+  static const T& unwrap(const StorageType& value) { return value; }
 };
 
-template<typename T> struct ParamStorageTraits<PassRefPtr<T>> {
-    typedef RefPtr<T> StorageType;
+template <typename T>
+struct ParamStorageTraits<PassRefPtr<T>> {
+  typedef RefPtr<T> StorageType;
 
-    static StorageType wrap(PassRefPtr<T> value) { return value; }
-    static T* unwrap(const StorageType& value) { return value.get(); }
+  static StorageType wrap(PassRefPtr<T> value) { return value; }
+  static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
-template<typename T> struct ParamStorageTraits<RefPtr<T>> {
-    typedef RefPtr<T> StorageType;
+template <typename T>
+struct ParamStorageTraits<RefPtr<T>> {
+  typedef RefPtr<T> StorageType;
 
-    static StorageType wrap(RefPtr<T> value) { return value.release(); }
-    static T* unwrap(const StorageType& value) { return value.get(); }
+  static StorageType wrap(RefPtr<T> value) { return value.release(); }
+  static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
-template<typename> class RetainPtr;
+template <typename>
+class RetainPtr;
 
-template<typename T> struct ParamStorageTraits<RetainPtr<T>> {
-    typedef RetainPtr<T> StorageType;
+template <typename T>
+struct ParamStorageTraits<RetainPtr<T>> {
+  typedef RetainPtr<T> StorageType;
 
-    static StorageType wrap(const RetainPtr<T>& value) { return value; }
-    static typename RetainPtr<T>::PtrType unwrap(const StorageType& value) { return value.get(); }
+  static StorageType wrap(const RetainPtr<T>& value) { return value; }
+  static typename RetainPtr<T>::PtrType unwrap(const StorageType& value) {
+    return value.get();
+  }
 };
 
-template<typename>
+template <typename>
 class Function;
 
-template<typename R, typename... Args>
+template <typename R, typename... Args>
 class Function<R(Args...)> {
-    USING_FAST_MALLOC(Function);
-    WTF_MAKE_NONCOPYABLE(Function);
-public:
-    virtual ~Function() { }
-    virtual R operator()(Args... args) = 0;
-protected:
-    Function() = default;
+  USING_FAST_MALLOC(Function);
+  WTF_MAKE_NONCOPYABLE(Function);
+
+ public:
+  virtual ~Function() {}
+  virtual R operator()(Args... args) = 0;
+
+ protected:
+  Function() = default;
 };
 
-template<int boundArgsCount, typename FunctionWrapper, typename FunctionType>
+template <int boundArgsCount, typename FunctionWrapper, typename FunctionType>
 class PartBoundFunctionImpl;
 
 // Specialization for unbound functions.
-template<typename FunctionWrapper, typename R, typename... UnboundParams>
-class PartBoundFunctionImpl<0, FunctionWrapper, R(UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper)
-        : m_functionWrapper(functionWrapper)
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
+template <typename FunctionWrapper, typename R, typename... UnboundParams>
+class PartBoundFunctionImpl<0, FunctionWrapper, R(UnboundParams...)> final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper)
+      : m_functionWrapper(functionWrapper) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
 };
 
-template<typename FunctionWrapper, typename R, typename P1, typename... UnboundParams>
-class PartBoundFunctionImpl<1, FunctionWrapper, R(P1, UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1)
-        : m_functionWrapper(functionWrapper)
-        , m_p1(ParamStorageTraits<P1>::wrap(p1))
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
-    typename ParamStorageTraits<P1>::StorageType m_p1;
+template <typename FunctionWrapper,
+          typename R,
+          typename P1,
+          typename... UnboundParams>
+class PartBoundFunctionImpl<1, FunctionWrapper, R(P1, UnboundParams...)> final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1)
+      : m_functionWrapper(functionWrapper),
+        m_p1(ParamStorageTraits<P1>::wrap(p1)) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
+  typename ParamStorageTraits<P1>::StorageType m_p1;
 };
 
-template<typename FunctionWrapper, typename R, typename P1, typename P2, typename... UnboundParams>
-class PartBoundFunctionImpl<2, FunctionWrapper, R(P1, P2, UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1, const P2& p2)
-        : m_functionWrapper(functionWrapper)
-        , m_p1(ParamStorageTraits<P1>::wrap(p1))
-        , m_p2(ParamStorageTraits<P2>::wrap(p2))
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), ParamStorageTraits<P2>::unwrap(m_p2), params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
-    typename ParamStorageTraits<P1>::StorageType m_p1;
-    typename ParamStorageTraits<P2>::StorageType m_p2;
+template <typename FunctionWrapper,
+          typename R,
+          typename P1,
+          typename P2,
+          typename... UnboundParams>
+class PartBoundFunctionImpl<2, FunctionWrapper, R(P1, P2, UnboundParams...)>
+    final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper,
+                        const P1& p1,
+                        const P2& p2)
+      : m_functionWrapper(functionWrapper),
+        m_p1(ParamStorageTraits<P1>::wrap(p1)),
+        m_p2(ParamStorageTraits<P2>::wrap(p2)) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1),
+                             ParamStorageTraits<P2>::unwrap(m_p2), params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
+  typename ParamStorageTraits<P1>::StorageType m_p1;
+  typename ParamStorageTraits<P2>::StorageType m_p2;
 };
 
-template<typename FunctionWrapper, typename R, typename P1, typename P2, typename P3, typename... UnboundParams>
-class PartBoundFunctionImpl<3, FunctionWrapper, R(P1, P2, P3, UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1, const P2& p2, const P3& p3)
-        : m_functionWrapper(functionWrapper)
-        , m_p1(ParamStorageTraits<P1>::wrap(p1))
-        , m_p2(ParamStorageTraits<P2>::wrap(p2))
-        , m_p3(ParamStorageTraits<P3>::wrap(p3))
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), ParamStorageTraits<P2>::unwrap(m_p2), ParamStorageTraits<P3>::unwrap(m_p3), params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
-    typename ParamStorageTraits<P1>::StorageType m_p1;
-    typename ParamStorageTraits<P2>::StorageType m_p2;
-    typename ParamStorageTraits<P3>::StorageType m_p3;
+template <typename FunctionWrapper,
+          typename R,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename... UnboundParams>
+class PartBoundFunctionImpl<3, FunctionWrapper, R(P1, P2, P3, UnboundParams...)>
+    final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper,
+                        const P1& p1,
+                        const P2& p2,
+                        const P3& p3)
+      : m_functionWrapper(functionWrapper),
+        m_p1(ParamStorageTraits<P1>::wrap(p1)),
+        m_p2(ParamStorageTraits<P2>::wrap(p2)),
+        m_p3(ParamStorageTraits<P3>::wrap(p3)) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1),
+                             ParamStorageTraits<P2>::unwrap(m_p2),
+                             ParamStorageTraits<P3>::unwrap(m_p3), params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
+  typename ParamStorageTraits<P1>::StorageType m_p1;
+  typename ParamStorageTraits<P2>::StorageType m_p2;
+  typename ParamStorageTraits<P3>::StorageType m_p3;
 };
 
-template<typename FunctionWrapper, typename R, typename P1, typename P2, typename P3, typename P4, typename... UnboundParams>
-class PartBoundFunctionImpl<4, FunctionWrapper, R(P1, P2, P3, P4, UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1, const P2& p2, const P3& p3, const P4& p4)
-        : m_functionWrapper(functionWrapper)
-        , m_p1(ParamStorageTraits<P1>::wrap(p1))
-        , m_p2(ParamStorageTraits<P2>::wrap(p2))
-        , m_p3(ParamStorageTraits<P3>::wrap(p3))
-        , m_p4(ParamStorageTraits<P4>::wrap(p4))
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), ParamStorageTraits<P2>::unwrap(m_p2), ParamStorageTraits<P3>::unwrap(m_p3), ParamStorageTraits<P4>::unwrap(m_p4), params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
-    typename ParamStorageTraits<P1>::StorageType m_p1;
-    typename ParamStorageTraits<P2>::StorageType m_p2;
-    typename ParamStorageTraits<P3>::StorageType m_p3;
-    typename ParamStorageTraits<P4>::StorageType m_p4;
+template <typename FunctionWrapper,
+          typename R,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename P4,
+          typename... UnboundParams>
+class PartBoundFunctionImpl<4,
+                            FunctionWrapper,
+                            R(P1, P2, P3, P4, UnboundParams...)>
+    final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper,
+                        const P1& p1,
+                        const P2& p2,
+                        const P3& p3,
+                        const P4& p4)
+      : m_functionWrapper(functionWrapper),
+        m_p1(ParamStorageTraits<P1>::wrap(p1)),
+        m_p2(ParamStorageTraits<P2>::wrap(p2)),
+        m_p3(ParamStorageTraits<P3>::wrap(p3)),
+        m_p4(ParamStorageTraits<P4>::wrap(p4)) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1),
+                             ParamStorageTraits<P2>::unwrap(m_p2),
+                             ParamStorageTraits<P3>::unwrap(m_p3),
+                             ParamStorageTraits<P4>::unwrap(m_p4), params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
+  typename ParamStorageTraits<P1>::StorageType m_p1;
+  typename ParamStorageTraits<P2>::StorageType m_p2;
+  typename ParamStorageTraits<P3>::StorageType m_p3;
+  typename ParamStorageTraits<P4>::StorageType m_p4;
 };
 
-template<typename FunctionWrapper, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename... UnboundParams>
-class PartBoundFunctionImpl<5, FunctionWrapper, R(P1, P2, P3, P4, P5, UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5)
-        : m_functionWrapper(functionWrapper)
-        , m_p1(ParamStorageTraits<P1>::wrap(p1))
-        , m_p2(ParamStorageTraits<P2>::wrap(p2))
-        , m_p3(ParamStorageTraits<P3>::wrap(p3))
-        , m_p4(ParamStorageTraits<P4>::wrap(p4))
-        , m_p5(ParamStorageTraits<P5>::wrap(p5))
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), ParamStorageTraits<P2>::unwrap(m_p2), ParamStorageTraits<P3>::unwrap(m_p3), ParamStorageTraits<P4>::unwrap(m_p4), ParamStorageTraits<P5>::unwrap(m_p5), params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
-    typename ParamStorageTraits<P1>::StorageType m_p1;
-    typename ParamStorageTraits<P2>::StorageType m_p2;
-    typename ParamStorageTraits<P3>::StorageType m_p3;
-    typename ParamStorageTraits<P4>::StorageType m_p4;
-    typename ParamStorageTraits<P5>::StorageType m_p5;
+template <typename FunctionWrapper,
+          typename R,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename P4,
+          typename P5,
+          typename... UnboundParams>
+class PartBoundFunctionImpl<5,
+                            FunctionWrapper,
+                            R(P1, P2, P3, P4, P5, UnboundParams...)>
+    final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper,
+                        const P1& p1,
+                        const P2& p2,
+                        const P3& p3,
+                        const P4& p4,
+                        const P5& p5)
+      : m_functionWrapper(functionWrapper),
+        m_p1(ParamStorageTraits<P1>::wrap(p1)),
+        m_p2(ParamStorageTraits<P2>::wrap(p2)),
+        m_p3(ParamStorageTraits<P3>::wrap(p3)),
+        m_p4(ParamStorageTraits<P4>::wrap(p4)),
+        m_p5(ParamStorageTraits<P5>::wrap(p5)) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1),
+                             ParamStorageTraits<P2>::unwrap(m_p2),
+                             ParamStorageTraits<P3>::unwrap(m_p3),
+                             ParamStorageTraits<P4>::unwrap(m_p4),
+                             ParamStorageTraits<P5>::unwrap(m_p5), params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
+  typename ParamStorageTraits<P1>::StorageType m_p1;
+  typename ParamStorageTraits<P2>::StorageType m_p2;
+  typename ParamStorageTraits<P3>::StorageType m_p3;
+  typename ParamStorageTraits<P4>::StorageType m_p4;
+  typename ParamStorageTraits<P5>::StorageType m_p5;
 };
 
-template<typename FunctionWrapper, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename... UnboundParams>
-class PartBoundFunctionImpl<6, FunctionWrapper, R(P1, P2, P3, P4, P5, P6, UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6)
-        : m_functionWrapper(functionWrapper)
-        , m_p1(ParamStorageTraits<P1>::wrap(p1))
-        , m_p2(ParamStorageTraits<P2>::wrap(p2))
-        , m_p3(ParamStorageTraits<P3>::wrap(p3))
-        , m_p4(ParamStorageTraits<P4>::wrap(p4))
-        , m_p5(ParamStorageTraits<P5>::wrap(p5))
-        , m_p6(ParamStorageTraits<P6>::wrap(p6))
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), ParamStorageTraits<P2>::unwrap(m_p2), ParamStorageTraits<P3>::unwrap(m_p3), ParamStorageTraits<P4>::unwrap(m_p4), ParamStorageTraits<P5>::unwrap(m_p5), ParamStorageTraits<P6>::unwrap(m_p6), params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
-    typename ParamStorageTraits<P1>::StorageType m_p1;
-    typename ParamStorageTraits<P2>::StorageType m_p2;
-    typename ParamStorageTraits<P3>::StorageType m_p3;
-    typename ParamStorageTraits<P4>::StorageType m_p4;
-    typename ParamStorageTraits<P5>::StorageType m_p5;
-    typename ParamStorageTraits<P6>::StorageType m_p6;
+template <typename FunctionWrapper,
+          typename R,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename P4,
+          typename P5,
+          typename P6,
+          typename... UnboundParams>
+class PartBoundFunctionImpl<6,
+                            FunctionWrapper,
+                            R(P1, P2, P3, P4, P5, P6, UnboundParams...)>
+    final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper,
+                        const P1& p1,
+                        const P2& p2,
+                        const P3& p3,
+                        const P4& p4,
+                        const P5& p5,
+                        const P6& p6)
+      : m_functionWrapper(functionWrapper),
+        m_p1(ParamStorageTraits<P1>::wrap(p1)),
+        m_p2(ParamStorageTraits<P2>::wrap(p2)),
+        m_p3(ParamStorageTraits<P3>::wrap(p3)),
+        m_p4(ParamStorageTraits<P4>::wrap(p4)),
+        m_p5(ParamStorageTraits<P5>::wrap(p5)),
+        m_p6(ParamStorageTraits<P6>::wrap(p6)) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1),
+                             ParamStorageTraits<P2>::unwrap(m_p2),
+                             ParamStorageTraits<P3>::unwrap(m_p3),
+                             ParamStorageTraits<P4>::unwrap(m_p4),
+                             ParamStorageTraits<P5>::unwrap(m_p5),
+                             ParamStorageTraits<P6>::unwrap(m_p6), params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
+  typename ParamStorageTraits<P1>::StorageType m_p1;
+  typename ParamStorageTraits<P2>::StorageType m_p2;
+  typename ParamStorageTraits<P3>::StorageType m_p3;
+  typename ParamStorageTraits<P4>::StorageType m_p4;
+  typename ParamStorageTraits<P5>::StorageType m_p5;
+  typename ParamStorageTraits<P6>::StorageType m_p6;
 };
 
-template<typename FunctionWrapper, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename... UnboundParams>
-class PartBoundFunctionImpl<7, FunctionWrapper, R(P1, P2, P3, P4, P5, P6, P7, UnboundParams...)> final : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
-public:
-    PartBoundFunctionImpl(FunctionWrapper functionWrapper, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7)
-        : m_functionWrapper(functionWrapper)
-        , m_p1(ParamStorageTraits<P1>::wrap(p1))
-        , m_p2(ParamStorageTraits<P2>::wrap(p2))
-        , m_p3(ParamStorageTraits<P3>::wrap(p3))
-        , m_p4(ParamStorageTraits<P4>::wrap(p4))
-        , m_p5(ParamStorageTraits<P5>::wrap(p5))
-        , m_p6(ParamStorageTraits<P6>::wrap(p6))
-        , m_p7(ParamStorageTraits<P7>::wrap(p7))
-    {
-    }
-
-    typename FunctionWrapper::ResultType operator()(UnboundParams... params) override
-    {
-        return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1), ParamStorageTraits<P2>::unwrap(m_p2), ParamStorageTraits<P3>::unwrap(m_p3), ParamStorageTraits<P4>::unwrap(m_p4), ParamStorageTraits<P5>::unwrap(m_p5), ParamStorageTraits<P6>::unwrap(m_p6), ParamStorageTraits<P7>::unwrap(m_p7), params...);
-    }
-
-private:
-    FunctionWrapper m_functionWrapper;
-    typename ParamStorageTraits<P1>::StorageType m_p1;
-    typename ParamStorageTraits<P2>::StorageType m_p2;
-    typename ParamStorageTraits<P3>::StorageType m_p3;
-    typename ParamStorageTraits<P4>::StorageType m_p4;
-    typename ParamStorageTraits<P5>::StorageType m_p5;
-    typename ParamStorageTraits<P6>::StorageType m_p6;
-    typename ParamStorageTraits<P7>::StorageType m_p7;
+template <typename FunctionWrapper,
+          typename R,
+          typename P1,
+          typename P2,
+          typename P3,
+          typename P4,
+          typename P5,
+          typename P6,
+          typename P7,
+          typename... UnboundParams>
+class PartBoundFunctionImpl<7,
+                            FunctionWrapper,
+                            R(P1, P2, P3, P4, P5, P6, P7, UnboundParams...)>
+    final
+    : public Function<typename FunctionWrapper::ResultType(UnboundParams...)> {
+ public:
+  PartBoundFunctionImpl(FunctionWrapper functionWrapper,
+                        const P1& p1,
+                        const P2& p2,
+                        const P3& p3,
+                        const P4& p4,
+                        const P5& p5,
+                        const P6& p6,
+                        const P7& p7)
+      : m_functionWrapper(functionWrapper),
+        m_p1(ParamStorageTraits<P1>::wrap(p1)),
+        m_p2(ParamStorageTraits<P2>::wrap(p2)),
+        m_p3(ParamStorageTraits<P3>::wrap(p3)),
+        m_p4(ParamStorageTraits<P4>::wrap(p4)),
+        m_p5(ParamStorageTraits<P5>::wrap(p5)),
+        m_p6(ParamStorageTraits<P6>::wrap(p6)),
+        m_p7(ParamStorageTraits<P7>::wrap(p7)) {}
+
+  typename FunctionWrapper::ResultType operator()(
+      UnboundParams... params) override {
+    return m_functionWrapper(ParamStorageTraits<P1>::unwrap(m_p1),
+                             ParamStorageTraits<P2>::unwrap(m_p2),
+                             ParamStorageTraits<P3>::unwrap(m_p3),
+                             ParamStorageTraits<P4>::unwrap(m_p4),
+                             ParamStorageTraits<P5>::unwrap(m_p5),
+                             ParamStorageTraits<P6>::unwrap(m_p6),
+                             ParamStorageTraits<P7>::unwrap(m_p7), params...);
+  }
+
+ private:
+  FunctionWrapper m_functionWrapper;
+  typename ParamStorageTraits<P1>::StorageType m_p1;
+  typename ParamStorageTraits<P2>::StorageType m_p2;
+  typename ParamStorageTraits<P3>::StorageType m_p3;
+  typename ParamStorageTraits<P4>::StorageType m_p4;
+  typename ParamStorageTraits<P5>::StorageType m_p5;
+  typename ParamStorageTraits<P6>::StorageType m_p6;
+  typename ParamStorageTraits<P7>::StorageType m_p7;
 };
 
-
-template<typename... UnboundArgs, typename FunctionType, typename... BoundArgs>
-PassOwnPtr<Function<typename FunctionWrapper<FunctionType>::ResultType(UnboundArgs...)>> bind(FunctionType function, const BoundArgs&... boundArgs)
-{
-    const int boundArgsCount = sizeof...(BoundArgs);
-    using BoundFunctionType = PartBoundFunctionImpl<boundArgsCount, FunctionWrapper<FunctionType>, typename FunctionWrapper<FunctionType>::ResultType(BoundArgs..., UnboundArgs...)>;
-    return adoptPtr(new BoundFunctionType(FunctionWrapper<FunctionType>(function), boundArgs...));
+template <typename... UnboundArgs, typename FunctionType, typename... BoundArgs>
+PassOwnPtr<Function<
+    typename FunctionWrapper<FunctionType>::ResultType(UnboundArgs...)>>
+bind(FunctionType function, const BoundArgs&... boundArgs) {
+  const int boundArgsCount = sizeof...(BoundArgs);
+  using BoundFunctionType =
+      PartBoundFunctionImpl<boundArgsCount, FunctionWrapper<FunctionType>,
+                            typename FunctionWrapper<FunctionType>::ResultType(
+                                BoundArgs..., UnboundArgs...)>;
+  return adoptPtr(new BoundFunctionType(FunctionWrapper<FunctionType>(function),
+                                        boundArgs...));
 }
 
 typedef Function<void()> Closure;
-
 }
 
 using WTF::Function;
 using WTF::bind;
 using WTF::Closure;
 
-#endif // WTF_Functional_h
+#endif  // WTF_Functional_h