Make mojo::Callback<>::Runnable::Run non-const.

mojo/public/cpp/bindings/callback.h

 // Copyright 2014 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 MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_
 
 #include <type_traits>
 #include <utility>
 
@@ skipping 15 matching lines @@
  public:
   // An interface that may be implemented to define the Run() method.
   struct Runnable {
     virtual ~Runnable() {}
     virtual void Run(
         // ForwardType ensures String is passed as a const reference. Can't use
         // universal refs (Args&&) here since this method itself isn't templated
         // because it is a virtual interface. So we have to take the arguments
         // all by value (except String which we take as a const reference due to
         // ForwardType).
-        typename internal::Callback_ParamTraits<Args>::ForwardType...)
-        const = 0;
+        typename internal::Callback_ParamTraits<Args>::ForwardType...) = 0;
   };
 
   // Constructs a "null" callback that does nothing.
   Callback() {}
 
   // Constructs a callback that will run |runnable|. The callback takes
   // ownership of |runnable|.
   explicit Callback(Runnable* runnable) : sink_(new RunnableHolder(runnable)) {}
 
   // As above, but can take an object that isn't derived from Runnable, so long
@@ skipping 43 matching lines @@
   void reset() { sink_ = nullptr; }
 
  private:
   // Adapts a class that has a Run() method but is not derived from Runnable to
   // be callable by Callback.
   template <typename Sink>
   struct RunnableAdapter : public Runnable {
     explicit RunnableAdapter(const Sink& sink) : sink(sink) {}
     virtual void Run(
         typename internal::Callback_ParamTraits<Args>::ForwardType... args)
-        const override {
+        override {
       sink.Run(std::forward<
                typename internal::Callback_ParamTraits<Args>::ForwardType>(
           args)...);
     }
     Sink sink;
   };
 
   // Adapts a class that has a compatible operator() to be callable by Callback.
   template <typename Sink>
   struct FunctorAdapter : public Runnable {
     explicit FunctorAdapter(const Sink& sink) : sink(sink) {}
     virtual void Run(
         typename internal::Callback_ParamTraits<Args>::ForwardType... args)
-        const override {
+        override {
       sink.operator()(
           std::forward<
               typename internal::Callback_ParamTraits<Args>::ForwardType>(
               args)...);
     }
     Sink sink;
   };
 
   // Adapts a function pointer.
   struct FunctionPtrAdapter : public Runnable {
    private:
     using FunctionPtr =
         void (*)(typename internal::Callback_ParamTraits<Args>::ForwardType...);
 
    public:
     explicit FunctionPtrAdapter(FunctionPtr function_ptr)
         : function_ptr(function_ptr) {}
     virtual void Run(
         typename internal::Callback_ParamTraits<Args>::ForwardType... args)
-        const override {
+        override {
       (*function_ptr)(
           std::forward<
               typename internal::Callback_ParamTraits<Args>::ForwardType>(
               args)...);
     }
     FunctionPtr function_ptr;
   };
 
   struct RunnableHolder : public base::RefCountedThreadSafe<RunnableHolder> {
     explicit RunnableHolder(Runnable* runnable) : runnable(runnable) {}
 
     scoped_ptr<Runnable> runnable;
 
    private:
     friend class base::RefCountedThreadSafe<RunnableHolder>;
     ~RunnableHolder() {}
   };
 
   scoped_refptr<RunnableHolder> sink_;
 };
 
 // A specialization of Callback which takes no parameters.
 typedef Callback<void()> Closure;
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_