Allow implicitly converting a lambda to mojo::Callback using C++11

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 <functional>
 #include <type_traits>
 
 #include "mojo/public/cpp/bindings/lib/callback_internal.h"
 #include "mojo/public/cpp/bindings/lib/shared_ptr.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 
 namespace mojo {
 
 template <typename Sig>
 class Callback;
@@ skipping 13 matching lines @@
         const = 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_(runnable) {}
 
-  // As above, but can take an object that isn't derived from Runnable, so long
-  // as it has a compatible operator() or Run() method. operator() will be
-  // preferred if the type has both.
+  // Adapts any type that is copy-constructable and has a compatible Run method
+  // or is convertible to std::function<void(Args...)> (such as a lambda of the
+  // correct type).
   template <typename Sink>
   Callback(const Sink& sink) {
     using sink_type = typename std::conditional<
-        internal::HasCompatibleCallOperator<Sink, Args...>::value,
+        std::is_convertible<Sink, std::function<void(Args...)>>::value,
         FunctorAdapter<Sink>, RunnableAdapter<Sink>>::type;
     sink_ = internal::SharedPtr<Runnable>(new sink_type(sink));
   }
 
   // As above, but can take a compatible function pointer.
   Callback(void (*function_ptr)(
       typename internal::Callback_ParamTraits<Args>::ForwardType...))
       : sink_(new FunctionPtrAdapter(function_ptr)) {}
 
   // Executes the callback function, invoking Pass() on move-only types.
@@ skipping 50 matching lines @@
 
   internal::SharedPtr<Runnable> sink_;
 };
 
 // A specialization of Callback which takes no parameters.
 typedef Callback<void()> Closure;
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_CALLBACK_H_