NOCOMMIT prototype: GRC service plumbing and process priority

services/resource_coordinator/resource_coordinator_service.cc

Index: services/resource_coordinator/resource_coordinator_service.cc
diff --git a/services/resource_coordinator/resource_coordinator_service.cc b/services/resource_coordinator/resource_coordinator_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..804f580ca9e62cbbadb4c73f516728468c7179a8
--- /dev/null
+++ b/services/resource_coordinator/resource_coordinator_service.cc
@@ -0,0 +1,51 @@
+// 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_provider.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(
+    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 =

[Ken Rockot(use gerrit already), 2017/03/15 22:51:55]

So as a preface, the ServiceContextRef stuff is kind of unfortunate, but we
don't yet have a better way of essentially ref-counting the service itself to
keep track of whether or not it's still in use. The idea is once the ref count
(i.e. the number of ServiceContextRef instances) goes to zero, we automatically
call RequestQuit and signal to the Service Manager that it can shut us down.

That means that in order to use it properly, you essentially need to hold a
corresponding ServiceContextRef for every active binding in your service.
Otherwise you may get killed while someone is still connected to one of your
interfaces.

So you'll want to provide CoordinationUnitProvider::Create with a reference to
ref_factory_, and have the impl call CreateRef and retain the returned
ServiceContextRef. You'll want to do the same thing for every CoordinationUnit
as well, passing a new ServiceContextRef into its constructor along with the
incoming CoordinationUnit request.

This is an unhappy situation and I'd like to find a way to hide all these
details and essentially automate the bookkeeping (e.g. by automatically tagging
incoming InterfaceRequests with some context, and having that propagate to
bindings), but for now it's the thing to do.

+      ref_factory_->CreateRef();
+  registry->AddConnectionLostClosure(
+      base::Bind(&OnConnectionLost, base::Passed(&connection_ref)));
+  registry->AddInterface(base::Bind(&CoordinationUnitProvider::Create));
+  return true;
+}
+
+}  // namespace speed