mojo: MessageReceiver*::AcceptWithResponder() now take a unique_ptr to the responder

mojo/public/cpp/bindings/tests/bindings_perftest.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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 121 matching lines @@
         "InProcessPingPong", "1000_Inactive",
         kIterations / MojoTicksToSeconds(end_time - start_time),
         "pings/second");
 
     delete[] inactive_services;
   }
 }
 
 class PingPongPaddle : public MessageReceiverWithResponderStatus {
  public:
-  PingPongPaddle(MessageReceiver* sender) : sender_(sender) {}
+  PingPongPaddle(std::unique_ptr<MessageReceiver> sender)
+      : sender_(std::move(sender)) {}
 
-  void set_sender(MessageReceiver* sender) { sender_ = sender; }
+  void set_sender(std::unique_ptr<MessageReceiver> sender) {
+    sender_ = std::move(sender);
+  }
 
   bool Accept(Message* message) override {
     uint32_t count = message->header()->name;
     if (!quit_closure_.is_null()) {
       count++;
       if (count >= expected_count_) {
         end_time_ = base::TimeTicks::Now();
         quit_closure_.Run();
         return true;
       }
     }
 
     internal::MessageBuilder builder(count, 0, 8, 0);
     bool result = sender_->Accept(builder.message());
     DCHECK(result);
     return true;
   }
 
-  bool AcceptWithResponder(Message* message,
-                           MessageReceiverWithStatus* responder) override {
+  bool AcceptWithResponder(
+      Message* message,
+      std::unique_ptr<MessageReceiverWithStatus> responder) override {
     NOTREACHED();
     return true;
   }
 
   base::TimeDelta Serve(uint32_t expected_count) {
     base::RunLoop run_loop;
 
     expected_count_ = expected_count;
     quit_closure_ = run_loop.QuitClosure();
 
     start_time_ = base::TimeTicks::Now();
     internal::MessageBuilder builder(0, 0, 8, 0);
     bool result = sender_->Accept(builder.message());
     DCHECK(result);
 
     run_loop.Run();
 
     return end_time_ - start_time_;
   }
 
  private:
   base::TimeTicks start_time_;
   base::TimeTicks end_time_;
   uint32_t expected_count_ = 0;
-  MessageReceiver* sender_;
+  std::unique_ptr<MessageReceiver> sender_;
   base::Closure quit_closure_;
 };
 
 TEST_F(MojoBindingsPerftest, MultiplexRouterPingPong) {
   MessagePipe pipe;
   scoped_refptr<internal::MultiplexRouter> router0(
       new internal::MultiplexRouter(std::move(pipe.handle0),
                                     internal::MultiplexRouter::SINGLE_INTERFACE,
                                     true, base::ThreadTaskRunnerHandle::Get()));
   scoped_refptr<internal::MultiplexRouter> router1(
@@ skipping 25 matching lines @@
                       kTestIterations / duration.InSecondsF(), "pings/second");
 }
 
 class CounterReceiver : public MessageReceiverWithResponderStatus {
  public:
   bool Accept(Message* message) override {
     counter_++;
     return true;
   }
 
-  bool AcceptWithResponder(Message* message,
-                           MessageReceiverWithStatus* responder) override {
+  bool AcceptWithResponder(
+      Message* message,
+      std::unique_ptr<MessageReceiverWithStatus> responder) override {
     NOTREACHED();
     return true;
   }
 
   uint32_t counter() const { return counter_; }
 
   void Reset() { counter_ = 0; }
 
  private:
   uint32_t counter_ = 0;
@@ skipping 28 matching lines @@
     if (i == 1) {
       test::LogPerfResult("MultiplexRouterDispatchCost", nullptr,
                           kIterations[i] / duration.InSecondsF(),
                           "times/second");
     }
   }
 }
 
 }  // namespace
 }  // namespace mojo