Deletes mojo::Callback

ipc/mojo/ipc_mojo_bootstrap.cc

 // 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.
 
 #include "ipc/mojo/ipc_mojo_bootstrap.h"
 
 #include <stdint.h>
 #include <utility>
 
+#include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/process_handle.h"
 #include "build/build_config.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_platform_file.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace IPC {
@@ skipping 47 matching lines @@
 }
 
 void MojoServerBootstrap::OnInitDone(int32_t peer_pid) {
   if (state() != STATE_WAITING_ACK) {
     set_state(STATE_ERROR);
     LOG(ERROR) << "Got inconsistent message from client.";
     return;
   }
 
   set_state(STATE_READY);
-  bootstrap_.set_connection_error_handler(mojo::Closure());
+  bootstrap_.set_connection_error_handler(base::Closure());
   delegate()->OnPipesAvailable(std::move(send_channel_),
                                std::move(receive_channel_request_), peer_pid);
 }
 
 // MojoBootstrap for client processes. You should create the instance
 // using MojoBootstrap::Create().
 class MojoClientBootstrap : public MojoBootstrap, public mojom::Bootstrap {
  public:
   MojoClientBootstrap();
 
  private:
   // MojoBootstrap implementation.
   void Connect() override;
 
   // mojom::Bootstrap implementation.
   void Init(mojom::ChannelAssociatedRequest receive_channel,
             mojom::ChannelAssociatedPtrInfo send_channel,
             int32_t peer_pid,
-            const mojo::Callback<void(int32_t)>& callback) override;
+            const InitCallback& callback) override;
 
   mojo::Binding<mojom::Bootstrap> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoClientBootstrap);
 };
 
 MojoClientBootstrap::MojoClientBootstrap() : binding_(this) {}
 
 void MojoClientBootstrap::Connect() {
   binding_.Bind(TakeHandle());
   binding_.set_connection_error_handler(
       base::Bind(&MojoClientBootstrap::Fail, base::Unretained(this)));
 }
 
 void MojoClientBootstrap::Init(mojom::ChannelAssociatedRequest receive_channel,
                                mojom::ChannelAssociatedPtrInfo send_channel,
                                int32_t peer_pid,
-                               const mojo::Callback<void(int32_t)>& callback) {
+                               const InitCallback& callback) {
   callback.Run(GetSelfPID());
   set_state(STATE_READY);
-  binding_.set_connection_error_handler(mojo::Closure());
+  binding_.set_connection_error_handler(base::Closure());
   delegate()->OnPipesAvailable(std::move(send_channel),
                                std::move(receive_channel), peer_pid);
 }
 
 }  // namespace
 
 // MojoBootstrap
 
 // static
 std::unique_ptr<MojoBootstrap> MojoBootstrap::Create(
@@ skipping 36 matching lines @@
 
 bool MojoBootstrap::HasFailed() const {
   return state() == STATE_ERROR;
 }
 
 mojo::ScopedMessagePipeHandle MojoBootstrap::TakeHandle() {
   return std::move(handle_);
 }
 
 }  // namespace IPC