Devirtualize base::BindState to save ~1% of Chrome's binary size (~1MB)

base/bind_internal.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
 #include "base/bind_helpers.h"
 #include "base/callback_internal.h"
 #include "base/memory/raw_scoped_refptr_mismatch_checker.h"
@@ skipping 346 matching lines @@
 // RunType is type of the Run() function that the Invoker<> should use.
 // Normally, this is the same as the RunType of the Runnable, but it can
 // be different if an adapter like IgnoreResult() has been used.
 //
 // BoundArgsType contains the storage type for all the bound arguments by
 // (ab)using a function type.
 template <typename Runnable, typename RunType, typename BoundArgList>
 struct BindState;
 
 template <typename Runnable,
-          typename R, typename... Args,
+          typename R,
+          typename... Args,
           typename... BoundArgs>
-struct BindState<Runnable, R(Args...), TypeList<BoundArgs...>>
+struct BindState<Runnable, R(Args...), TypeList<BoundArgs...>> final
     : public BindStateBase {
  private:
   using StorageType = BindState<Runnable, R(Args...), TypeList<BoundArgs...>>;
   using RunnableType = Runnable;
 
   // true_type if Runnable is a method invocation and the first bound argument
   // is a WeakPtr.
   using IsWeakCall =
       IsWeakMethod<HasIsMethodTag<Runnable>::value, BoundArgs...>;
 
@@ skipping 11 matching lines @@
       InvokeHelper<IsWeakCall::value, R, Runnable, InvokeHelperArgs>;
 
   using UnboundArgs = DropTypeListItem<sizeof...(BoundArgs), TypeList<Args...>>;
 
  public:
   using InvokerType = Invoker<BoundIndices, StorageType, Unwrappers,
                               InvokeHelperType, UnboundForwardRunType>;
   using UnboundRunType = MakeFunctionType<R, UnboundArgs>;
 
   BindState(const Runnable& runnable, const BoundArgs&... bound_args)
-      : runnable_(runnable), ref_(bound_args...), bound_args_(bound_args...) {}
+      : BindStateBase(&Destroy),
+        runnable_(runnable),
+        ref_(bound_args...),
+        bound_args_(bound_args...) {}
 
   RunnableType runnable_;
   MaybeScopedRefPtr<HasIsMethodTag<Runnable>::value, BoundArgs...> ref_;
   Tuple<BoundArgs...> bound_args_;
 
  private:
-  ~BindState() override {}
+  ~BindState() {}
+
+  static void Destroy(BindStateBase* self) {
+    delete static_cast<BindState*>(self);
+  }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_