Add mojo::StrongBindingSet and use it in GeolocationServiceContext.

mojo/common/strong_binding_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/strong_binding_set.h"
+
+#include <vector>
+
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace mojo {
+namespace {
+
+class SampleServiceImpl : public sample::Service {
+ public:
+  explicit SampleServiceImpl(size_t* num_instances)
+      : num_instances_(num_instances) {
+    (*num_instances_)++;
+  }
+  ~SampleServiceImpl() override { (*num_instances_)--; }
+
+  // sample::Service overrides:
+  void Frobinate(sample::FooPtr foo,
+                 BazOptions,
+                 sample::PortPtr port,
+                 const FrobinateCallback& callback) override {
+    callback.Run(0);
+  }
+  void GetPort(mojo::InterfaceRequest<sample::Port> port) override {}
+
+ private:
+  size_t* num_instances_;
+};
+
+}  // namespace
+
+class StrongBindingSetTest : public testing::Test {
+ protected:
+  SampleServiceImpl* CreateService(
+      mojo::InterfaceRequest<sample::Service> request) {
+    return services_.EmplaceService(std::move(request), &num_instances_);
+  }
+
+  SampleServiceImpl* WaitForServiceError() {
+    SampleServiceImpl* service = nullptr;
+    base::RunLoop run_loop;
+    services_.set_connection_error_handler(base::Bind(
+        &StrongBindingSetTest::OnConnectionError, base::Unretained(this),
+        run_loop.QuitClosure(), num_instances_, &service));
+    run_loop.Run();
+    services_.set_connection_error_handler(
+        mojo::Callback<void(SampleServiceImpl*)>());
+    return service;
+  }
+
+  size_t num_instances() { return num_instances_; }
+
+  const StrongBindingSet<SampleServiceImpl>& services() const {
+    return services_;
+  }
+
+  StrongBindingSet<SampleServiceImpl>& mutable_services() {
+    return services_;
+  }
+
+ private:
+  void OnConnectionError(const base::Closure& quit_closure,
+                         size_t num_instances,
+                         SampleServiceImpl** service_out,
+                         SampleServiceImpl* service) {
+    EXPECT_EQ(num_instances, num_instances_);
+    quit_closure.Run();
+    *service_out = service;
+  }
+
+  base::MessageLoop message_loop_;
+  size_t num_instances_ = 0;
+  StrongBindingSet<SampleServiceImpl> services_;
+};
+
+TEST_F(StrongBindingSetTest, Basic) {
+  EXPECT_EQ(0u, services().size());
+  EXPECT_TRUE(services().empty());
+
+  std::vector<SampleServiceImpl*> services_copy(services().begin(),
+                                                services().end());
+  EXPECT_TRUE(services_copy.empty());
+
+  sample::ServicePtr service_ptr;
+  SampleServiceImpl* service = CreateService(mojo::GetProxy(&service_ptr));
+  sample::ServicePtr other_service_ptr;
+  SampleServiceImpl* other_service =
+      CreateService(mojo::GetProxy(&other_service_ptr));
+  EXPECT_EQ(2u, num_instances());
+  EXPECT_EQ(2u, services().size());
+  EXPECT_FALSE(services().empty());
+
+  services_copy =
+      std::vector<SampleServiceImpl*>(services().begin(), services().end());
+  EXPECT_EQ(2u, services_copy.size());
+  service_ptr.reset();
+
+  EXPECT_EQ(service, WaitForServiceError());
+  EXPECT_EQ(1u, num_instances());
+
+  EXPECT_EQ(1u, services().size());
+  EXPECT_FALSE(services().empty());
+
+  services_copy =
+      std::vector<SampleServiceImpl*>(services().begin(), services().end());
+  EXPECT_EQ(1u, services_copy.size());
+  EXPECT_EQ(other_service, services_copy[0]);
+}
+
+TEST_F(StrongBindingSetTest, Destroy) {
+  EXPECT_EQ(0u, services().size());
+  EXPECT_TRUE(services().empty());
+
+  std::vector<SampleServiceImpl*> services_copy(services().begin(),
+                                                services().end());
+  EXPECT_TRUE(services_copy.empty());
+
+  base::RunLoop run_loop;
+  sample::ServicePtr service_ptr;
+  SampleServiceImpl* service = CreateService(mojo::GetProxy(&service_ptr));
+  sample::ServicePtr other_service_ptr;
+  CreateService(mojo::GetProxy(&other_service_ptr));
+  EXPECT_EQ(2u, num_instances());
+  EXPECT_EQ(2u, services().size());
+  EXPECT_FALSE(services().empty());
+
+  services_copy =
+      std::vector<SampleServiceImpl*>(services().begin(), services().end());
+  EXPECT_EQ(2u, services_copy.size());
+  mutable_services().DestroyService(service);
+  EXPECT_EQ(1u, num_instances());
+  EXPECT_EQ(1u, services().size());
+  EXPECT_FALSE(services().empty());
+
+  services_copy =
+      std::vector<SampleServiceImpl*>(services().begin(), services().end());
+  EXPECT_EQ(1u, services_copy.size());
+
+  service_ptr.set_connection_error_handler(run_loop.QuitClosure());
+  other_service_ptr.set_connection_error_handler(run_loop.QuitClosure());
+  run_loop.Run();
+}
+
+TEST_F(StrongBindingSetTest, Clear) {
+  EXPECT_EQ(0u, services().size());
+  EXPECT_TRUE(services().empty());
+
+  std::vector<SampleServiceImpl*> services_copy(services().begin(),
+                                                services().end());
+  EXPECT_TRUE(services_copy.empty());
+
+  sample::ServicePtr service_ptr;
+  CreateService(mojo::GetProxy(&service_ptr));
+  EXPECT_EQ(1u, num_instances());
+  EXPECT_EQ(1u, services().size());
+  EXPECT_FALSE(services().empty());
+
+  services_copy =
+      std::vector<SampleServiceImpl*>(services().begin(), services().end());
+  EXPECT_EQ(1u, services_copy.size());
+  mutable_services().Clear();
+  EXPECT_EQ(0u, num_instances());
+  EXPECT_EQ(0u, services().size());
+  EXPECT_TRUE(services().empty());
+
+  services_copy =
+      std::vector<SampleServiceImpl*>(services().begin(), services().end());
+  EXPECT_TRUE(services_copy.empty());
+
+  base::RunLoop run_loop;
+  service_ptr.set_connection_error_handler(run_loop.QuitClosure());
+  run_loop.Run();
+}
+
+}  // namespace mojo