Privatize StrongBinding lifetime management

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

 // Copyright 2013 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 <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 463 matching lines @@
   ptr.set_connection_error_handler(run_loop3.QuitClosure());
   ptr->SetInteger(789, sample::Enum::VALUE);
   run_loop3.Run();
   EXPECT_TRUE(ptr.encountered_error());
   // The call to SetInteger() after RequireVersion(4u) is ignored.
   EXPECT_EQ(456, impl.integer());
 }
 
 class StrongMathCalculatorImpl : public math::Calculator {
  public:
-  StrongMathCalculatorImpl(ScopedMessagePipeHandle handle,
-                           bool* error_received,
-                           bool* destroyed,
-                           const base::Closure& closure)
-      : error_received_(error_received),
-        destroyed_(destroyed),
-        closure_(closure),
-        binding_(this, std::move(handle)) {
-    binding_.set_connection_error_handler(
-        base::Bind(&SetFlagAndRunClosure, error_received_, closure_));
-  }
+  StrongMathCalculatorImpl(bool* destroyed) : destroyed_(destroyed) {}
   ~StrongMathCalculatorImpl() override { *destroyed_ = true; }
 
   // math::Calculator implementation.
   void Clear(const CalcCallback& callback) override { callback.Run(total_); }
 
   void Add(double value, const CalcCallback& callback) override {
     total_ += value;
     callback.Run(total_);
   }
 
   void Multiply(double value, const CalcCallback& callback) override {
     total_ *= value;
     callback.Run(total_);
   }
 
  private:
   double total_ = 0.0;
-  bool* error_received_;
   bool* destroyed_;
-  base::Closure closure_;
-
-  StrongBinding<math::Calculator> binding_;
 };
 
 TEST(StrongConnectorTest, Math) {
   base::MessageLoop loop;
 
   bool error_received = false;
   bool destroyed = false;
-  MessagePipe pipe;
+  math::CalculatorPtr calc;
   base::RunLoop run_loop;
-  new StrongMathCalculatorImpl(std::move(pipe.handle0), &error_received,
-                               &destroyed, run_loop.QuitClosure());
 
-  math::CalculatorPtr calc;
-  calc.Bind(InterfacePtrInfo<math::Calculator>(std::move(pipe.handle1), 0u));
+  auto binding = MakeStrongBinding(
+      base::MakeUnique<StrongMathCalculatorImpl>(&destroyed), GetProxy(&calc));
+  binding->set_connection_error_handler(
+      base::Bind(&SetFlagAndRunClosure, &error_received,
+                 run_loop.QuitClosure()));
 
   {
     // Suppose this is instantiated in a process that has the other end of the
     // message pipe.
     MathCalculatorUI calculator_ui(std::move(calc));
 
     base::RunLoop run_loop, run_loop2;
     calculator_ui.Add(2.0, run_loop.QuitClosure());
     calculator_ui.Multiply(5.0, run_loop2.QuitClosure());
     run_loop.Run();
@@ skipping 80 matching lines @@
     // end which will destroy the instance since it is strongly bound.
   }
 
   run_loop.Run();
   EXPECT_TRUE(error_received);
   EXPECT_FALSE(destroyed);
 }
 
 class CImpl : public C {
  public:
-  CImpl(bool* d_called, InterfaceRequest<C> request,
-        const base::Closure& closure)
-      : d_called_(d_called), binding_(this, std::move(request)),
-        closure_(closure) {}
+  CImpl(bool* d_called, const base::Closure& closure)
+      : d_called_(d_called), closure_(closure) {}
   ~CImpl() override {}
 
  private:
   void D() override {
     *d_called_ = true;
     closure_.Run();
   }
 
   bool* d_called_;
-  StrongBinding<C> binding_;
   base::Closure closure_;
 };
 
 class BImpl : public B {
  public:
-  BImpl(bool* d_called, InterfaceRequest<B> request,
-        const base::Closure& closure)
-      : d_called_(d_called), binding_(this, std::move(request)),
-        closure_(closure) {}
+  BImpl(bool* d_called, const base::Closure& closure)
+      : d_called_(d_called), closure_(closure) {}
   ~BImpl() override {}
 
  private:
   void GetC(InterfaceRequest<C> c) override {
-    new CImpl(d_called_, std::move(c), closure_);
+    MakeStrongBinding(base::MakeUnique<CImpl>(d_called_, closure_),
+                      std::move(c));
   }
 
   bool* d_called_;
-  StrongBinding<B> binding_;
   base::Closure closure_;
 };
 
 class AImpl : public A {
  public:
   AImpl(InterfaceRequest<A> request, const base::Closure& closure)
       : d_called_(false), binding_(this, std::move(request)),
         closure_(closure) {}
   ~AImpl() override {}
 
   bool d_called() const { return d_called_; }
 
  private:
   void GetB(InterfaceRequest<B> b) override {
-    new BImpl(&d_called_, std::move(b), closure_);
+    MakeStrongBinding(base::MakeUnique<BImpl>(&d_called_, closure_),
+                      std::move(b));
   }
 
   bool d_called_;
   Binding<A> binding_;
   base::Closure closure_;
 };
 
 TEST_F(InterfacePtrTest, Scoping) {
   APtr a;
   base::RunLoop run_loop;
@@ skipping 80 matching lines @@
   bool called = false;
   calc.set_connection_error_handler(base::Bind(&SetBool, &called));
   calc.FlushForTesting();
   EXPECT_TRUE(called);
   calc.FlushForTesting();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo