Privatize StrongBinding lifetime management

mojo/public/cpp/bindings/tests/associated_interface_unittest.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 <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 871 matching lines @@
   impl.binding()->set_connection_error_handler(base::Bind(&SetBool, &called));
   ptr.reset();
   EXPECT_FALSE(called);
   impl.binding()->FlushForTesting();
   EXPECT_TRUE(called);
   impl.binding()->FlushForTesting();
 }
 
 TEST_F(AssociatedInterfaceTest, StrongBindingFlushForTesting) {
   IntegerSenderConnectionPtr ptr;
-  IntegerSenderConnectionImpl impl(IntegerSenderConnectionRequest{});
-  mojo::StrongBinding<IntegerSenderConnection> binding(&impl, GetProxy(&ptr));
-  binding.set_connection_error_handler(base::Bind(&Fail));
+  auto binding =
+      MakeStrongBinding(base::MakeUnique<IntegerSenderConnectionImpl>(
+                            IntegerSenderConnectionRequest{}),
+                        GetProxy(&ptr));
   bool called = false;
   IntegerSenderAssociatedPtr sender_ptr;
   ptr->GetSender(GetProxy(&sender_ptr, ptr.associated_group()));
   sender_ptr->Echo(1, base::Bind(&SetBoolWithUnusedParameter<int>, &called));
   EXPECT_FALSE(called);
   // Because the flush is sent from the binding, it only guarantees that the
   // request has been received, not the response. The second flush waits for the
   // response to be received.
-  binding.FlushForTesting();
-  binding.FlushForTesting();
+  ASSERT_TRUE(binding);
+  binding->FlushForTesting();
+  ASSERT_TRUE(binding);
+  binding->FlushForTesting();
   EXPECT_TRUE(called);
 }
 
 TEST_F(AssociatedInterfaceTest, StrongBindingFlushForTestingWithClosedPeer) {
   IntegerSenderConnectionPtr ptr;
-  mojo::StrongBinding<IntegerSenderConnection> binding(
-      new IntegerSenderConnectionImpl(IntegerSenderConnectionRequest{}),
-      GetProxy(&ptr));
   bool called = false;
-  binding.set_connection_error_handler(base::Bind(&SetBool, &called));
+  auto binding =
+      MakeStrongBinding(base::MakeUnique<IntegerSenderConnectionImpl>(
+                            IntegerSenderConnectionRequest{}),
+                        GetProxy(&ptr));
+  binding->set_connection_error_handler(base::Bind(&SetBool, &called));
   ptr.reset();
   EXPECT_FALSE(called);
-  binding.FlushForTesting();
+  ASSERT_TRUE(binding);
+  binding->FlushForTesting();
   EXPECT_TRUE(called);
-  binding.FlushForTesting();
+  ASSERT_FALSE(binding);
 }
 
 TEST_F(AssociatedInterfaceTest, PtrFlushForTesting) {
   IntegerSenderConnectionPtr ptr;
   IntegerSenderConnectionImpl impl(GetProxy(&ptr));
   bool called = false;
   ptr.set_connection_error_handler(base::Bind(&Fail));
   ptr->AsyncGetSender(base::Bind(
       &SetBoolWithUnusedParameter<IntegerSenderAssociatedPtrInfo>, &called));
   EXPECT_FALSE(called);
   ptr.FlushForTesting();
   EXPECT_TRUE(called);
 }
 
 TEST_F(AssociatedInterfaceTest, PtrFlushForTestingWithClosedPeer) {
   IntegerSenderConnectionPtr ptr;
   GetProxy(&ptr);
   bool called = false;
   ptr.set_connection_error_handler(base::Bind(&SetBool, &called));
   EXPECT_FALSE(called);
   ptr.FlushForTesting();
   EXPECT_TRUE(called);
   ptr.FlushForTesting();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo