Mark OnceCallback::Run() & const so it matches a const callback object.

base/callback.h

 // Copyright (c) 2012 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_CALLBACK_H_
 #define BASE_CALLBACK_H_
 
 #include "base/callback_forward.h"
 #include "base/callback_internal.h"
 
@@ skipping 23 matching lines @@
 
 // Specialization for OnceCallback.
 template <typename R, typename... Args>
 class RunMixin<OnceCallback<R(Args...)>> {
  private:
   using CallbackType = OnceCallback<R(Args...)>;
 
  public:
   using PolymorphicInvoke = R(*)(internal::BindStateBase*, Args&&...);
 
-  R Run(Args... args) & {
+  R Run(Args... args) const & {
     // Note: even though this static_assert will trivially always fail, it
     // cannot be simply replaced with static_assert(false, ...) because:
     // - Per [dcl.dcl]/p4, a program is ill-formed if the constant-expression
     //   argument does not evaluate to true.
     // - Per [temp.res]/p8, if no valid specialization can be generated for a
     //   template definition, and that template is not instantiated, the
     //   template definition is ill-formed, no diagnostic required.
     // These two clauses, taken together, would allow a conforming C++ compiler
     // to immediately reject static_assert(false, ...), even inside an
     // uninstantiated template.
     static_assert(!IsOnceCallback<CallbackType>::value,
-                  "OnceCallback::Run() may only be invoked on an rvalue, i.e. "
-                  "std::move(callback).Run().");
+                  "OnceCallback::Run() may only be invoked on a non-const "
+                  "rvalue, i.e. std::move(callback).Run().");
   }
 
   R Run(Args... args) && {
     // Move the callback instance into a local variable before the invocation,
     // that ensures the internal state is cleared after the invocation.
     // It's not safe to touch |this| after the invocation, since running the
     // bound function may destroy |this|.
     CallbackType cb = static_cast<CallbackType&&>(*this);
     PolymorphicInvoke f =
         reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
@@ skipping 66 matching lines @@
   bool Equals(const Callback& other) const {
     return this->EqualsInternal(other);
   }
 
   friend class internal::RunMixin<Callback>;
 };
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_H_