Mojo: Armed Watchers

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

 // Copyright 2016 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 <memory>
 #include <utility>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/associated_binding_set.h"
@@ skipping 334 matching lines @@
   PingServiceAssociatedPtr ptr;
   master_ptr->GetPing(MakeRequest(&ptr));
 
   ptr.ResetWithReason(2048u, "bye");
 
   run_loop.Run();
 }
 
 class PingInstanceCounter : public PingService {
  public:
-  PingInstanceCounter() { ++instance_count; }
-  ~PingInstanceCounter() override { --instance_count; }
+  explicit PingInstanceCounter(
+      const base::Closure& destruction_callback = base::Closure())
+      : destruction_callback_(destruction_callback) {
+    ++instance_count;
+  }
+
+  ~PingInstanceCounter() override {
+    --instance_count;
+    if (destruction_callback_)
+      destruction_callback_.Run();
+  }
 
   void Ping(const PingCallback& callback) override {}
 
+  const base::Closure destruction_callback_;
+
   static int instance_count;
 };
 int PingInstanceCounter::instance_count = 0;
 
 TEST_F(BindingSetTest, StrongBinding_Destructor) {
   PingServicePtr ping_a, ping_b;
   auto bindings = base::MakeUnique<StrongBindingSet<PingService>>();
 
   bindings->AddBinding(base::MakeUnique<PingInstanceCounter>(),
                        mojo::MakeRequest(&ping_a));
   EXPECT_EQ(1, PingInstanceCounter::instance_count);
 
   bindings->AddBinding(base::MakeUnique<PingInstanceCounter>(),
                        mojo::MakeRequest(&ping_b));
   EXPECT_EQ(2, PingInstanceCounter::instance_count);
 
   bindings.reset();
   EXPECT_EQ(0, PingInstanceCounter::instance_count);
 }
 
 TEST_F(BindingSetTest, StrongBinding_ConnectionError) {
+  base::RunLoop loop_a, loop_b;
   PingServicePtr ping_a, ping_b;
   StrongBindingSet<PingService> bindings;
-  bindings.AddBinding(base::MakeUnique<PingInstanceCounter>(),
-                      mojo::MakeRequest(&ping_a));
-  bindings.AddBinding(base::MakeUnique<PingInstanceCounter>(),
-                      mojo::MakeRequest(&ping_b));
+  bindings.AddBinding(
+      base::MakeUnique<PingInstanceCounter>(loop_a.QuitClosure()),
+      mojo::MakeRequest(&ping_a));
+  bindings.AddBinding(
+      base::MakeUnique<PingInstanceCounter>(loop_b.QuitClosure()),
+      mojo::MakeRequest(&ping_b));
   EXPECT_EQ(2, PingInstanceCounter::instance_count);
 
   ping_a.reset();
-  base::RunLoop().RunUntilIdle();
+  loop_a.Run();
   EXPECT_EQ(1, PingInstanceCounter::instance_count);
 
   ping_b.reset();
-  base::RunLoop().RunUntilIdle();
+  loop_b.Run();
   EXPECT_EQ(0, PingInstanceCounter::instance_count);
 }
 
 TEST_F(BindingSetTest, StrongBinding_RemoveBinding) {
   PingServicePtr ping_a, ping_b;
   StrongBindingSet<PingService> bindings;
   BindingId binding_id_a = bindings.AddBinding(
       base::MakeUnique<PingInstanceCounter>(), mojo::MakeRequest(&ping_a));
   BindingId binding_id_b = bindings.AddBinding(
       base::MakeUnique<PingInstanceCounter>(), mojo::MakeRequest(&ping_b));
   EXPECT_EQ(2, PingInstanceCounter::instance_count);
 
   EXPECT_TRUE(bindings.RemoveBinding(binding_id_a));
   EXPECT_EQ(1, PingInstanceCounter::instance_count);
 
   EXPECT_TRUE(bindings.RemoveBinding(binding_id_b));
   EXPECT_EQ(0, PingInstanceCounter::instance_count);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo