Fixes race in Shell

services/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 SERVICES_SHELL_SHELL_H_
 #define SERVICES_SHELL_SHELL_H_
 
 #include <map>
 #include <memory>
 #include <vector>
@@ skipping 63 matching lines @@
   mojom::ShellClientRequest InitInstanceForEmbedder(const std::string& name);
 
  private:
   class Instance;
 
   // ShellClient:
   bool AcceptConnection(Connection* connection) override;
 
   void InitCatalog(mojom::ShellClientPtr catalog);
 
+  // Returns the resolver to use for the specified identity.
+  // NOTE: ShellResolvers are cached to ensure we service requests in order. If
+  // we use a separate ShellResolver for each request ordering is not
+  // guaranteed and can lead to random flake.
+  mojom::ShellResolver* GetResolver(const Identity& identity);
+
   // Destroys all Shell-ends of connections established with Applications.
   // Applications connected by this Shell will observe pipe errors and have a
   // chance to shutdown.
   void TerminateShellConnections();
 
   // Removes a Instance when it encounters an error.
   void OnInstanceError(Instance* instance);
 
   // Completes a connection between a source and target application as defined
   // by |params|, exchanging InterfaceProviders between them. If no existing
@@ skipping 30 matching lines @@
   // If there is not one running one is started for |source_identity|.
   mojom::ShellClientFactory* GetShellClientFactory(
       const Identity& shell_client_factory_identity);
   void OnShellClientFactoryLost(const Identity& which);
 
   // Callback when remote Catalog resolves mojo:foo to mojo:bar.
   // |params| are the params passed to Connect().
   // |client| if provided is a ShellClientPtr which should be used to manage the
   // new application instance. This may be null.
   // |result| contains the result of the resolve operation.
-  void OnGotResolvedName(mojom::ShellResolverPtr resolver,
-                         std::unique_ptr<ConnectParams> params,
+  void OnGotResolvedName(std::unique_ptr<ConnectParams> params,
                          mojom::ShellClientPtr client,
                          mojom::ResolveResultPtr result);
 
   base::WeakPtr<Shell> GetWeakPtr();
 
   void CleanupRunner(NativeRunner* runner);
 
   std::map<Identity, Instance*> identity_to_instance_;
 
   // Tracks the names of instances that are allowed to field connection requests
   // from all users.
   std::set<std::string> singletons_;
 
   std::map<Identity, mojom::ShellClientFactoryPtr> shell_client_factories_;
   // Counter used to assign ids to client factories.
   uint32_t shell_client_factory_id_counter_;
 
+  std::map<Identity, mojom::ShellResolverPtr> identity_to_resolver_;
+
   mojo::InterfacePtrSet<mojom::InstanceListener> instance_listeners_;
 
   base::Callback<void(const Identity&)> instance_quit_callback_;
   std::unique_ptr<NativeRunnerFactory> native_runner_factory_;
   std::vector<std::unique_ptr<NativeRunner>> native_runners_;
   std::unique_ptr<ShellConnection> shell_connection_;
   base::WeakPtrFactory<Shell> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Shell);
 };
 
 mojom::Connector::ConnectCallback EmptyConnectCallback();
 
 }  // namespace shell
 
 #endif  // SERVICES_SHELL_SHELL_H_