Deletes mojo::Callback

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

 // Copyright 2016 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 <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 20 matching lines @@
   template <typename Func>
   static CallbackType BindLambda(Func func) {
     return base::Bind(&LambdaBinder::RunLambda<Func>, func);
   }
 };
 
 class TestSyncCommonImpl {
  public:
   TestSyncCommonImpl() {}
 
-  using PingHandler = Callback<void(const Callback<void()>&)>;
-  using PingBinder = LambdaBinder<const Callback<void()>&>;
+  using PingHandler = base::Callback<void(const base::Callback<void()>&)>;
+  using PingBinder = LambdaBinder<const base::Callback<void()>&>;
   template <typename Func>
   void set_ping_handler(Func handler) {
     ping_handler_ = PingBinder::BindLambda(handler);
   }
 
-  using EchoHandler = Callback<void(int32_t, const Callback<void(int32_t)>&)>;
-  using EchoBinder = LambdaBinder<int32_t, const Callback<void(int32_t)>&>;
+  using EchoHandler =
+      base::Callback<void(int32_t, const base::Callback<void(int32_t)>&)>;
+  using EchoBinder =
+      LambdaBinder<int32_t, const base::Callback<void(int32_t)>&>;
   template <typename Func>
   void set_echo_handler(Func handler) {
     echo_handler_ = EchoBinder::BindLambda(handler);
   }
 
   using AsyncEchoHandler =
-      Callback<void(int32_t, const Callback<void(int32_t)>&)>;
-  using AsyncEchoBinder = LambdaBinder<int32_t, const Callback<void(int32_t)>&>;
+      base::Callback<void(int32_t, const base::Callback<void(int32_t)>&)>;
+  using AsyncEchoBinder =
+      LambdaBinder<int32_t, const base::Callback<void(int32_t)>&>;
   template <typename Func>
   void set_async_echo_handler(Func handler) {
     async_echo_handler_ = AsyncEchoBinder::BindLambda(handler);
   }
 
-  using SendInterfaceHandler = Callback<void(TestSyncAssociatedPtrInfo)>;
+  using SendInterfaceHandler = base::Callback<void(TestSyncAssociatedPtrInfo)>;
   using SendInterfaceBinder = LambdaBinder<TestSyncAssociatedPtrInfo>;
   template <typename Func>
   void set_send_interface_handler(Func handler) {
     send_interface_handler_ = SendInterfaceBinder::BindLambda(handler);
   }
 
-  using SendRequestHandler = Callback<void(TestSyncAssociatedRequest)>;
+  using SendRequestHandler = base::Callback<void(TestSyncAssociatedRequest)>;
   using SendRequestBinder = LambdaBinder<TestSyncAssociatedRequest>;
   template <typename Func>
   void set_send_request_handler(Func handler) {
     send_request_handler_ = SendRequestBinder::BindLambda(handler);
   }
 
-  void PingImpl(const Callback<void()>& callback) {
+  void PingImpl(const base::Callback<void()>& callback) {
     if (ping_handler_.is_null()) {
       callback.Run();
       return;
     }
     ping_handler_.Run(callback);
   }
-  void EchoImpl(int32_t value, const Callback<void(int32_t)>& callback) {
+  void EchoImpl(int32_t value, const base::Callback<void(int32_t)>& callback) {
     if (echo_handler_.is_null()) {
       callback.Run(value);
       return;
     }
     echo_handler_.Run(value, callback);
   }
-  void AsyncEchoImpl(int32_t value, const Callback<void(int32_t)>& callback) {
+  void AsyncEchoImpl(int32_t value,
+                     const base::Callback<void(int32_t)>& callback) {
     if (async_echo_handler_.is_null()) {
       callback.Run(value);
       return;
     }
     async_echo_handler_.Run(value, callback);
   }
   void SendInterfaceImpl(TestSyncAssociatedPtrInfo ptr) {
     send_interface_handler_.Run(std::move(ptr));
   }
   void SendRequestImpl(TestSyncAssociatedRequest request) {
@@ skipping 627 matching lines @@
   int32_t result_value = -1;
   ASSERT_TRUE(master_ptr_->Echo(456, &result_value));
   EXPECT_EQ(456, result_value);
 }
 
 // TODO(yzshen): Add more tests related to associated interfaces.
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo