Global Resource Coordinator: Basic service internals

services/resource_coordinator/resource_coordinator_service.cc

+// Copyright 2017 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 "services/resource_coordinator/resource_coordinator_service.h"
+
+#include "base/macros.h"
+#include "services/resource_coordinator/coordination_unit/coordination_unit_provider_impl.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
+#include "services/service_manager/public/cpp/service_context.h"
+
+namespace resource_coordinator {
+
+namespace {
+
+void OnConnectionLost(std::unique_ptr<service_manager::ServiceContextRef> ref) {
+  // No-op. This merely takes ownership of |ref| so it can be destroyed when
+  // this function is invoked.
+}
+
+}  // namespace
+
+std::unique_ptr<service_manager::Service> ResourceCoordinatorService::Create() {
+  return base::MakeUnique<ResourceCoordinatorService>();
+}
+
+ResourceCoordinatorService::ResourceCoordinatorService()
+    : weak_factory_(this) {}
+
+ResourceCoordinatorService::~ResourceCoordinatorService() = default;
+
+void ResourceCoordinatorService::OnStart() {
+  ref_factory_.reset(new service_manager::ServiceContextRefFactory(
+      base::Bind(&service_manager::ServiceContext::RequestQuit,
+                 base::Unretained(context()))));
+}
+
+bool ResourceCoordinatorService::OnConnect(

[Ken Rockot(use gerrit already), 2017/04/10 23:58:00]

Please just implement OnBindInterface instead of OnConnect, and have client code
use BindInterface. You can own your own single InterfaceRegistry which you
initialize in the ctor instead (and forward incoming OnBindInterface args to
InterfaceRegistry::BindInterface). Then there's no need to do this stupid junk
with the OnConnectionLost to keep alive the service. We plan to delete the
concept of a service "connection" and thus delete Service::OnConnect.

[oystein (OOO til 10th of July), 2017/04/12 19:15:31]

Done.

+    const service_manager::ServiceInfo& remote_info,
+    service_manager::InterfaceRegistry* registry) {
+  // Add a reference to the service and tie it to the lifetime of the
+  // InterfaceRegistry's connection.
+  std::unique_ptr<service_manager::ServiceContextRef> connection_ref =
+      ref_factory_->CreateRef();
+  registry->AddConnectionLostClosure(
+      base::Bind(&OnConnectionLost, base::Passed(&connection_ref)));
+  registry->AddInterface(base::Bind(&CoordinationUnitProviderImpl::Create,
+                                    base::Unretained(ref_factory_.get())));
+  return true;
+}
+
+}  // namespace speed