Migrate resource_coordinator to new service APIs

Migrates resource_coordinator away from the deprecated ServiceContext
API to ServiceBinding, and migrates its tests from the deprecated
ServiceTest framework to regular unit tests.

Bug: 891780,906239
Change-Id: I308746a7fc02402ec78d59f03c2c06395bc79b5c
Reviewed-on: https://chromium-review.googlesource.com/c/1351775
Commit-Queue: Ken Rockot <rockot@google.com>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: oysteine <oysteine@chromium.org>
Cr-Commit-Position: refs/heads/master@{#612072}

content/browser/service_manager/service_manager_context.cc

@@ -631,11 +631,13 @@ ServiceManagerContext::ServiceManagerContext(
       std::move(root_browser_service), mojo::MakeRequest(&pid_receiver));
   pid_receiver->SetPID(base::GetCurrentProcId());
 
-  service_manager::EmbeddedServiceInfo resource_coordinator_info;
-  resource_coordinator_info.factory =
-      base::Bind(&resource_coordinator::ResourceCoordinatorService::Create);
-  packaged_services_connection_->AddEmbeddedService(
-      resource_coordinator::mojom::kServiceName, resource_coordinator_info);
+  packaged_services_connection_->AddServiceRequestHandler(
+      resource_coordinator::mojom::kServiceName,
+      base::BindRepeating([](service_manager::mojom::ServiceRequest request) {
+        service_manager::Service::RunUntilTermination(
+            std::make_unique<resource_coordinator::ResourceCoordinatorService>(
+                std::move(request)));
+      }));
 
   if (media_session::IsMediaSessionEnabled()) {
     service_manager::EmbeddedServiceInfo media_session_info;

services/BUILD.gn

@@ -100,7 +100,6 @@ if (!is_ios) {
 
     catalog_deps = [
       "//services/preferences:tests_catalog",
-      "//services/resource_coordinator:tests_catalog",
       "//services/video_capture:tests_catalog",
       "//services/viz:tests_catalog",
     ]

services/resource_coordinator/BUILD.gn

@@ -2,14 +2,11 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import("//services/service_manager/public/service_manifest.gni")
+
 # There should be only one resource coordinator. It is currently
 # in the browser process. So, only //content/browser should link to this target.
 # Others modules should only need the public targets.
-import("//services/catalog/public/tools/catalog.gni")
-import("//services/service_manager/public/cpp/service.gni")
-import("//services/service_manager/public/service_manifest.gni")
-import("//services/service_manager/public/tools/test/service_test.gni")
-
 source_set("lib") {
   sources = [
     "coordination_unit/coordination_unit_base.cc",
@@ -79,17 +76,6 @@ service_manifest("manifest") {
   source = "manifest.json"
 }
 
-service("resource_coordinator") {
-  sources = [
-    "service_main.cc",
-  ]
-
-  deps = [
-    ":lib",
-    "//mojo/public/cpp/system",
-  ]
-}
-
 source_set("tests") {
   testonly = true
 
@@ -131,25 +117,9 @@ source_set("tests") {
     "//mojo/public/cpp/bindings",
     "//services/resource_coordinator/public/cpp:resource_coordinator_cpp",
     "//services/service_manager/public/cpp",
-    "//services/service_manager/public/cpp:service_test_support",
+    "//services/service_manager/public/cpp/test:test_support",
     "//services/service_manager/public/mojom",
     "//testing/gmock",
     "//testing/gtest",
   ]
-
-  data_deps = [
-    ":resource_coordinator",
-    ":lib",
-  ]
-}
-
-service_manifest("unittest_manifest") {
-  name = "resource_coordinator_unittests"
-  source = "unittest_manifest.json"
-}
-
-catalog("tests_catalog") {
-  testonly = true
-  embedded_services = [ ":unittest_manifest" ]
-  standalone_services = [ ":manifest" ]
 }

services/resource_coordinator/OWNERS

@@ -9,6 +9,3 @@ per-file BUILD.gn=file://services/resource_coordinator/memory_instrumentation/OW
 
 per-file manifest.json=set noparent
 per-file manifest.json=file://ipc/SECURITY_OWNERS
-
-per-file unittest_manifest.json=set noparent
-per-file unittest_manifest.json=file://ipc/SECURITY_OWNERS

services/resource_coordinator/coordination_unit/coordination_unit_base.h

@@ -18,7 +18,7 @@
 #include "services/resource_coordinator/public/cpp/coordination_unit_types.h"
 #include "services/resource_coordinator/public/mojom/coordination_unit.mojom.h"
 #include "services/resource_coordinator/public/mojom/coordination_unit_provider.mojom.h"
-#include "services/service_manager/public/cpp/service_context_ref.h"
+#include "services/service_manager/public/cpp/service_keepalive.h"
 
 namespace resource_coordinator {
 
@@ -89,10 +89,10 @@ class CoordinationUnitInterface : public CoordinationUnitBase,
   static CoordinationUnitClass* Create(
       const CoordinationUnitID& id,
       CoordinationUnitGraph* graph,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref) {
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref) {
     std::unique_ptr<CoordinationUnitClass> new_cu =
         std::make_unique<CoordinationUnitClass>(id, graph,
-                                                std::move(service_ref));
+                                                std::move(keepalive_ref));
     return static_cast<CoordinationUnitClass*>(
         PassOwnershipToGraph(std::move(new_cu)));
   }
@@ -113,9 +113,9 @@ class CoordinationUnitInterface : public CoordinationUnitBase,
       const CoordinationUnitID& id,
       CoordinationUnitGraph* graph,
 
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref)
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref)
       : CoordinationUnitBase(id, graph), binding_(this) {
-    service_ref_ = std::move(service_ref);
+    keepalive_ref_ = std::move(keepalive_ref);
   }
 
   ~CoordinationUnitInterface() override = default;
@@ -146,7 +146,7 @@ class CoordinationUnitInterface : public CoordinationUnitBase,
  private:
   mojo::BindingSet<MojoInterfaceClass> bindings_;
   mojo::Binding<MojoInterfaceClass> binding_;
-  std::unique_ptr<service_manager::ServiceContextRef> service_ref_;
+  std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref_;
 
   DISALLOW_COPY_AND_ASSIGN(CoordinationUnitInterface);
 };

services/resource_coordinator/coordination_unit/coordination_unit_base_unittest.cc

@@ -9,7 +9,6 @@
 #include "services/resource_coordinator/coordination_unit/page_coordination_unit_impl.h"
 #include "services/resource_coordinator/coordination_unit/process_coordination_unit_impl.h"
 #include "services/resource_coordinator/public/mojom/coordination_unit.mojom.h"
-#include "services/service_manager/public/cpp/service_context_ref.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace resource_coordinator {

services/resource_coordinator/coordination_unit/coordination_unit_graph.cc

@@ -49,10 +49,9 @@ CoordinationUnitGraph::~CoordinationUnitGraph() {
 void CoordinationUnitGraph::OnStart(
     service_manager::BinderRegistryWithArgs<
         const service_manager::BindSourceInfo&>* registry,
-    service_manager::ServiceContextRefFactory* service_ref_factory) {
+    service_manager::ServiceKeepalive* keepalive) {
   // Create the singleton CoordinationUnitProvider.
-  provider_ =
-      std::make_unique<CoordinationUnitProviderImpl>(service_ref_factory, this);
+  provider_ = std::make_unique<CoordinationUnitProviderImpl>(keepalive, this);
   registry->AddInterface(base::BindRepeating(
       &CoordinationUnitProviderImpl::Bind, base::Unretained(provider_.get())));
 }
@@ -80,26 +79,26 @@ void CoordinationUnitGraph::OnBeforeCoordinationUnitDestroyed(
 
 FrameCoordinationUnitImpl* CoordinationUnitGraph::CreateFrameCoordinationUnit(
     const CoordinationUnitID& id,
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref) {
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref) {
   return FrameCoordinationUnitImpl::Create(id, this, std::move(service_ref));
 }
 
 PageCoordinationUnitImpl* CoordinationUnitGraph::CreatePageCoordinationUnit(
     const CoordinationUnitID& id,
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref) {
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref) {
   return PageCoordinationUnitImpl::Create(id, this, std::move(service_ref));
 }
 
 ProcessCoordinationUnitImpl*
 CoordinationUnitGraph::CreateProcessCoordinationUnit(
     const CoordinationUnitID& id,
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref) {
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref) {
   return ProcessCoordinationUnitImpl::Create(id, this, std::move(service_ref));
 }
 
 SystemCoordinationUnitImpl*
 CoordinationUnitGraph::FindOrCreateSystemCoordinationUnit(
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref) {
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref) {
   CoordinationUnitBase* system_cu =
       GetCoordinationUnitByID(system_coordination_unit_id_);
   if (system_cu)

services/resource_coordinator/coordination_unit/coordination_unit_graph.h

@@ -17,13 +17,12 @@
 #include "services/metrics/public/cpp/ukm_recorder.h"
 #include "services/resource_coordinator/public/cpp/coordination_unit_id.h"
 #include "services/resource_coordinator/public/cpp/coordination_unit_types.h"
-#include "services/service_manager/public/cpp/service_context_ref.h"
+#include "services/service_manager/public/cpp/service_keepalive.h"
 
 namespace service_manager {
 template <typename... BinderArgs>
 class BinderRegistryWithArgs;
 struct BindSourceInfo;
-class ServiceContextRefFactory;
 }  // namespace service_manager
 
 namespace resource_coordinator {
@@ -52,7 +51,7 @@ class CoordinationUnitGraph {
 
   void OnStart(service_manager::BinderRegistryWithArgs<
                    const service_manager::BindSourceInfo&>* registry,
-               service_manager::ServiceContextRefFactory* service_ref_factory);
+               service_manager::ServiceKeepalive* keepalive);
   void RegisterObserver(
       std::unique_ptr<CoordinationUnitGraphObserver> observer);
   void OnCoordinationUnitCreated(CoordinationUnitBase* coordination_unit);
@@ -61,15 +60,15 @@ class CoordinationUnitGraph {
 
   FrameCoordinationUnitImpl* CreateFrameCoordinationUnit(
       const CoordinationUnitID& id,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref);
   PageCoordinationUnitImpl* CreatePageCoordinationUnit(
       const CoordinationUnitID& id,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref);
   ProcessCoordinationUnitImpl* CreateProcessCoordinationUnit(
       const CoordinationUnitID& id,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref);
   SystemCoordinationUnitImpl* FindOrCreateSystemCoordinationUnit(
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> service_ref);
 
   std::vector<ProcessCoordinationUnitImpl*> GetAllProcessCoordinationUnits();
   std::vector<FrameCoordinationUnitImpl*> GetAllFrameCoordinationUnits();
@@ -112,8 +111,7 @@ class CoordinationUnitGraph {
   ukm::UkmRecorder* ukm_recorder_ = nullptr;
   std::unique_ptr<CoordinationUnitProviderImpl> provider_;
 
-  static void Create(
-      service_manager::ServiceContextRefFactory* service_ref_factory);
+  static void Create(service_manager::ServiceKeepalive* keepalive);
 
   DISALLOW_COPY_AND_ASSIGN(CoordinationUnitGraph);
 };

services/resource_coordinator/coordination_unit/coordination_unit_provider_impl.cc

@@ -13,17 +13,16 @@
 #include "services/resource_coordinator/coordination_unit/process_coordination_unit_impl.h"
 #include "services/resource_coordinator/coordination_unit/system_coordination_unit_impl.h"
 #include "services/service_manager/public/cpp/bind_source_info.h"
-#include "services/service_manager/public/cpp/service_context_ref.h"
 
 namespace resource_coordinator {
 
 CoordinationUnitProviderImpl::CoordinationUnitProviderImpl(
-    service_manager::ServiceContextRefFactory* service_ref_factory,
+    service_manager::ServiceKeepalive* service_keepalive,
     CoordinationUnitGraph* coordination_unit_graph)
-    : service_ref_factory_(service_ref_factory),
+    : service_keepalive_(service_keepalive),
       coordination_unit_graph_(coordination_unit_graph) {
-  DCHECK(service_ref_factory);
-  service_ref_ = service_ref_factory->CreateRef();
+  DCHECK(service_keepalive_);
+  keepalive_ref_ = service_keepalive_->CreateRef();
 }
 
 CoordinationUnitProviderImpl::~CoordinationUnitProviderImpl() = default;
@@ -38,7 +37,7 @@ void CoordinationUnitProviderImpl::CreateFrameCoordinationUnit(
     const CoordinationUnitID& id) {
   FrameCoordinationUnitImpl* frame_cu =
       coordination_unit_graph_->CreateFrameCoordinationUnit(
-          id, service_ref_factory_->CreateRef());
+          id, service_keepalive_->CreateRef());
 
   frame_cu->Bind(std::move(request));
   auto& frame_cu_binding = frame_cu->binding();
@@ -53,7 +52,7 @@ void CoordinationUnitProviderImpl::CreatePageCoordinationUnit(
     const CoordinationUnitID& id) {
   PageCoordinationUnitImpl* page_cu =
       coordination_unit_graph_->CreatePageCoordinationUnit(
-          id, service_ref_factory_->CreateRef());
+          id, service_keepalive_->CreateRef());
 
   page_cu->Bind(std::move(request));
   auto& page_cu_binding = page_cu->binding();
@@ -68,7 +67,7 @@ void CoordinationUnitProviderImpl::CreateProcessCoordinationUnit(
     const CoordinationUnitID& id) {
   ProcessCoordinationUnitImpl* process_cu =
       coordination_unit_graph_->CreateProcessCoordinationUnit(
-          id, service_ref_factory_->CreateRef());
+          id, service_keepalive_->CreateRef());
 
   process_cu->Bind(std::move(request));
   auto& process_cu_binding = process_cu->binding();
@@ -82,7 +81,7 @@ void CoordinationUnitProviderImpl::GetSystemCoordinationUnit(
     resource_coordinator::mojom::SystemCoordinationUnitRequest request) {
   // Simply fetch the existing SystemCU and add an additional binding to it.
   coordination_unit_graph_
-      ->FindOrCreateSystemCoordinationUnit(service_ref_factory_->CreateRef())
+      ->FindOrCreateSystemCoordinationUnit(service_keepalive_->CreateRef())
       ->AddBinding(std::move(request));
 }
 

services/resource_coordinator/coordination_unit/coordination_unit_provider_impl.h

@@ -12,11 +12,10 @@
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/resource_coordinator/coordination_unit/coordination_unit_graph.h"
 #include "services/resource_coordinator/public/mojom/coordination_unit_provider.mojom.h"
+#include "services/service_manager/public/cpp/service_keepalive.h"
 
 namespace service_manager {
 struct BindSourceInfo;
-class ServiceContextRefFactory;
-class ServiceContextRef;
 }  // service_manager
 
 namespace resource_coordinator {
@@ -24,7 +23,7 @@ namespace resource_coordinator {
 class CoordinationUnitProviderImpl : public mojom::CoordinationUnitProvider {
  public:
   CoordinationUnitProviderImpl(
-      service_manager::ServiceContextRefFactory* service_ref_factory,
+      service_manager::ServiceKeepalive* service_keepalive,
       CoordinationUnitGraph* coordination_unit_graph);
   ~CoordinationUnitProviderImpl() override;
 
@@ -49,8 +48,8 @@ class CoordinationUnitProviderImpl : public mojom::CoordinationUnitProvider {
       override;
 
  private:
-  service_manager::ServiceContextRefFactory* service_ref_factory_;
-  std::unique_ptr<service_manager::ServiceContextRef> service_ref_;
+  service_manager::ServiceKeepalive* const service_keepalive_;
+  std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref_;
   CoordinationUnitGraph* coordination_unit_graph_;
   mojo::BindingSet<mojom::CoordinationUnitProvider> bindings_;
 

services/resource_coordinator/coordination_unit/coordination_unit_test_harness.cc

@@ -9,20 +9,12 @@
 
 namespace resource_coordinator {
 
-namespace {
-
-void OnLastServiceRefDestroyed() {
-  // No-op. This is required by service_manager::ServiceContextRefFactory
-  // construction but not needed for the tests.
-}
-
-}  // namespace
-
 CoordinationUnitTestHarness::CoordinationUnitTestHarness()
     : task_env_(base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME,
                 base::test::ScopedTaskEnvironment::ExecutionMode::QUEUED),
-      service_ref_factory_(base::Bind(&OnLastServiceRefDestroyed)),
-      provider_(&service_ref_factory_, &coordination_unit_graph_) {}
+      service_keepalive_(static_cast<service_manager::ServiceBinding*>(nullptr),
+                         base::nullopt /* idle_timeout */),
+      provider_(&service_keepalive_, &coordination_unit_graph_) {}
 
 CoordinationUnitTestHarness::~CoordinationUnitTestHarness() = default;
 

services/resource_coordinator/coordination_unit/coordination_unit_test_harness.h

@@ -13,7 +13,7 @@
 #include "services/resource_coordinator/coordination_unit/coordination_unit_graph.h"
 #include "services/resource_coordinator/coordination_unit/coordination_unit_provider_impl.h"
 #include "services/resource_coordinator/coordination_unit/system_coordination_unit_impl.h"
-#include "services/service_manager/public/cpp/service_context_ref.h"
+#include "services/service_manager/public/cpp/service_keepalive.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace resource_coordinator {
@@ -60,7 +60,7 @@ class CoordinationUnitTestHarness : public testing::Test {
       CoordinationUnitID cu_id) {
     return TestCoordinationUnitWrapper<CoordinationUnitClass>(
         CoordinationUnitClass::Create(cu_id, coordination_unit_graph(),
-                                      service_ref_factory_.CreateRef()));
+                                      service_keepalive_.CreateRef()));
   }
 
   template <class CoordinationUnitClass>
@@ -74,7 +74,7 @@ class CoordinationUnitTestHarness : public testing::Test {
   GetSystemCoordinationUnit() {
     return TestCoordinationUnitWrapper<SystemCoordinationUnitImpl>(
         coordination_unit_graph()->FindOrCreateSystemCoordinationUnit(
-            service_ref_factory_.CreateRef()));
+            service_keepalive_.CreateRef()));
   }
 
   // testing::Test:
@@ -84,9 +84,6 @@ class CoordinationUnitTestHarness : public testing::Test {
   base::test::ScopedTaskEnvironment& task_env() {
     return task_env_;
   }
-  service_manager::ServiceContextRefFactory* service_context_ref_factory() {
-    return &service_ref_factory_;
-  }
   CoordinationUnitGraph* coordination_unit_graph() {
     return &coordination_unit_graph_;
   }
@@ -94,7 +91,7 @@ class CoordinationUnitTestHarness : public testing::Test {
 
  private:
   base::test::ScopedTaskEnvironment task_env_;
-  service_manager::ServiceContextRefFactory service_ref_factory_;
+  service_manager::ServiceKeepalive service_keepalive_;
   CoordinationUnitGraph coordination_unit_graph_;
   CoordinationUnitProviderImpl provider_;
 };

services/resource_coordinator/coordination_unit/frame_coordination_unit_impl.cc

@@ -14,8 +14,8 @@ namespace resource_coordinator {
 FrameCoordinationUnitImpl::FrameCoordinationUnitImpl(
     const CoordinationUnitID& id,
     CoordinationUnitGraph* graph,
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref)
-    : CoordinationUnitInterface(id, graph, std::move(service_ref)),
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref)
+    : CoordinationUnitInterface(id, graph, std::move(keepalive_ref)),
       parent_frame_coordination_unit_(nullptr),
       page_coordination_unit_(nullptr),
       process_coordination_unit_(nullptr) {}

services/resource_coordinator/coordination_unit/frame_coordination_unit_impl.h

@@ -26,7 +26,7 @@ class FrameCoordinationUnitImpl
   FrameCoordinationUnitImpl(
       const CoordinationUnitID& id,
       CoordinationUnitGraph* graph,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref);
   ~FrameCoordinationUnitImpl() override;
 
   // FrameCoordinationUnit implementation.

services/resource_coordinator/coordination_unit/mock_coordination_unit_graphs.cc

@@ -14,10 +14,6 @@
 #include "services/resource_coordinator/public/cpp/coordination_unit_id.h"
 #include "services/resource_coordinator/public/cpp/coordination_unit_types.h"
 
-namespace service_manager {
-class ServiceContextRef;
-}
-
 namespace resource_coordinator {
 
 MockSinglePageInSingleProcessCoordinationUnitGraph::

services/resource_coordinator/coordination_unit/page_coordination_unit_impl.cc

@@ -16,8 +16,8 @@ namespace resource_coordinator {
 PageCoordinationUnitImpl::PageCoordinationUnitImpl(
     const CoordinationUnitID& id,
     CoordinationUnitGraph* graph,
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref)
-    : CoordinationUnitInterface(id, graph, std::move(service_ref)) {}
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref)
+    : CoordinationUnitInterface(id, graph, std::move(keepalive_ref)) {}
 
 PageCoordinationUnitImpl::~PageCoordinationUnitImpl() {
   for (auto* child_frame : frame_coordination_units_)

services/resource_coordinator/coordination_unit/page_coordination_unit_impl.h

@@ -24,7 +24,7 @@ class PageCoordinationUnitImpl
   PageCoordinationUnitImpl(
       const CoordinationUnitID& id,
       CoordinationUnitGraph* graph,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref);
   ~PageCoordinationUnitImpl() override;
 
   // mojom::PageCoordinationUnit implementation.

services/resource_coordinator/coordination_unit/process_coordination_unit_impl.cc

@@ -13,8 +13,8 @@ namespace resource_coordinator {
 ProcessCoordinationUnitImpl::ProcessCoordinationUnitImpl(
     const CoordinationUnitID& id,
     CoordinationUnitGraph* graph,
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref)
-    : CoordinationUnitInterface(id, graph, std::move(service_ref)) {}
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref)
+    : CoordinationUnitInterface(id, graph, std::move(keepalive_ref)) {}
 
 ProcessCoordinationUnitImpl::~ProcessCoordinationUnitImpl() {
   // Make as if we're transitioning to the null PID before we die to clear this

services/resource_coordinator/coordination_unit/process_coordination_unit_impl.h

@@ -35,7 +35,7 @@ class ProcessCoordinationUnitImpl
   ProcessCoordinationUnitImpl(
       const CoordinationUnitID& id,
       CoordinationUnitGraph* graph,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref);
   ~ProcessCoordinationUnitImpl() override;
 
   // mojom::ProcessCoordinationUnit implementation.

services/resource_coordinator/coordination_unit/system_coordination_unit_impl.cc

@@ -19,8 +19,8 @@ namespace resource_coordinator {
 SystemCoordinationUnitImpl::SystemCoordinationUnitImpl(
     const CoordinationUnitID& id,
     CoordinationUnitGraph* graph,
-    std::unique_ptr<service_manager::ServiceContextRef> service_ref)
-    : CoordinationUnitInterface(id, graph, std::move(service_ref)) {}
+    std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref)
+    : CoordinationUnitInterface(id, graph, std::move(keepalive_ref)) {}
 
 SystemCoordinationUnitImpl::~SystemCoordinationUnitImpl() = default;
 

services/resource_coordinator/coordination_unit/system_coordination_unit_impl.h

@@ -21,7 +21,7 @@ class SystemCoordinationUnitImpl
   SystemCoordinationUnitImpl(
       const CoordinationUnitID& id,
       CoordinationUnitGraph* graph,
-      std::unique_ptr<service_manager::ServiceContextRef> service_ref);
+      std::unique_ptr<service_manager::ServiceKeepaliveRef> keepalive_ref);
   ~SystemCoordinationUnitImpl() override;
 
   // mojom::SystemCoordinationUnit implementation:

services/resource_coordinator/resource_coordinator_service.cc

@@ -15,7 +15,6 @@
 #include "services/resource_coordinator/observers/metrics_collector.h"
 #include "services/resource_coordinator/observers/page_signal_generator_impl.h"
 #include "services/resource_coordinator/public/cpp/resource_coordinator_features.h"
-#include "services/service_manager/public/cpp/service_context.h"
 
 #if defined(OS_WIN)
 #include "services/resource_coordinator/observers/working_set_trimmer_win.h"
@@ -23,23 +22,16 @@
 
 namespace resource_coordinator {
 
-std::unique_ptr<service_manager::Service> ResourceCoordinatorService::Create() {
-  auto resource_coordinator_service =
-      std::make_unique<ResourceCoordinatorService>();
-
-  return resource_coordinator_service;
-}
-
-ResourceCoordinatorService::ResourceCoordinatorService()
-    : introspector_(&coordination_unit_graph_), weak_factory_(this) {}
+ResourceCoordinatorService::ResourceCoordinatorService(
+    service_manager::mojom::ServiceRequest request)
+    : service_binding_(this, std::move(request)),
+      service_keepalive_(&service_binding_, base::nullopt /* idle_timeout */),
+      introspector_(&coordination_unit_graph_) {}
 
 ResourceCoordinatorService::~ResourceCoordinatorService() = default;
 
 void ResourceCoordinatorService::OnStart() {
-  ref_factory_.reset(new service_manager::ServiceContextRefFactory(
-      context()->CreateQuitClosure()));
-
-  ukm_recorder_ = ukm::MojoUkmRecorder::Create(context()->connector());
+  ukm_recorder_ = ukm::MojoUkmRecorder::Create(service_binding_.GetConnector());
 
   registry_.AddInterface(
       base::Bind(&CoordinationUnitIntrospectorImpl::BindToInterface,
@@ -66,7 +58,7 @@ void ResourceCoordinatorService::OnStart() {
   }
 #endif
 
-  coordination_unit_graph_.OnStart(&registry_, ref_factory_.get());
+  coordination_unit_graph_.OnStart(&registry_, &service_keepalive_);
   coordination_unit_graph_.set_ukm_recorder(ukm_recorder_.get());
 
   // TODO(chiniforooshan): The abstract class Coordinator in the
@@ -76,7 +68,7 @@ void ResourceCoordinatorService::OnStart() {
   // memory_instrumentation::Coordinator.
   memory_instrumentation_coordinator_ =
       std::make_unique<memory_instrumentation::CoordinatorImpl>(
-          context()->connector());
+          service_binding_.GetConnector());
   registry_.AddInterface(base::BindRepeating(
       &memory_instrumentation::CoordinatorImpl::BindCoordinatorRequest,
       base::Unretained(memory_instrumentation_coordinator_.get())));

services/resource_coordinator/resource_coordinator_service.h

@@ -19,28 +19,24 @@
 #include "services/resource_coordinator/webui_graph_dump_impl.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/service.h"
-#include "services/service_manager/public/cpp/service_context_ref.h"
+#include "services/service_manager/public/cpp/service_binding.h"
+#include "services/service_manager/public/cpp/service_keepalive.h"
+#include "services/service_manager/public/mojom/service.mojom.h"
 
 namespace resource_coordinator {
 
 class ResourceCoordinatorService : public service_manager::Service {
  public:
-  ResourceCoordinatorService();
+  explicit ResourceCoordinatorService(
+      service_manager::mojom::ServiceRequest request);
   ~ResourceCoordinatorService() override;
 
-  // service_manager::Service:
-  // Factory function for use as an embedded service.
-  static std::unique_ptr<service_manager::Service> Create();
-
   // service_manager::Service:
   void OnStart() override;
   void OnBindInterface(const service_manager::BindSourceInfo& source_info,
                        const std::string& interface_name,
                        mojo::ScopedMessagePipeHandle interface_pipe) override;
 
-  service_manager::ServiceContextRefFactory* ref_factory() {
-    return ref_factory_.get();
-  }
   ukm::MojoUkmRecorder* ukm_recorder() { return ukm_recorder_.get(); }
   CoordinationUnitGraph* coordination_unit_graph() {
     return &coordination_unit_graph_;
@@ -51,6 +47,9 @@ class ResourceCoordinatorService : public service_manager::Service {
                           const service_manager::BindSourceInfo& source_info);
   void OnGraphDumpConnectionError(WebUIGraphDumpImpl* graph_dump);
 
+  service_manager::ServiceBinding service_binding_;
+  service_manager::ServiceKeepalive service_keepalive_;
+
   service_manager::BinderRegistryWithArgs<
       const service_manager::BindSourceInfo&>
       registry_;
@@ -59,14 +58,13 @@ class ResourceCoordinatorService : public service_manager::Service {
   std::unique_ptr<ukm::MojoUkmRecorder> ukm_recorder_;
   std::unique_ptr<memory_instrumentation::CoordinatorImpl>
       memory_instrumentation_coordinator_;
-  std::unique_ptr<service_manager::ServiceContextRefFactory> ref_factory_;
 
   // Current graph dump instances.
   std::vector<std::unique_ptr<WebUIGraphDumpImpl>> graph_dumps_;
 
   // WeakPtrFactory members should always come last so WeakPtrs are destructed
   // before other members.
-  base::WeakPtrFactory<ResourceCoordinatorService> weak_factory_;
+  base::WeakPtrFactory<ResourceCoordinatorService> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(ResourceCoordinatorService);
 };

services/resource_coordinator/resource_coordinator_service_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "base/macros.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/resource_coordinator/public/cpp/frame_resource_coordinator.h"
 #include "services/resource_coordinator/public/cpp/page_resource_coordinator.h"
@@ -13,15 +14,23 @@
 #include "services/resource_coordinator/public/cpp/system_resource_coordinator.h"
 #include "services/resource_coordinator/public/mojom/coordination_unit_provider.mojom.h"
 #include "services/resource_coordinator/public/mojom/service_constants.mojom.h"
-#include "services/service_manager/public/cpp/service.h"
-#include "services/service_manager/public/cpp/service_test.h"
+#include "services/resource_coordinator/resource_coordinator_service.h"
+#include "services/service_manager/public/cpp/test/test_connector_factory.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 namespace resource_coordinator {
 
-class ResourceCoordinatorTest : public service_manager::test::ServiceTest {
+class ResourceCoordinatorTest : public testing::Test {
  public:
   ResourceCoordinatorTest()
-      : service_manager::test::ServiceTest("resource_coordinator_unittests") {}
+      : service_(
+            test_connector_factory_.RegisterInstance(mojom::kServiceName)) {
+    // The resource_coordinator service may attempt to connect to the metrics
+    // service. Allow these requests to be silently ignored rather than
+    // bringing up or simulating the metrics service just for unit tests.
+    test_connector_factory_.set_ignore_unknown_service_requests(true);
+  }
+
   ~ResourceCoordinatorTest() override {}
 
   void GetIDCallback(const CoordinationUnitID& cu_id) {
@@ -53,7 +62,16 @@ class ResourceCoordinatorTest : public service_manager::test::ServiceTest {
     TestCUImpl<CoordinationUnitPtrType*>(cu);
   }
 
+ protected:
+  service_manager::Connector* connector() {
+    return test_connector_factory_.GetDefaultConnector();
+  }
+
  private:
+  base::test::ScopedTaskEnvironment task_environment_;
+  service_manager::TestConnectorFactory test_connector_factory_;
+  ResourceCoordinatorService service_;
+
   base::RunLoop* loop_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceCoordinatorTest);

services/resource_coordinator/service_main.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 "services/service_manager/public/c/main.h"
-#include "services/service_manager/public/cpp/service_runner.h"
-
-MojoResult ServiceMain(MojoHandle service_request_handle) {
-  return service_manager::ServiceRunner(
-             new resource_coordinator::ResourceCoordinatorService())
-      .Run(service_request_handle);
-}

services/resource_coordinator/unittest_manifest.json

-{
-  "name": "resource_coordinator_unittests",
-  "display_name": "Resource Coordinator Unittests",
-  "interface_provider_specs": {
-    "service_manager:connector": {
-      "requires": {
-        "resource_coordinator": [ "tests" ]
-      }
-    }
-  }
-}