Service Manager: Rework Service and ServiceContext lifetime

content/common/service_manager/service_manager_connection_impl.cc

 // Copyright 2016 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 "content/common/service_manager/service_manager_connection_impl.h"
 
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_checker.h"
 #include "content/common/service_manager/embedded_service_runner.h"
 #include "content/public/common/connection_filter.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/system/message_pipe.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/interfaces/service_factory.mojom.h"
 #include "services/service_manager/runner/common/client_util.h"
 
 namespace content {
 namespace {
 
 base::LazyInstance<std::unique_ptr<ServiceManagerConnection>>::Leaky
     g_connection_for_process = LAZY_INSTANCE_INITIALIZER;
@@ skipping 87 matching lines @@
       const service_manager::InterfaceRegistry::Binder& binder) {
     DCHECK(!started_);
     default_browser_binder_ = base::Bind(
         &IOThreadContext::CallBinderOnTaskRunner,
         base::ThreadTaskRunnerHandle::Get(), binder);
   }
 
  private:
   friend class base::RefCountedThreadSafe<IOThreadContext>;
 
+  // A forwarding service_manager::Service implementation to account for the
+  // fact that IOThreadContext is a Service which owns its ServiceContext, but
+  // ServiceContext should own its Service.
+  //
+  // TODO(rockot): Clean this up.
+  class ForwardingServiceImpl : public service_manager::Service {
+   public:
+    explicit ForwardingServiceImpl(service_manager::Service* service)
+        : service_(service) {}
+    ~ForwardingServiceImpl() override {}
+
+    // service_manager::Service:
+    void OnStart(service_manager::ServiceContext* context) override {
+      service_->OnStart(context);
+    }
+
+    bool OnConnect(const service_manager::ServiceInfo& remote_info,
+                   service_manager::InterfaceRegistry* registry) override {
+      return service_->OnConnect(remote_info, registry);
+    }
+
+    bool OnStop() override { return service_->OnStop(); }
+
+   private:
+    service_manager::Service* const service_;
+    DISALLOW_COPY_AND_ASSIGN(ForwardingServiceImpl);
+  };
+
   class MessageLoopObserver : public base::MessageLoop::DestructionObserver {
    public:
     explicit MessageLoopObserver(base::WeakPtr<IOThreadContext> context)
         : context_(context) {
       base::MessageLoop::current()->AddDestructionObserver(this);
     }
 
     ~MessageLoopObserver() override {
       base::MessageLoop::current()->RemoveDestructionObserver(this);
     }
@@ skipping 22 matching lines @@
 
     DISALLOW_COPY_AND_ASSIGN(MessageLoopObserver);
   };
 
   ~IOThreadContext() override {}
 
   void StartOnIOThread() {
     // Should bind |io_thread_checker_| to the context's thread.
     DCHECK(io_thread_checker_.CalledOnValidThread());
     service_context_.reset(new service_manager::ServiceContext(
-        this, std::move(pending_service_request_),
+        base::MakeUnique<ForwardingServiceImpl>(this),
+        std::move(pending_service_request_),
         std::move(io_thread_connector_),
         std::move(pending_connector_request_)));
 
     // MessageLoopObserver owns itself.
     message_loop_observer_ =
         new MessageLoopObserver(weak_factory_.GetWeakPtr());
   }
 
   void ShutDownOnIOThread() {
     DCHECK(io_thread_checker_.CalledOnValidThread());
@@ skipping 32 matching lines @@
   }
 
   void OnBrowserConnectionLost() {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     has_browser_connection_ = false;
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // service_manager::Service implementation
 
-  void OnStart(const service_manager::ServiceInfo& info) override {
+  void OnStart(service_manager::ServiceContext* context) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
     DCHECK(!initialize_handler_.is_null());
-    local_info_ = info;
+    local_info_ = context->local_info();
 
     InitializeCallback handler = base::ResetAndReturn(&initialize_handler_);
     callback_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(handler, local_info_.identity));
   }
 
   bool OnConnect(const service_manager::ServiceInfo& remote_info,
                  service_manager::InterfaceRegistry* registry) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
 
@@ skipping 298 matching lines @@
 
 void ServiceManagerConnectionImpl::GetInterface(
     service_manager::mojom::InterfaceProvider* provider,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle request_handle) {
   provider->GetInterface(interface_name, std::move(request_handle));
 }
 
 }  // namespace content