Make Service own ServiceContext.

services/shell/tests/lifecycle/lifecycle_unittest.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 <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 20 matching lines @@
 void QuitLoop(base::RunLoop* loop) {
   loop->Quit();
 }
 
 void DecrementCountAndQuitWhenZero(base::RunLoop* loop, size_t* count) {
   if (!--(*count))
     loop->Quit();
 }
 
 struct Instance {
-  Instance() : id(mojom::kInvalidInstanceID), pid(0) {}
-  Instance(const Identity& identity, uint32_t id, uint32_t pid)
-      : identity(identity), id(id), pid(pid) {}
+  Instance() : pid(0) {}
+  Instance(const Identity& identity, uint32_t pid)
+      : identity(identity), pid(pid) {}
 
   Identity identity;
-  uint32_t id;
   uint32_t pid;
 };
 
 class InstanceState : public mojom::ServiceManagerListener {
  public:
   InstanceState(mojom::ServiceManagerListenerRequest request,
                 base::RunLoop* loop)
       : binding_(this, std::move(request)), loop_(loop) {}
   ~InstanceState() override {}
 
   bool HasInstanceForName(const std::string& name) const {
     return instances_.find(name) != instances_.end();
   }
   size_t GetNewInstanceCount() const {
     return instances_.size() - initial_instances_.size();
   }
   void WaitForInstanceDestruction(base::RunLoop* loop) {
     DCHECK(!destruction_loop_);
     destruction_loop_ = loop;
     // First of all check to see if we should be spinning this loop at all -
     // the app(s) we're waiting on quitting may already have quit.
     TryToQuitDestructionLoop();
   }
 
  private:
   // mojom::ServiceManagerListener:
   void OnInit(mojo::Array<mojom::ServiceInfoPtr> instances) override {
     for (const auto& instance : instances) {
-      Instance i(instance->identity.To<Identity>(), instance->id,
-                 instance->pid);
+      Instance i(instance->identity.To<Identity>(), instance->pid);
       initial_instances_[i.identity.name()] = i;
       instances_[i.identity.name()] = i;
     }
     loop_->Quit();
   }
   void OnServiceCreated(mojom::ServiceInfoPtr instance) override {
     instances_[instance->identity->name] =
-        Instance(instance->identity.To<Identity>(), instance->id,
-                 instance->pid);
+        Instance(instance->identity.To<Identity>(), instance->pid);
   }
-  void OnServiceStarted(uint32_t id, uint32_t pid) override {
+  void OnServiceStarted(mojom::IdentityPtr identity_ptr,
+                        uint32_t pid) override {
+    Identity identity = identity_ptr.To<Identity>();
     for (auto& instance : instances_) {
-      if (instance.second.id == id) {
+      if (instance.second.identity == identity) {
         instance.second.pid = pid;
         break;
       }
     }
   }
-  void OnServiceStopped(uint32_t id) override {
+  void OnServiceStopped(mojom::IdentityPtr identity_ptr) override {
+    Identity identity = identity_ptr.To<Identity>();
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
-      if (it->second.id == id) {
+      if (it->second.identity == identity) {
         instances_.erase(it);
         break;
       }
     }
     TryToQuitDestructionLoop();
   }
 
   void TryToQuitDestructionLoop() {
     if (!GetNewInstanceCount() && destruction_loop_) {
       destruction_loop_->Quit();
@@ skipping 337 matching lines @@
   parent->Quit();
 
   // Quitting the parent should cascade-quit the child.
   WaitForInstanceDestruction();
   EXPECT_EQ(0u, instances()->GetNewInstanceCount());
   EXPECT_FALSE(instances()->HasInstanceForName(kTestParentName));
   EXPECT_FALSE(instances()->HasInstanceForName(kTestAppName));
 }
 
 }  // namespace shell