Add a instance groups to Connect(), and introduce an Identity struct.

mojo/shell/shell.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_SHELL_SHELL_H_
 #define MOJO_SHELL_SHELL_H_
 
 #include <map>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_ptr_set.h"
 #include "mojo/services/package_manager/package_manager.h"
 #include "mojo/services/package_manager/public/interfaces/shell_resolver.mojom.h"
 #include "mojo/shell/connect_params.h"
-#include "mojo/shell/identity.h"
 #include "mojo/shell/loader.h"
 #include "mojo/shell/native_runner.h"
+#include "mojo/shell/public/cpp/identity.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/interfaces/connector.mojom.h"
 #include "mojo/shell/public/interfaces/interface_provider.mojom.h"
 #include "mojo/shell/public/interfaces/shell.mojom.h"
 #include "mojo/shell/public/interfaces/shell_client.mojom.h"
 #include "mojo/shell/public/interfaces/shell_client_factory.mojom.h"
 
 namespace base {
 class FilePath;
 class SequencedWorkerPool;
 }
 
 namespace mojo {
 class ShellConnection;
 namespace shell {
 
+// A set of names of interfaces that may be exposed to an application.
+using AllowedInterfaces = std::set<std::string>;
+// A map of allowed applications to allowed interface sets. See shell.mojom for
+// more details.
+using CapabilityFilter = std::map<std::string, AllowedInterfaces>;
+
+// Creates an identity for the Shell, used when the Shell connects to
+// applications.
+Identity CreateShellIdentity();
+
+// Returns a capability filter that allows an application to connect to any
+// other application and any service exposed by other applications.
+CapabilityFilter GetPermissiveCapabilityFilter();
+
+// Returns the set of interfaces that an application instance with |filter| is
+// allowed to see from an instance with |identity|.
+AllowedInterfaces GetAllowedInterfaces(const CapabilityFilter& filter,
+                                       const Identity& identity);
+
 class Shell : public ShellClient {
  public:
   // API for testing.
   class TestAPI {
    public:
     explicit TestAPI(Shell* shell);
     ~TestAPI();
 
     // Returns true if there is a Instance for this name.
     bool HasRunningInstanceForName(const std::string& name) const;
@@ skipping 63 matching lines @@
   Instance* GetExistingInstance(const Identity& identity) const;
 
   void NotifyPIDAvailable(uint32_t id, base::ProcessId pid);
 
   // Attempt to complete the connection requested by |params| by connecting to
   // an existing instance. If there is an existing instance, |params| is taken,
   // and this function returns true.
   bool ConnectToExistingInstance(scoped_ptr<ConnectParams>* params);
 
   Instance* CreateInstance(const Identity& target_id,
+                           const CapabilityFilter& filter,
                            mojom::ShellClientRequest* request);
 
   // Called from the instance implementing mojom::Shell. |user_id| must be
   // resolved by the instance (i.e. must not be mojom::kInheritUserID).
   void CreateInstanceForFactory(
       mojom::ShellClientFactoryPtr factory,
       const std::string& name,
       const std::string& user_id,
       mojom::CapabilityFilterPtr filter,
       mojom::PIDReceiverRequest pid_receiver);
@@ skipping 13 matching lines @@
 
   // Callback when remote PackageManager resolves mojo:foo to mojo:bar.
   // |params| are the params passed to Connect().
   // |resolved_name| is the mojo: name identifying the physical package
   // application.
   // |file_url| is the resolved file:// URL of the physical package.
   // |base_filter| is the CapabilityFilter the requested application should be
   // run with, from its manifest.
   void OnGotResolvedName(scoped_ptr<ConnectParams> params,
                          const String& resolved_name,
-                         const String& resolved_qualifier,
+                         const String& resolved_instance,
                          mojom::CapabilityFilterPtr base_filter,
                          const String& file_url);
 
   // Tries to load |target| with an Loader. Returns true if one was registered
   // and it was loaded, in which case |request| is taken.
   bool LoadWithLoader(const Identity& target,
                       mojom::ShellClientRequest* request);
 
   // Returns the appropriate loader for |name|, or the default loader if there
   // is no loader configured for the name.
@@ skipping 28 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(Shell);
 };
 
 mojom::Connector::ConnectCallback EmptyConnectCallback();
 
 }  // namespace shell
 }  // namespace mojo
 
 #endif  // MOJO_SHELL_SHELL_H_