Make "all user" services work when packaged.

services/service_manager/tests/service_manager/service_manager_unittest.cc

Index: services/service_manager/tests/service_manager/service_manager_unittest.cc
diff --git a/services/service_manager/tests/service_manager/service_manager_unittest.cc b/services/service_manager/tests/service_manager/service_manager_unittest.cc
index f834d63fd20e289a9b3d908856f36f9b42b09c4f..b6f7e2279f3dbe10aa9bba63811db8b381492911 100644
--- a/services/service_manager/tests/service_manager/service_manager_unittest.cc
+++ b/services/service_manager/tests/service_manager/service_manager_unittest.cc
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ -115,6 +116,19 @@ class ServiceManagerTest : public test::ServiceTest,
 
   const std::vector<InstanceInfo>& instances() const { return instances_; }
 
+  using ServiceStartedCallback =
+      base::Callback<void(const service_manager::Identity&)>;
+  void set_service_started_callback(const ServiceStartedCallback& callback) {
+    service_started_callback_ = callback;
+  }
+
+  using ServiceFailedToStartCallback =
+      base::Callback<void(const service_manager::Identity&)>;
+  void set_service_failed_to_start_callback(
+      const ServiceFailedToStartCallback& callback) {
+    service_failed_to_start_callback_ = callback;
+  }
+
  private:
   // test::ServiceTest:
   std::unique_ptr<Service> CreateService() override {
@@ -141,6 +155,13 @@ class ServiceManagerTest : public test::ServiceTest,
         break;
       }
     }
+    if (!service_started_callback_.is_null())
+        service_started_callback_.Run(identity);
+  }
+  void OnServiceFailedToStart(
+      const service_manager::Identity& identity) override {
+    if (!service_failed_to_start_callback_.is_null())
+        service_failed_to_start_callback_.Run(identity);
   }
   void OnServiceStopped(const service_manager::Identity& identity) override {
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
@@ -157,6 +178,8 @@ class ServiceManagerTest : public test::ServiceTest,
   std::vector<InstanceInfo> instances_;
   std::vector<InstanceInfo> initial_instances_;
   std::unique_ptr<base::RunLoop> wait_for_instances_loop_;
+  ServiceStartedCallback service_started_callback_;
+  ServiceFailedToStartCallback service_failed_to_start_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceManagerTest);
 };
@@ -206,4 +229,54 @@ TEST_F(ServiceManagerTest, CreateInstance) {
   base::RunLoop().Run();
 }
 
+void OnServiceStartedCallback(int* start_count,
+                              std::string* service_name,
+                              const service_manager::Identity& identity) {
+  (*start_count)++;
+  *service_name = identity.name();
+  base::MessageLoop::current()->QuitWhenIdle();

[Ken Rockot(use gerrit already), 2016/10/21 19:52:33]

nit: QuitWhenIdle() usage in tests is prone to flaky behavior. Would you mind
just updating these tests so that you pass an explicit quit closure around as
needed? e.g.

  void OnServiceStartedCallback(
      int* start_count,
      std::string* service_name,
      const service_manager::Identity& identity,
      const base::Closure& continuation) {
    (*start_count)++;
    *service_name = identity.name();
    continuation.Run();
  }

  {
    base::RunLoop loop;
    set_service_started_callback(base::BindRepeating(
        &OnServiceStartedClalback, &start_count, &service_name,
        loop.QuitClosure());

    // Do stuff...
    loop.Run();
  }

This makes the flow control explicit rather than relying on assumptions about
MessageLoop business.

[Jay Civelli, 2016/10/21 20:48:33]

Great idea, done.

+}
+
+void OnServiceFailedToStartCallback(
+      bool* run,
+      const service_manager::Identity& identity) {
+  *run = true;
+  base::MessageLoop::current()->QuitWhenIdle();
+}
+
+// Tests that creating connecting to a singleton packaged service work.
+TEST_F(ServiceManagerTest, CreatePackagedSingletonInstance) {
+  AddListenerAndWaitForApplications();
+
+  int start_count = 0;
+  std::string service_name;
+  set_service_started_callback(base::BindRepeating(
+      &OnServiceStartedCallback, &start_count, &service_name));
+  bool failed_to_start = false;
+  set_service_failed_to_start_callback(base::BindRepeating(
+      &OnServiceFailedToStartCallback, &failed_to_start));
+
+  // Connect to the embedder service first.
+  std::unique_ptr<Connection> embedder_connection =
+      connector()->Connect("exe:service_manager_unittest_embedder");
+  base::RunLoop().Run();
+  EXPECT_FALSE(failed_to_start);
+  EXPECT_FALSE(embedder_connection->IsPending());
+  EXPECT_EQ(1, start_count);
+  EXPECT_EQ("exe:service_manager_unittest_embedder", service_name);
+
+  failed_to_start = false;
+  start_count = 0;
+  service_name.clear();
+
+  // Connect to the packaged singleton service.
+  std::unique_ptr<Connection> singleton_connection =
+      connector()->Connect("service:service_manager_unittest_singleton");
+  base::RunLoop().Run();
+  EXPECT_FALSE(failed_to_start);
+  EXPECT_FALSE(singleton_connection->IsPending());
+  EXPECT_EQ(1, start_count);
+  EXPECT_EQ("service:service_manager_unittest_singleton", service_name);
+}
+
 }  // namespace service_manager