mojo: fail gracefully if ServiceRegistry can't find ServiceConnector

mojo/service_manager/service_manager_unittest.cc

 // Copyright 2014 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 "base/at_exit.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/public/cpp/application/application.h"
 #include "mojo/public/interfaces/service_provider/service_provider.mojom.h"
 #include "mojo/service_manager/service_loader.h"
 #include "mojo/service_manager/service_manager.h"
 #include "mojo/service_manager/test.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 const char kTestAURLString[] = "test:TestA";
 const char kTestBURLString[] = "test:TestB";
 
 struct TestContext {
   TestContext() : num_impls(0), num_loader_deletes(0) {}
   std::string last_test_string;
   int num_impls;
   int num_loader_deletes;
 };
 
+class QuitMessageLoopErrorHandler : public ErrorHandler {
+ public:
+  QuitMessageLoopErrorHandler() {}
+  virtual ~QuitMessageLoopErrorHandler() {}
+
+  // |ErrorHandler| implementation:
+  virtual void OnConnectionError() OVERRIDE {
+    base::MessageLoop::current()->QuitWhenIdle();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(QuitMessageLoopErrorHandler);
+};
+
 class TestServiceImpl : public InterfaceImpl<TestService> {
  public:
   explicit TestServiceImpl(TestContext* context) : context_(context) {
     ++context_->num_impls;
   }
 
   virtual ~TestServiceImpl() {
     --context_->num_impls;
   }
 
@@ skipping 69 matching lines @@
 
   scoped_ptr<Application> test_app_;
   TestContext* context_;
   int num_loads_;
   DISALLOW_COPY_AND_ASSIGN(TestServiceLoader);
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public InterfaceImpl<TestA> {
  public:
-  TestAImpl(Application* app) : app_(app) {}
+  explicit TestAImpl(Application* app) : app_(app) {}
 
   virtual void LoadB() OVERRIDE {
     TestBPtr b;
     app_->ConnectTo(kTestBURLString, &b);
     b->Test();
   }
 
  private:
   Application* app_;
 };
 
 class TestBImpl : public InterfaceImpl<TestB> {
  public:
   virtual void Test() OVERRIDE {
     base::MessageLoop::current()->Quit();
   }
 };
 
 class TestApp : public Application, public ServiceLoader {
  public:
-  TestApp(std::string requestor_url)
+  explicit TestApp(std::string requestor_url)
       : requestor_url_(requestor_url),
         num_connects_(0) {
   }
 
   int num_connects() const { return num_connects_; }
 
  private:
   virtual void LoadService(
       ServiceManager* manager,
       const GURL& url,
@@ skipping 198 matching lines @@
   b_app->AddService<TestBImpl>();
   sm.SetLoaderForURL(scoped_ptr<ServiceLoader>(b_app), GURL(kTestBURLString));
 
   TestAPtr a;
   sm.ConnectTo(GURL(kTestAURLString), &a, GURL());
   a->LoadB();
   loop_.Run();
   EXPECT_EQ(0, b_app->num_connects());
 }
 
+TEST_F(ServiceManagerTest, NoServiceNoLoad) {
+  ServiceManager sm;
+
+  TestApp* b_app = new TestApp(std::string());
+  b_app->AddService<TestBImpl>();
+  sm.SetLoaderForURL(scoped_ptr<ServiceLoader>(b_app), GURL(kTestBURLString));
+
+  // There is no TestA service implementation registered with ServiceManager,
+  // so this cannot succeed (but also shouldn't crash).
+  TestAPtr a;
+  sm.ConnectTo(GURL(kTestBURLString), &a, GURL());
+  QuitMessageLoopErrorHandler quitter;
+  a.set_error_handler(&quitter);
+  a->LoadB();
+
+  loop_.Run();
+  EXPECT_TRUE(a.encountered_error());
+  EXPECT_EQ(0, b_app->num_connects());
+}
+
 TEST_F(ServiceManagerTest, Interceptor) {
   ServiceManager sm;
   TestServiceInterceptor interceptor;
   TestServiceLoader* default_loader = new TestServiceLoader;
   sm.set_default_loader(scoped_ptr<ServiceLoader>(default_loader));
   sm.SetInterceptor(&interceptor);
 
   std::string url("test:test3");
   TestServicePtr test_service;
   sm.ConnectTo(GURL(url), &test_service, GURL());
   EXPECT_EQ(1, interceptor.call_count());
   EXPECT_EQ(url, interceptor.url_spec());
   EXPECT_EQ(1, default_loader->num_loads());
 }
 
 }  // namespace mojo