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

mojo/public/cpp/bindings/tests/callback_unittest.cc

 // Copyright 2015 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.
 
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
@@ skipping 44 matching lines @@
 }
 
 void FunctionStringArgByConstRef(const String& s) {
   (*g_calls)++;
 }
 
 void FunctionMoveOnlyType(ExampleMoveOnlyType m) {
   (*g_calls)++;
 }
 
-static_assert(!internal::HasCompatibleCallOperator<RunnableNoArgs>::value,
-              "HasCompatibleCallOperator<Runnable>");
-static_assert(!internal::HasCompatibleCallOperator<RunnableOneArg, int>::value,
-              "HasCompatibleCallOperator<RunnableOneArg, int>");
-static_assert(!internal::HasCompatibleCallOperator<RunnableStringArgByConstRef,
-                                                   String>::value,
-              "HasCompatibleCallOperator<RunnableStringArgByConstRef, String>");
-static_assert(!internal::HasCompatibleCallOperator<RunnableMoveOnlyParam,
-                                                   ExampleMoveOnlyType>::value,
-              "HasCompatibleCallOperator<RunnableMoveOnlyParam, String>");
-
-auto lambda_one = []() {};
-static_assert(internal::HasCompatibleCallOperator<decltype(lambda_one)>::value,
-              "HasCompatibleCallOperator<lambda []() {}>");
-
-auto lambda_two = [](int x) {};
-static_assert(
-    internal::HasCompatibleCallOperator<decltype(lambda_two), int>::value,
-    "HasCompatibleCallOperator<lambda [](int x) {}, int>");
-
-auto lambda_three = [](const String& s) {};
-static_assert(
-    internal::HasCompatibleCallOperator<decltype(lambda_three), String>::value,
-    "HasCompatibleCallOperator<lambda [](const String& s) {}, String>");
-
-auto lambda_four = [](ExampleMoveOnlyType m) {};
-static_assert(internal::HasCompatibleCallOperator<decltype(lambda_four),
-                                                  ExampleMoveOnlyType>::value,
-              "HasCompatibleCallOperator<lambda [](ExampleMoveOnlyType) {}, "
-              "ExampleMoveOnlyType>");
-
 // Tests constructing and invoking a mojo::Callback from objects with a
 // compatible Run() method (called 'runnables'), from lambdas, and from function
 // pointers.
 TEST(Callback, Create) {
   int calls = 0;
 
   RunnableNoArgs f(&calls);
   // Construct from a runnable object.
   mojo::Callback<void()> cb = f;
   cb.Run();
@@ skipping 81 matching lines @@
   g_overloaded_function_with_double_param_called = false;
   mojo::Callback<void(double)> cb_with_double_param = &OverloadedFunction;
   cb_with_double_param.Run(123);
   EXPECT_TRUE(g_overloaded_function_with_double_param_called);
   g_overloaded_function_with_double_param_called = false;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo