Add FlushForTesting to InterfacePtr and Binding.

mojo/public/cpp/bindings/tests/binding_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.
 
 // Note: This file tests both binding.h (mojo::Binding) and strong_binding.h
 // (mojo::StrongBinding).
 
 #include "mojo/public/cpp/bindings/binding.h"
 
 #include <stdint.h>
@@ skipping 46 matching lines @@
   bool* const was_deleted_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceImpl);
 };
 
 template <typename... Args>
 void DoSetFlagAndRunClosure(bool* flag,
                             const base::Closure& closure,
                             Args... args) {
   *flag = true;
-  closure.Run();
+  if (!closure.is_null())
+    closure.Run();
 }
 
 template <typename... Args>
 base::Callback<void(Args...)> SetFlagAndRunClosure(
     bool* flag,
     const base::Closure& callback = base::Closure()) {
   return base::Bind(&DoSetFlagAndRunClosure<Args...>, flag, callback);
 }
 
 // BindingTest -----------------------------------------------------------------
@@ skipping 300 matching lines @@
 
   for (int i = 0; i < 10; ++i) {
     status = 0;
     base::RunLoop loop;
     ptr->Ping(loop.QuitClosure());
     loop.Run();
     EXPECT_EQ(3, status);
   }
 }
 
+void Fail() {
+  FAIL() << "Unexpected connection error";
+}
+
+TEST_F(BindingTest, FlushForTesting) {
+  bool called = false;
+  sample::ServicePtr ptr;
+  auto request = GetProxy(&ptr);
+  ServiceImpl impl;
+  Binding<sample::Service> binding(&impl, std::move(request));
+  binding.set_connection_error_handler(base::Bind(&Fail));
+
+  ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
+                 SetFlagAndRunClosure<int32_t>(&called));
+  EXPECT_FALSE(called);
+  binding.FlushForTesting();
+  binding.FlushForTesting();
+  EXPECT_TRUE(called);
+}
+
+TEST_F(BindingTest, FlushForTestingWithClosedPeer) {
+  bool called = false;
+  sample::ServicePtr ptr;
+  auto request = GetProxy(&ptr);
+  ServiceImpl impl;
+  Binding<sample::Service> binding(&impl, std::move(request));
+  binding.set_connection_error_handler(SetFlagAndRunClosure(&called));
+  ptr.reset();
+
+  EXPECT_FALSE(called);
+  binding.FlushForTesting();
+  EXPECT_TRUE(called);
+  binding.FlushForTesting();
+}
+
+TEST_F(BindingTest, FlushForTestingWhenClosed) {
+  ServiceImpl impl;
+  Binding<sample::Service> binding(&impl);
+  binding.FlushForTesting();
+}
+
 // StrongBindingTest -----------------------------------------------------------
 
 using StrongBindingTest = BindingTestBase;
 
 // Tests that destroying a mojo::StrongBinding closes the bound message pipe
 // handle but does *not* destroy the implementation object.
 TEST_F(StrongBindingTest, DestroyClosesMessagePipe) {
   base::RunLoop run_loop;
   bool encountered_error = false;
   bool was_deleted = false;
@@ skipping 80 matching lines @@
   EXPECT_FALSE(ptr_error_handler_called);
   EXPECT_TRUE(was_deleted);
   was_deleted = false;  // It shouldn't be double-deleted!
   run_loop.Run();
   EXPECT_TRUE(ptr_error_handler_called);
   EXPECT_FALSE(was_deleted);
 
   EXPECT_FALSE(binding_error_handler_called);
 }
 
+TEST_F(StrongBindingTest, FlushForTesting) {
+  bool called = false;
+  bool was_deleted = false;
+  sample::ServicePtr ptr;
+  auto request = GetProxy(&ptr);
+  StrongBinding<sample::Service> binding(new ServiceImpl(&was_deleted),
+                                         std::move(request));
+  binding.set_connection_error_handler(base::Bind(&Fail));
+
+  ptr->Frobinate(nullptr, sample::Service::BazOptions::REGULAR, nullptr,
+                 SetFlagAndRunClosure<int32_t>(&called));
+  EXPECT_FALSE(called);
+  binding.FlushForTesting();
+  binding.FlushForTesting();
+  EXPECT_TRUE(called);
+  EXPECT_FALSE(was_deleted);
+  ptr.reset();
+  binding.set_connection_error_handler(base::Closure());
+  binding.FlushForTesting();
+  EXPECT_TRUE(was_deleted);
+}
+
+TEST_F(StrongBindingTest, FlushForTestingWithClosedPeer) {
+  bool called = false;
+  bool was_deleted = false;
+  sample::ServicePtr ptr;
+  auto request = GetProxy(&ptr);
+  StrongBinding<sample::Service> binding(new ServiceImpl(&was_deleted),
+                                         std::move(request));
+  binding.set_connection_error_handler(SetFlagAndRunClosure(&called));
+  ptr.reset();
+
+  EXPECT_FALSE(called);
+  EXPECT_FALSE(was_deleted);
+  binding.FlushForTesting();
+  EXPECT_TRUE(called);
+  EXPECT_TRUE(was_deleted);
+  binding.FlushForTesting();
+  EXPECT_TRUE(was_deleted);
+}
+
+TEST_F(StrongBindingTest, FlushForTestingWhenClosed) {
+  bool was_deleted = false;
+  ServiceImpl impl(&was_deleted);
+  StrongBinding<sample::Service> binding(&impl);
+  binding.FlushForTesting();
+  EXPECT_FALSE(was_deleted);
+}
+
 }  // namespace
 }  // mojo