Pass bound values as const values to the bound function

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 <stddef.h>
 
 #include <tuple>
@@ skipping 138 matching lines @@
  public:
   // MSVC 2013 doesn't support Type Alias of function types.
   // Revisit this after we update it to newer version.
   typedef R RunType(Args...);
 
   explicit RunnableAdapter(R(*function)(Args...))
       : function_(function) {
   }
 
   template <typename... RunArgs>
-  R Run(RunArgs&&... args) {
+  R Run(RunArgs&&... args) const {
     return function_(std::forward<RunArgs>(args)...);
   }
 
  private:
   R (*function_)(Args...);
 };
 
 // Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...)> {
  public:
   // MSVC 2013 doesn't support Type Alias of function types.
   // Revisit this after we update it to newer version.
   typedef R RunType(T*, Args...);
   using IsMethod = std::true_type;
 
   explicit RunnableAdapter(R(T::*method)(Args...))
       : method_(method) {
   }
 
   template <typename Receiver, typename... RunArgs>
-  R Run(Receiver&& receiver_ptr, RunArgs&&... args) {
+  R Run(Receiver&& receiver_ptr, RunArgs&&... args) const {
     // Clang skips CV qualifier check on a method pointer invocation when the
     // receiver is a subclass. Store the receiver into a const reference to
     // T to ensure the CV check works.
     // https://llvm.org/bugs/show_bug.cgi?id=27037
     T& receiver = *receiver_ptr;
     return (receiver.*method_)(std::forward<RunArgs>(args)...);
   }
 
  private:
   R (T::*method_)(Args...);
 };
 
 // Const Method.
 template <typename R, typename T, typename... Args>
 class RunnableAdapter<R(T::*)(Args...) const> {
  public:
   using RunType = R(const T*, Args...);
   using IsMethod = std::true_type;
 
   explicit RunnableAdapter(R(T::*method)(Args...) const)
       : method_(method) {
   }
 
   template <typename Receiver, typename... RunArgs>
-  R Run(Receiver&& receiver_ptr, RunArgs&&... args) {
+  R Run(Receiver&& receiver_ptr, RunArgs&&... args) const {
     // Clang skips CV qualifier check on a method pointer invocation when the
     // receiver is a subclass. Store the receiver into a unqualified reference
     // to T to ensure the CV check works.
     // https://llvm.org/bugs/show_bug.cgi?id=27037
     const T& receiver = *receiver_ptr;
     return (receiver.*method_)(std::forward<RunArgs>(args)...);
   }
 
  private:
   R (T::*method_)(Args...) const;
@@ skipping 133 matching lines @@
 template <size_t... bound_indices,
           typename StorageType,
           bool is_weak_call,
           typename R,
           typename... UnboundArgs>
 struct Invoker<IndexSequence<bound_indices...>,
                StorageType,
                is_weak_call,
                R(UnboundArgs...)> {
   static R Run(BindStateBase* base, UnboundArgs&&... unbound_args) {
-    StorageType* storage = static_cast<StorageType*>(base);
+    const StorageType* storage = static_cast<StorageType*>(base);
     // Local references to make debugger stepping easier. If in a debugger,
     // you really want to warp ahead and step through the
     // InvokeHelper<>::MakeItSo() call below.
     return InvokeHelper<is_weak_call, R>::MakeItSo(
         storage->runnable_,
         Unwrap(std::get<bound_indices>(storage->bound_args_))...,
         std::forward<UnboundArgs>(unbound_args)...);
   }
 };
 
@@ skipping 66 matching lines @@
 
   static void Destroy(BindStateBase* self) {
     delete static_cast<BindState*>(self);
   }
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_