Change mojo demo apps to use Application.

mojo/public/shell/service.h

 // 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.
 
 #ifndef MOJO_PUBLIC_SHELL_SERVICE_H_
 #define MOJO_PUBLIC_SHELL_SERVICE_H_
 
 #include <vector>
 
 #include "mojo/public/bindings/error_handler.h"
@@ skipping 45 matching lines @@
 // Specialization of ServiceFactory.
 // ServiceImpl: Implementation of Service interface.
 // Context: Optional type of shared context.v
 //
 //
 namespace mojo {
 
 namespace internal {
 class ServiceFactoryBase {
  public:
-  class Owner {
+  class Owner : public ShellClient {
    public:
-    virtual Shell* GetShell() = 0;
+    Owner(ScopedShellHandle shell_handle);
+    ~Owner();
+    Shell* shell() { return shell_.get(); }
     virtual void AddServiceFactory(
         internal::ServiceFactoryBase* service_factory) = 0;
     virtual void RemoveServiceFactory(
         internal::ServiceFactoryBase* service_factory) = 0;
 
    protected:
     void set_service_factory_owner(ServiceFactoryBase* service_factory,
                                    Owner* owner) {
       service_factory->owner_ = owner;
     }
+    RemotePtr<Shell> shell_;
   };
   ServiceFactoryBase() : owner_(NULL) {}
   virtual ~ServiceFactoryBase();
-  Shell* GetShell() { return owner_->GetShell(); }
+  Shell* shell() { return owner_->shell(); }
   virtual void AcceptConnection(const std::string& url,
                                 ScopedMessagePipeHandle client_handle) = 0;
 
  protected:
   Owner* owner_;
 };
 }  // namespace internal
 
 template <class ServiceImpl, typename Context=void>
 class ServiceFactory : public internal::ServiceFactoryBase {
@@ skipping 52 matching lines @@
                   ScopedMessagePipeHandle client_handle) {
     service_factory_ = service_factory;
     client_.reset(
         MakeScopedHandle(
             InterfaceHandle<typename ServiceInterface::_Peer>(
                 client_handle.release().value())).Pass(),
         this,
         &reaper_);
   }
 
+  Shell* shell() { return service_factory_->shell(); }
   Context* context() const { return service_factory_->context(); }
   typename ServiceInterface::_Peer* client() { return client_.get(); }
 
  private:
   // The Reaper class allows us to handle errors on the client proxy without
   // polluting the name space of the Service<> class.
   class Reaper : public ErrorHandler {
    public:
     Reaper(Service<ServiceInterface, ServiceImpl, Context>* service)
         : service_(service) {}
     virtual void OnError() {
       service_->service_factory_->RemoveService(
           static_cast<ServiceImpl*>(service_));
     }
    private:
     Service<ServiceInterface, ServiceImpl, Context>* service_;
   };
   friend class ServiceFactory<ServiceImpl, Context>;
   Reaper reaper_;
   ServiceFactory<ServiceImpl, Context>* service_factory_;
   RemotePtr<typename ServiceInterface::_Peer> client_;
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_SHELL_SERVICE_H_