Deletes mojo::Callback

mojo/public/cpp/bindings/tests/bind_task_runner_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 "base/bind.h"
+#include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
@@ skipping 101 matching lines @@
 
 template <typename BindingType, typename RequestType>
 class IntegerSenderImpl : public IntegerSender {
  public:
   IntegerSenderImpl(RequestType request,
                     scoped_refptr<base::SingleThreadTaskRunner> runner)
       : binding_(this, std::move(request), std::move(runner)) {}
 
   ~IntegerSenderImpl() override {}
 
-  using EchoHandler = Callback<void(int32_t, const EchoCallback&)>;
+  using EchoHandler = base::Callback<void(int32_t, const EchoCallback&)>;
 
   void set_echo_handler(const EchoHandler& handler) { echo_handler_ = handler; }
 
   void Echo(int32_t value, const EchoCallback& callback) override {
     if (echo_handler_.is_null())
       callback.Run(value);
     else
       echo_handler_.Run(value, callback);
   }
   void Send(int32_t value) override { NOTREACHED(); }
@@ skipping 12 matching lines @@
 
   explicit IntegerSenderConnectionImpl(
       IntegerSenderConnectionRequest request,
       scoped_refptr<base::SingleThreadTaskRunner> runner,
       scoped_refptr<base::SingleThreadTaskRunner> sender_runner)
       : binding_(this, std::move(request), std::move(runner)),
         sender_runner_(std::move(sender_runner)) {}
 
   ~IntegerSenderConnectionImpl() override {}
 
-  void set_get_sender_notification(const Closure& notification) {
+  void set_get_sender_notification(const base::Closure& notification) {
     get_sender_notification_ = notification;
   }
   void GetSender(IntegerSenderAssociatedRequest sender) override {
     sender_impl_.reset(new SenderType(std::move(sender), sender_runner_));
     get_sender_notification_.Run();
   }
 
   void AsyncGetSender(const AsyncGetSenderCallback& callback) override {
     NOTREACHED();
   }
 
   Binding<IntegerSenderConnection>* binding() { return &binding_; }
 
   SenderType* sender_impl() { return sender_impl_.get(); }
 
  private:
   Binding<IntegerSenderConnection> binding_;
   std::unique_ptr<SenderType> sender_impl_;
   scoped_refptr<base::SingleThreadTaskRunner> sender_runner_;
-  Closure get_sender_notification_;
+  base::Closure get_sender_notification_;
 };
 
 class BindTaskRunnerTest : public testing::Test {
  protected:
   void SetUp() override {
     binding_task_runner_ = scoped_refptr<TestTaskRunner>(new TestTaskRunner);
     ptr_task_runner_ = scoped_refptr<TestTaskRunner>(new TestTaskRunner);
 
     auto request = GetProxy(&ptr_, ptr_task_runner_);
     impl_.reset(new ImplType(std::move(request), binding_task_runner_));
@@ skipping 194 matching lines @@
   EXPECT_TRUE(sender_impl_error);
   connection_ptr_task_runner_->Run();
   EXPECT_TRUE(connection_ptr_error);
   sender_ptr_task_runner_->Run();
   EXPECT_TRUE(sender_ptr_error);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo