Make Function's constructor and bindInternal() private

third_party/WebKit/Source/wtf/Functional.h

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 221 matching lines @@
 }
 
 template<typename Signature, FunctionThreadAffinity threadAffinity = SameThreadAffinity>
 class Function;
 
 template<typename R, typename... Args, FunctionThreadAffinity threadAffinity>
 class Function<R(Args...), threadAffinity> {
     USING_FAST_MALLOC(Function);
     WTF_MAKE_NONCOPYABLE(Function);
 public:
-    Function(base::Callback<R(Args...)> callback)
-        : m_callback(std::move(callback)) { }
-
     ~Function()
     {
         DCHECK(m_threadChecker.CalledOnValidThread());
     }
 
     R operator()(Args... args)
     {
         DCHECK(m_threadChecker.CalledOnValidThread());
         return m_callback.Run(std::forward<Args>(args)...);
     }
 
     explicit operator base::Callback<R(Args...)>()
     {
         return m_callback;
     }
 
 private:
+    Function(base::Callback<R(Args...)> callback)
+        : m_callback(std::move(callback)) { }
+
+    template <typename FunctionType, typename... BoundParameters>
+    static std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, threadAffinity>> bindInternal(FunctionType function, BoundParameters&&... boundParameters)
+    {
+        using UnboundRunType = base::MakeUnboundRunType<FunctionType, BoundParameters...>;
+        return wrapUnique(new Function<UnboundRunType, threadAffinity>(base::Bind(function, typename ParamStorageTraits<typename std::decay<BoundParameters>::type>::StorageType(std::forward<BoundParameters>(boundParameters))...)));
+    }
+
+    template <typename FunctionType, typename... BoundParameters>
+    friend std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, SameThreadAffinity>> bind(FunctionType, BoundParameters&&...);
+
+    template <typename FunctionType, typename... BoundParameters>
+    friend std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, CrossThreadAffinity>> crossThreadBind(FunctionType, BoundParameters&&...);
+
     using MaybeThreadChecker = typename std::conditional<
         threadAffinity == SameThreadAffinity,
         base::ThreadChecker,
         base::ThreadCheckerDoNothing>::type;
     MaybeThreadChecker m_threadChecker;
     base::Callback<R(Args...)> m_callback;
 };
 
-template <FunctionThreadAffinity threadAffinity, typename FunctionType, typename... BoundParameters>
-std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, threadAffinity>> bindInternal(FunctionType function, BoundParameters&&... boundParameters)
-{
-    using UnboundRunType = base::MakeUnboundRunType<FunctionType, BoundParameters...>;
-    return wrapUnique(new Function<UnboundRunType, threadAffinity>(base::Bind(function, typename ParamStorageTraits<typename std::decay<BoundParameters>::type>::StorageType(std::forward<BoundParameters>(boundParameters))...)));
-}
-
 template <typename FunctionType, typename... BoundParameters>
 std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, SameThreadAffinity>> bind(FunctionType function, BoundParameters&&... boundParameters)
 {
-    return bindInternal<SameThreadAffinity>(function, std::forward<BoundParameters>(boundParameters)...);
+    return Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, SameThreadAffinity>::bindInternal(function, std::forward<BoundParameters>(boundParameters)...);
 }
 
 template <typename FunctionType, typename... BoundParameters>
 std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, CrossThreadAffinity>> crossThreadBind(FunctionType function, BoundParameters&&... boundParameters)
 {
-    return bindInternal<CrossThreadAffinity>(function, CrossThreadCopier<typename std::decay<BoundParameters>::type>::copy(std::forward<BoundParameters>(boundParameters))...);
+    return Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, CrossThreadAffinity>::bindInternal(function, CrossThreadCopier<typename std::decay<BoundParameters>::type>::copy(std::forward<BoundParameters>(boundParameters))...);
 }
 
 typedef Function<void(), SameThreadAffinity> Closure;
 typedef Function<void(), CrossThreadAffinity> CrossThreadClosure;
 
 } // namespace WTF
 
 using WTF::crossThreadBind;
 
 using WTF::passed;
 using WTF::unretained;
 using WTF::crossThreadUnretained;
 
 using WTF::Function;
 using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h