Home | History | Annotate | Download | only in service_manager 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef MOJO_SERVICE_MANAGER_SERVICE_MANAGER_H_
      6 #define MOJO_SERVICE_MANAGER_SERVICE_MANAGER_H_
      7 
      8 #include <map>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/gtest_prod_util.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "mojo/public/interfaces/service_provider/service_provider.mojom.h"
     14 #include "mojo/service_manager/service_loader.h"
     15 #include "mojo/service_manager/service_manager_export.h"
     16 #include "url/gurl.h"
     17 
     18 namespace mojo {
     19 
     20 class MOJO_SERVICE_MANAGER_EXPORT ServiceManager {
     21  public:
     22   // API for testing.
     23   class MOJO_SERVICE_MANAGER_EXPORT TestAPI {
     24    public:
     25     explicit TestAPI(ServiceManager* manager);
     26     ~TestAPI();
     27 
     28     // Returns a handle to a unique ServiceProvider instance.
     29     ScopedMessagePipeHandle GetServiceProviderHandle();
     30 
     31     // Returns true if the shared instance has been created.
     32     static bool HasCreatedInstance();
     33     // Returns true if there is a ServiceFactory for this URL.
     34     bool HasFactoryForURL(const GURL& url) const;
     35 
     36    private:
     37     class TestServiceProviderConnection;
     38 
     39     ServiceManager* manager_;
     40     scoped_ptr<TestServiceProviderConnection> service_provider_;
     41 
     42     DISALLOW_COPY_AND_ASSIGN(TestAPI);
     43   };
     44 
     45   // Interface class for debugging only.
     46   class Interceptor {
     47    public:
     48     virtual ~Interceptor() {}
     49     // Called when ServiceManager::Connect is called.
     50     virtual ScopedMessagePipeHandle OnConnectToClient(
     51         const GURL& url, ScopedMessagePipeHandle handle) = 0;
     52   };
     53 
     54   ServiceManager();
     55   ~ServiceManager();
     56 
     57   // Returns a shared instance, creating it if necessary.
     58   static ServiceManager* GetInstance();
     59 
     60   // Loads a service if necessary and establishes a new client connection.
     61   void ConnectToService(const GURL& service_url,
     62                         const std::string& service_name,
     63                         ScopedMessagePipeHandle client_handle,
     64                         const GURL& requestor_url);
     65 
     66   template <typename Interface>
     67   void ConnectTo(const GURL& service_url,
     68                  InterfacePtr<Interface>* ptr,
     69                  const GURL& requestor_url) {
     70     MessagePipe pipe;
     71     ptr->Bind(pipe.handle0.Pass());
     72     ConnectToService(service_url,
     73                      Interface::Name_,
     74                      pipe.handle1.Pass(),
     75                      requestor_url);
     76   }
     77 
     78   // Sets the default Loader to be used if not overridden by SetLoaderForURL()
     79   // or SetLoaderForScheme().
     80   void set_default_loader(scoped_ptr<ServiceLoader> loader) {
     81     default_loader_ = loader.Pass();
     82   }
     83   // Sets a Loader to be used for a specific url.
     84   void SetLoaderForURL(scoped_ptr<ServiceLoader> loader, const GURL& url);
     85   // Sets a Loader to be used for a specific url scheme.
     86   void SetLoaderForScheme(scoped_ptr<ServiceLoader> loader,
     87                           const std::string& scheme);
     88   // Allows to interpose a debugger to service connections.
     89   void SetInterceptor(Interceptor* interceptor);
     90 
     91  private:
     92   class ServiceFactory;
     93   typedef std::map<std::string, ServiceLoader*> SchemeToLoaderMap;
     94   typedef std::map<GURL, ServiceLoader*> URLToLoaderMap;
     95   typedef std::map<GURL, ServiceFactory*> URLToServiceFactoryMap;
     96 
     97   // Returns the Loader to use for a url (using default if not overridden.)
     98   // The preference is to use a loader that's been specified for an url first,
     99   // then one that's been specified for a scheme, then the default.
    100   ServiceLoader* GetLoaderForURL(const GURL& url);
    101 
    102   // Removes a ServiceFactory when it encounters an error.
    103   void OnServiceFactoryError(ServiceFactory* service_factory);
    104 
    105   // Loader management.
    106   URLToLoaderMap url_to_loader_;
    107   SchemeToLoaderMap scheme_to_loader_;
    108   scoped_ptr<ServiceLoader> default_loader_;
    109   Interceptor* interceptor_;
    110 
    111   URLToServiceFactoryMap url_to_service_factory_;
    112   DISALLOW_COPY_AND_ASSIGN(ServiceManager);
    113 };
    114 
    115 }  // namespace mojo
    116 
    117 #endif  // MOJO_SERVICE_MANAGER_SERVICE_MANAGER_H_
    118