Update monet.

mojo/common/interface_ptr_set_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 "mojo/common/interface_ptr_set.h"
+
+#include "base/message_loop/message_loop.h"
+#include "mojo/common/test_interfaces.mojom.h"
+#include "mojo/message_pump/message_pump_mojo.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace mojo {
+namespace common {
+namespace {
+
+class DummyImpl : public tests::Dummy {
+ public:
+  explicit DummyImpl(InterfaceRequest<tests::Dummy> request)
+      : binding_(this, request.Pass()) {}
+
+  void Foo() override { call_count_++; }
+
+  void CloseMessagePipe() { binding_.Close(); }
+
+  int call_count() { return call_count_; }
+
+ private:
+  Binding<tests::Dummy> binding_;
+  int call_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(DummyImpl);
+};
+
+// Tests all of the functionality of InterfacePtrSet.
+TEST(InterfacePtrSetTest, FullLifeCycle) {
+  base::MessageLoop loop(MessagePumpMojo::Create());
+
+  // Create 10 InterfacePtrs.
+  const size_t kNumObjects = 10;
+  InterfacePtr<tests::Dummy> intrfc_ptrs[kNumObjects];
+
+  // Create 10 DummyImpls and 10 message pipes and bind them all together.
+  std::unique_ptr<DummyImpl> impls[kNumObjects];
+  for (size_t i = 0; i < kNumObjects; i++) {
+    impls[i].reset(new DummyImpl(GetProxy(&intrfc_ptrs[i])));
+  }
+
+  // Move all 10 InterfacePtrs into the set.
+  InterfacePtrSet<tests::Dummy> intrfc_ptr_set;
+  EXPECT_EQ(0u, intrfc_ptr_set.size());
+  for (InterfacePtr<tests::Dummy>& ptr : intrfc_ptrs) {
+    intrfc_ptr_set.AddInterfacePtr(ptr.Pass());
+  }
+  EXPECT_EQ(kNumObjects, intrfc_ptr_set.size());
+
+  // Check that initially all call counts are zero.
+  for (const std::unique_ptr<DummyImpl>& impl : impls) {
+    EXPECT_EQ(0, impl->call_count());
+  }
+
+  // Invoke ForAllPtrs().
+  size_t num_invocations = 0;
+  intrfc_ptr_set.ForAllPtrs([&num_invocations](tests::Dummy* dummy) {
+    dummy->Foo();
+    num_invocations++;
+  });
+  EXPECT_EQ(kNumObjects, num_invocations);
+
+  // Check that now all call counts are one.
+  loop.RunUntilIdle();
+  for (const std::unique_ptr<DummyImpl>& impl : impls) {
+    EXPECT_EQ(1, impl->call_count());
+  }
+
+  // Close the first 5 message pipes. This will (after RunUntilIdle) cause
+  // connection errors on the closed pipes which will cause the first five
+  // objects to be removed.
+  for (size_t i = 0; i < kNumObjects / 2; i++) {
+    impls[i]->CloseMessagePipe();
+  }
+  EXPECT_EQ(kNumObjects, intrfc_ptr_set.size());
+  loop.RunUntilIdle();
+  EXPECT_EQ(kNumObjects / 2, intrfc_ptr_set.size());
+
+  // Invoke ForAllPtrs again on the remaining five pointers
+  intrfc_ptr_set.ForAllPtrs([](tests::Dummy* dummy) { dummy->Foo(); });
+  loop.RunUntilIdle();
+
+  // Check that now the first five counts are still 1 but the second five
+  // counts are two.
+  for (size_t i = 0; i < kNumObjects; i++) {
+    int expected = (i < kNumObjects / 2 ? 1 : 2);
+    EXPECT_EQ(expected, impls[i]->call_count());
+  }
+
+  // Close all of the MessagePipes and clear the set.
+  intrfc_ptr_set.CloseAll();
+
+  // Invoke ForAllPtrs() again.
+  intrfc_ptr_set.ForAllPtrs([](tests::Dummy* dummy) { dummy->Foo(); });
+  loop.RunUntilIdle();
+
+  // Check that the counts are the same as last time.
+  for (size_t i = 0; i < kNumObjects; i++) {
+    int expected = (i < kNumObjects / 2 ? 1 : 2);
+    EXPECT_EQ(expected, impls[i]->call_count());
+  }
+  EXPECT_EQ(0u, intrfc_ptr_set.size());
+}
+
+}  // namespace
+}  // namespace common
+}  // namespace mojo