mojo/shell/application_instance.h

   1 // Copyright 2015 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_SHELL_APPLICATION_INSTANCE_H_
   6 #define MOJO_SHELL_APPLICATION_INSTANCE_H_
   7
   8 #include <set>
   9
  10 #include "base/callback.h"
  11 #include "mojo/application/public/interfaces/application.mojom.h"
  12 #include "mojo/application/public/interfaces/shell.mojom.h"
  13 #include "mojo/public/cpp/bindings/binding.h"
  14 #include "mojo/shell/identity.h"
  15 #include "url/gurl.h"
  16
  17 namespace mojo {
  18
  19 // TODO(beng): upstream this into mojo repo, array.h so it can be shared with
  20 //             application_impl.cc.
  21 // A |TypeConverter| that will create an |std::set<E>| containing a copy of
  22 // the contents of an |Array<T>|, using |TypeConverter<E, T>| to copy each
  23 // element. If the input array is null, the output set will be empty.
  24 template <typename E, typename T>
  25 struct TypeConverter <std::set<E>, Array<T>> {
  26   static std::set<E> Convert(const Array<T>& input) {
  27     std::set<E> result;
  28     if (!input.is_null()) {
  29       for (size_t i = 0; i < input.size(); ++i)
  30         result.insert(TypeConverter<E, T>::Convert(input[i]));
  31     }
  32     return result;
  33   }
  34 };
  35
  36 template <typename T, typename E>
  37 struct TypeConverter <Array<T>, std::set<E>> {
  38   static Array<T> Convert(const std::set<E>& input) {
  39     Array<T> result(0u);
  40     for (auto i : input)
  41       result.push_back(TypeConverter<T, E>::Convert(i));
  42     return result.Pass();
  43   }
  44 };
  45
  46 namespace shell {
  47
  48 class ApplicationManager;
  49
  50 // Encapsulates a connection to an instance of an application, tracked by the
  51 // shell's ApplicationManager.
  52 class ApplicationInstance : public Shell {
  53  public:
  54   using AllowedInterfaces = std::set<std::string>;
  55   using CapabilityFilter = std::map<std::string, AllowedInterfaces>;
  56
  57   ApplicationInstance(ApplicationPtr application,
  58                       ApplicationManager* manager,
  59                       const Identity& resolved_identity,
  60                       const CapabilityFilter& filter,
  61                       const base::Closure& on_application_end);
  62
  63   ~ApplicationInstance() override;
  64
  65   void InitializeApplication();
  66
  67   void ConnectToClient(ApplicationInstance* originator,
  68                        const GURL& requested_url,
  69                        const GURL& requestor_url,
  70                        InterfaceRequest<ServiceProvider> services,
  71                        ServiceProviderPtr exposed_services,
  72                        CapabilityFilterPtr filter);
  73
  74   // Returns the set of interfaces this application instance is allowed to see
  75   // from an instance with |identity|.
  76   AllowedInterfaces GetAllowedInterfaces(const Identity& identity) const;
  77
  78   Application* application() { return application_.get(); }
  79   const Identity& identity() const { return identity_; }
  80   base::Closure on_application_end() const { return on_application_end_; }
  81
  82  private:
  83   // Shell implementation:
  84   void ConnectToApplication(URLRequestPtr app_request,
  85                             InterfaceRequest<ServiceProvider> services,
  86                             ServiceProviderPtr exposed_services,
  87                             CapabilityFilterPtr filter) override;
  88   void QuitApplication() override;
  89
  90   void CallAcceptConnection(ApplicationInstance* originator,
  91                             const GURL& url,
  92                             InterfaceRequest<ServiceProvider> services,
  93                             ServiceProviderPtr exposed_services,
  94                             const GURL& requested_url);
  95
  96   void OnConnectionError();
  97
  98   void OnQuitRequestedResult(bool can_quit);
  99
 100   struct QueuedClientRequest {
 101     QueuedClientRequest();
 102     ~QueuedClientRequest();
 103     ApplicationInstance* originator;
 104     GURL requested_url;
 105     GURL requestor_url;
 106     InterfaceRequest<ServiceProvider> services;
 107     ServiceProviderPtr exposed_services;
 108     CapabilityFilterPtr filter;
 109   };
 110
 111   ApplicationManager* const manager_;
 112   const Identity identity_;
 113   const CapabilityFilter filter_;
 114   const bool allow_any_application_;
 115   base::Closure on_application_end_;
 116   ApplicationPtr application_;
 117   Binding<Shell> binding_;
 118   bool queue_requests_;
 119   std::vector<QueuedClientRequest*> queued_client_requests_;
 120
 121   DISALLOW_COPY_AND_ASSIGN(ApplicationInstance);
 122 };
 123
 124 }  // namespace shell
 125 }  // namespace mojo
 126
 127 #endif  // MOJO_SHELL_APPLICATION_INSTANCE_H_