Introduce very beginning of navigation

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/message_loop/message_loop.h"
 #include "mojo/public/cpp/application/application.h"
 #include "mojo/public/cpp/environment/environment.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"
@@ skipping 17 matching lines @@
 class TestServiceImpl : public InterfaceImpl<TestService> {
  public:
   explicit TestServiceImpl(TestContext* context) : context_(context) {
     ++context_->num_impls;
   }
 
   virtual ~TestServiceImpl() {
     --context_->num_impls;
   }
 
+  virtual void OnConnectionError() OVERRIDE {
+    base::MessageLoop::current()->Quit();
+  }
+
   // TestService implementation:
   virtual void Test(const String& test_string) OVERRIDE {
     context_->last_test_string = test_string;
     client()->AckTest();
   }
 
  private:
   TestContext* context_;
 };
 
@@ skipping 20 matching lines @@
  private:
   TestServicePtr service_;
   bool quit_after_ack_;
   DISALLOW_COPY_AND_ASSIGN(TestClientImpl);
 };
 
 class TestServiceLoader : public ServiceLoader {
  public:
   TestServiceLoader()
       : context_(NULL),
-        num_loads_(0),
-        quit_after_error_(false) {
+        num_loads_(0) {
   }
 
   virtual ~TestServiceLoader() {
     if (context_)
       ++context_->num_loader_deletes;
     test_app_.reset(NULL);
   }
 
   void set_context(TestContext* context) { context_ = context; }
-  void set_quit_after_error(bool quit_after_error) {
-    quit_after_error_ = quit_after_error;
-  }
-
   int num_loads() const { return num_loads_; }
 
  private:
   virtual void LoadService(
       ServiceManager* manager,
       const GURL& url,
       ScopedMessagePipeHandle service_provider_handle) OVERRIDE {
     ++num_loads_;
     test_app_.reset(new Application(service_provider_handle.Pass()));
     test_app_->AddService<TestServiceImpl>(context_);
   }
 
   virtual void OnServiceError(ServiceManager* manager,
                               const GURL& url) OVERRIDE {
-    if (quit_after_error_) {
-      base::MessageLoop::current()->PostTask(FROM_HERE,
-                                             base::MessageLoop::QuitClosure());
-    }
   }
 
   scoped_ptr<Application> test_app_;
   TestContext* context_;
   int num_loads_;
-  bool quit_after_error_;
   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) {}
 
   virtual void LoadB() OVERRIDE {
     TestBPtr b;
@@ skipping 89 matching lines @@
   virtual void SetUp() OVERRIDE {
     GURL test_url(kTestURLString);
     service_manager_.reset(new ServiceManager);
 
     MessagePipe pipe;
     TestServicePtr service_proxy = MakeProxy<TestService>(pipe.handle0.Pass());
     test_client_.reset(new TestClientImpl(service_proxy.Pass()));
 
     TestServiceLoader* default_loader = new TestServiceLoader;
     default_loader->set_context(&context_);
-    default_loader->set_quit_after_error(true);
     service_manager_->set_default_loader(
         scoped_ptr<ServiceLoader>(default_loader));
 
     service_manager_->ConnectToService(
         test_url, TestService::Name_, pipe.handle1.Pass(), GURL());
   }
 
   virtual void TearDown() OVERRIDE {
     test_client_.reset(NULL);
     service_manager_.reset(NULL);
@@ skipping 20 matching lines @@
 }
 
 TEST_F(ServiceManagerTest, ClientError) {
   test_client_->Test("test");
   EXPECT_TRUE(HasFactoryForTestURL());
   loop_.Run();
   EXPECT_EQ(1, context_.num_impls);
   test_client_.reset(NULL);
   loop_.Run();
   EXPECT_EQ(0, context_.num_impls);
-  EXPECT_FALSE(HasFactoryForTestURL());
+  EXPECT_TRUE(HasFactoryForTestURL());
 }
 
 TEST_F(ServiceManagerTest, Deletes) {
   {
     ServiceManager sm;
     TestServiceLoader* default_loader = new TestServiceLoader;
     default_loader->set_context(&context_);
     TestServiceLoader* url_loader1 = new TestServiceLoader;
     TestServiceLoader* url_loader2 = new TestServiceLoader;
     url_loader1->set_context(&context_);
@@ skipping 96 matching lines @@
 
   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