Allow trusted brokers to restrict connections for spawned applications to whitelisted applications …

mojo/application/public/cpp/application_connection.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_APPLICATION_PUBLIC_CPP_APPLICATION_CONNECTION_H_
 #define MOJO_APPLICATION_PUBLIC_CPP_APPLICATION_CONNECTION_H_
 
 #include <string>
 
 #include "mojo/application/public/cpp/lib/interface_factory_connector.h"
@@ skipping 38 matching lines @@
 
   // Closes the connection and destroys this object. This is the only valid way
   // to destroy this object.
   void CloseConnection();
 
   // See class description for details.
   virtual void SetServiceConnector(ServiceConnector* connector) = 0;
 
   // Makes Interface available as a service to the remote application.
   // |factory| will create implementations of Interface on demand.
+  // Returns true if the service was exposed, false if capability filtering
+  // from the shell prevented the service from being exposed.
   template <typename Interface>
-  void AddService(InterfaceFactory<Interface>* factory) {
-    SetServiceConnectorForName(
+  bool AddService(InterfaceFactory<Interface>* factory) {
+    return SetServiceConnectorForName(
         new internal::InterfaceFactoryConnector<Interface>(factory),
         Interface::Name_);
   }
 
   // Binds |ptr| to an implemention of Interface in the remote application.
   // |ptr| can immediately be used to start sending requests to the remote
   // service.
   template <typename Interface>
   void ConnectToService(InterfacePtr<Interface>* ptr) {
     if (ServiceProvider* sp = GetServiceProvider()) {
@@ skipping 20 matching lines @@
 
   // Returns the raw proxy to the remote application's ServiceProvider
   // interface. Most applications will just use ConnectToService() instead.
   // Caller does not take ownership.
   virtual ServiceProvider* GetServiceProvider() = 0;
 
   // Returns the local application's ServiceProvider interface. The return
   // value is owned by this connection.
   virtual ServiceProvider* GetLocalServiceProvider() = 0;
 
+  // Register a handler to receive an error notification on the pipe to the
+  // remote application's service provider.
+  virtual void SetRemoteServiceProviderConnectionErrorHandler(
+      const Closure& handler) = 0;
+
  protected:
   virtual ~ApplicationConnection();
 
   // Called to give the derived type to perform some cleanup before destruction.
   virtual void OnCloseConnection() = 0;
 
  private:
-  virtual void SetServiceConnectorForName(ServiceConnector* service_connector,
+  // Returns true if the connector was set, false if it was not set (e.g. by
+  // some filtering policy preventing this interface from being exposed).
+  virtual bool SetServiceConnectorForName(ServiceConnector* service_connector,
                                           const std::string& name) = 0;
 
   // Ensures that CloseConnection can only be called once and the
   // ApplicationConnection's destructor can only be called after the connection
   // is closed.
   bool connection_closed_;
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_APPLICATION_PUBLIC_CPP_APPLICATION_CONNECTION_H_