Change primordial pipes to ShellClient

mojo/shell/shell.cc

 // 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.
 
 #include "mojo/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 82 matching lines @@
 }
 
 // Encapsulates a connection to an instance of an application, tracked by the
 // shell's Shell.
 class Shell::Instance : public mojom::Connector,
                         public mojom::PIDReceiver,
                         public ShellClient,
                         public InterfaceFactory<mojom::Shell>,
                         public mojom::Shell {
  public:
-  Instance(mojom::ShellClientPtr shell_client,
-           mojo::shell::Shell* shell,
+  Instance(mojo::shell::Shell* shell,
            const Identity& identity,
            const CapabilitySpec& capability_spec)
     : shell_(shell),
       id_(GenerateUniqueID()),
       identity_(identity),
       capability_spec_(capability_spec),
       allow_any_application_(capability_spec.required.count("*") == 1),
-      shell_client_(std::move(shell_client)),
       pid_receiver_binding_(this),
       weak_factory_(this) {
     if (identity_.name() == kShellName ||
         shell_->GetLoaderForName(identity_.name())) {
       pid_ = base::Process::Current().Pid();
     }
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
-
-    shell_client_.set_connection_error_handler(
-        base::Bind(&Instance::OnShellClientLost, base::Unretained(this)));
   }
 
   ~Instance() override {}
 
   void OnShellClientLost() {
     shell_client_.reset();
     OnConnectionLost();
   }
 
   void OnConnectionLost() {
     // Any time a Connector is lost or we lose the ShellClient connection, it
     // may have been the last pipe using this Instance. If so, clean up.
     if (connectors_.empty() && !shell_client_) {
       // Deletes |this|.
       shell_->OnInstanceError(this);
     }
   }
 
   void OnInitializeResponse(mojom::ConnectorRequest connector_request) {
     if (connector_request.is_pending()) {
       connectors_.AddBinding(this, std::move(connector_request));
       connectors_.set_connection_error_handler(
           base::Bind(&Instance::OnConnectionLost, base::Unretained(this)));
     }
   }
 
-  void InitializeClient() {
-    shell_client_->Initialize(mojom::Identity::From(identity_), id_,
-                              base::Bind(&Instance::OnInitializeResponse,
-                                         base::Unretained(this)));
-  }
-
   void ConnectToClient(scoped_ptr<ConnectParams> params) {
+    CHECK(shell_client_.is_bound());
     params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                    identity_.user_id(), id_);
     uint32_t source_id = mojom::kInvalidInstanceID;
     CapabilityRequest spec;
     spec.interfaces.insert("*");
     Instance* source = shell_->GetExistingInstance(params->source());
     if (source) {
       spec = GenerateCapabilityRequestForConnection(
           source->capability_spec_, identity_, capability_spec_);
       source_id = source->id();
     }
     shell_client_->AcceptConnection(
         mojom::Identity::From(params->source()), source_id,
         params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
         mojom::CapabilityRequest::From(spec), params->target().name());
   }
 
+  void StartWithClient(mojom::ShellClientPtr client) {
+    CHECK(!shell_client_);
+    shell_client_ = std::move(client);
+    shell_client_.set_connection_error_handler(
+        base::Bind(&Instance::OnShellClientLost, base::Unretained(this)));
+    shell_client_->Initialize(mojom::Identity::From(identity_), id_,
+                              base::Bind(&Instance::OnInitializeResponse,
+                                         base::Unretained(this)));
+  }
+
   void StartWithClientProcessConnection(
-      mojom::ShellClientRequest request,
       mojom::ClientProcessConnectionPtr client_process_connection) {
-    factory_.Bind(mojom::ShellClientFactoryPtrInfo(
-        std::move(client_process_connection->shell_client_factory), 0u));
+    mojom::ShellClientPtr client;
+    client.Bind(mojom::ShellClientPtrInfo(
+        std::move(client_process_connection->shell_client), 0));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
-    factory_->CreateShellClient(std::move(request), identity_.name());
+    StartWithClient(std::move(client));
   }
 
-  void StartWithFilePath(mojom::ShellClientRequest request,
-                         const base::FilePath& path) {
+  void StartWithFilePath(const base::FilePath& path) {
+    CHECK(!shell_client_);
     scoped_ptr<NativeRunner> runner =
         shell_->native_runner_factory_->Create(path);
     bool start_sandboxed = false;
-    runner->Start(path, identity_, start_sandboxed, std::move(request),
-                  base::Bind(&Instance::PIDAvailable,
-                             weak_factory_.GetWeakPtr()),
-                  base::Bind(&mojo::shell::Shell::CleanupRunner,
-                             shell_->weak_ptr_factory_.GetWeakPtr(),
-                             runner.get()));
+    mojom::ShellClientPtr client = runner->Start(
+        path, identity_, start_sandboxed,
+        base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
+        base::Bind(&mojo::shell::Shell::CleanupRunner,
+                   shell_->weak_ptr_factory_.GetWeakPtr(), runner.get()));
     shell_->native_runners_.push_back(std::move(runner));
+    StartWithClient(std::move(client));
   }
 
   mojom::InstanceInfoPtr CreateInstanceInfo() const {
     mojom::InstanceInfoPtr info(mojom::InstanceInfo::New());
     info->id = id_;
     info->identity = mojom::Identity::From(identity_);
     info->pid = pid_;
     return info;
   }
 
@@ skipping 83 matching lines @@
       if (!HasClass(kCapabilityClass_ClientProcess)) {
         LOG(ERROR) << "Error: Instance: " << identity_.name() << " attempting "
                    << "to register an instance for a process it created for "
                    << "target: " << target.name() << " without the "
                    << "mojo:shell{client_process} capability class.";
         callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
 
-      if (!(*client_process_connection)->shell_client_factory.is_valid() ||
+      if (!(*client_process_connection)->shell_client.is_valid() ||
           !(*client_process_connection)->pid_receiver_request.is_valid()) {
-        LOG(ERROR) << "Error: must supply both shell_client_factory AND "
+        LOG(ERROR) << "Error: must supply both shell_client AND "
                    << "pid_receiver_request when sending "
                    << "client_process_connection.";
         callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
       if (shell_->GetExistingOrRootInstance(target)) {
         LOG(ERROR) << "Error: Cannot client process matching existing identity:"
                    << "Name: " << target.name() << " User: " << target.user_id()
                    << " Instance: " << target.instance();
@@ skipping 71 matching lines @@
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   const Identity identity_;
   const CapabilitySpec capability_spec_;
   const bool allow_any_application_;
   mojom::ShellClientPtr shell_client_;
   Binding<mojom::PIDReceiver> pid_receiver_binding_;
   BindingSet<mojom::Connector> connectors_;
   BindingSet<mojom::Shell> shell_bindings_;
-  mojom::ShellClientFactoryPtr factory_;
   NativeRunner* runner_ = nullptr;
   base::ProcessId pid_ = base::kNullProcessId;
   base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 // static
 Shell::TestAPI::TestAPI(Shell* shell) : shell_(shell) {}
 Shell::TestAPI::~TestAPI() {}
 
 bool Shell::TestAPI::HasRunningInstanceForName(const std::string& name) const {
   for (const auto& entry : shell_->identity_to_instance_) {
     if (entry.first.name() == name)
       return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(scoped_ptr<NativeRunnerFactory> native_runner_factory,
              mojom::ShellClientPtr catalog)
     : native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
   mojom::ShellClientPtr client;
   mojom::ShellClientRequest request = GetProxy(&client);
-  CreateInstance(CreateShellIdentity(), GetPermissiveCapabilities(),
-                 std::move(client));
+  Instance* instance = CreateInstance(CreateShellIdentity(),
+                                      GetPermissiveCapabilities());
+  instance->StartWithClient(std::move(client));
   shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
 
 Shell::~Shell() {
   TerminateShellConnections();
   STLDeleteValues(&name_to_loader_);
   for (auto& runner : native_runners_)
@@ skipping 49 matching lines @@
   }
   DCHECK(instance);
   return instance->AcceptConnection(connection);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 void Shell::InitCatalog(mojom::ShellClientPtr catalog) {
   Identity identity(kCatalogName, mojom::kRootUserID);
-  CreateInstance(identity, CapabilitySpec(), std::move(catalog));
+  Instance* instance = CreateInstance(identity, CapabilitySpec());
+  instance->StartWithClient(std::move(catalog));
   shell_connection_->connector()->ConnectToInterface(
       kCatalogName, &shell_resolver_);
 
   // Seed the catalog with manifest info for the shell & catalog.
   shell_resolver_->ResolveMojoName(
       kCatalogName, base::Bind(&EmptyResolverCallback));
   shell_resolver_->ResolveMojoName(
       kShellName, base::Bind(&EmptyResolverCallback));
 }
 
@@ skipping 61 matching lines @@
 }
 
 bool Shell::ConnectToExistingInstance(scoped_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingOrRootInstance((*params)->target());
   if (instance)
     instance->ConnectToClient(std::move(*params));
   return !!instance;
 }
 
 Shell::Instance* Shell::CreateInstance(const Identity& target,
-                                       const CapabilitySpec& spec,
-                                       mojom::ShellClientPtr client) {
+                                       const CapabilitySpec& spec) {
   CHECK(target.user_id() != mojom::kInheritUserID);
-  Instance* instance = new Instance(std::move(client), this, target, spec);
+  Instance* instance = new Instance(this, target, spec);
   DCHECK(identity_to_instance_.find(target) ==
          identity_to_instance_.end());
   identity_to_instance_[target] = instance;
   mojom::InstanceInfoPtr info = instance->CreateInstanceInfo();
   instance_listeners_.ForAllPtrs(
       [this, &info](mojom::InstanceListener* listener) {
         listener->InstanceCreated(info.Clone());
       });
-  instance->InitializeClient();
   return instance;
 }
 
 void Shell::AddInstanceListener(mojom::InstanceListenerPtr listener) {
   // TODO(beng): filter instances provided by those visible to this client.
   Array<mojom::InstanceInfoPtr> instances;
   for (auto& instance : identity_to_instance_)
     instances.push_back(instance.second->CreateInstanceInfo());
   listener->SetExistingInstances(std::move(instances));
 
   instance_listeners_.AddInterfacePtr(std::move(listener));
 }
 
-void Shell::CreateShellClient(const Identity& source,
-                              const Identity& shell_client_factory,
-                              const std::string& name,
-                              mojom::ShellClientRequest request) {
+void Shell::CreateShellClientWithFactory(const Identity& source,
+                                         const Identity& shell_client_factory,
+                                         const std::string& name,
+                                         mojom::ShellClientRequest request) {
   mojom::ShellClientFactory* factory =
       GetShellClientFactory(shell_client_factory, source);
   factory->CreateShellClient(std::move(request), name);
 }
 
 mojom::ShellClientFactory* Shell::GetShellClientFactory(
     const Identity& shell_client_factory_identity,
     const Identity& source_identity) {
   auto it = shell_client_factories_.find(shell_client_factory_identity);
   if (it != shell_client_factories_.end())
@@ skipping 41 matching lines @@
 
   Identity source = params->source();
   // |capabilities_ptr| can be null when there is no manifest, e.g. for URL
   // types not resolvable by the resolver.
   CapabilitySpec capabilities = GetPermissiveCapabilities();
   if (!capabilities_ptr.is_null())
     capabilities = capabilities_ptr.To<CapabilitySpec>();
 
   mojom::ClientProcessConnectionPtr client_process_connection =
       params->TakeClientProcessConnection();
+  Instance* instance = CreateInstance(target, capabilities);
 
-  mojom::ShellClientRequest request;
-  if (!client.is_bound())
-    request = GetProxy(&client);
+  // Below are various paths through which a new Instance can be bound to a
+  // ShellClient proxy.
+  if (client.is_bound()) {

[Ken Rockot(use gerrit already), 2016/03/14 19:30:07]

Not crazy about how this logic panned out. We should be able to simplify at
least by getting rid of Loader.

+    // If a ShellClientPtr was provided, there's no more work to do: someone
+    // is already holding a corresponding ShellClientRequest.
+    instance->StartWithClient(std::move(client));
+  } else if (!client_process_connection.is_null()) {
+    // Likewise if a ClientProcessConnection was given via Connect(), it
+    // provides the ShellClient proxy to use.
+    instance->StartWithClientProcessConnection(
+        std::move(client_process_connection));
+  } else {
+    // Otherwise we create a new ShellClient pipe.
+    mojom::ShellClientRequest request = GetProxy(&client);
+    if (LoadWithLoader(target, &request)) {
+      instance->StartWithClient(std::move(client));
+    } else {
+      CHECK(!file_url.is_null() && !capabilities_ptr.is_null());
 
-  Instance* instance = CreateInstance(target, capabilities, std::move(client));
-  instance->ConnectToClient(std::move(params));
-
-  // If a ShellClientPtr was provided, there's no more work to do: someone
-  // is already holding a corresponding ShellClientRequest.
-  if (!request.is_pending())
-    return;
-
-  if (client_process_connection.is_null() && LoadWithLoader(target, &request))
-    return;
-
-  CHECK(!file_url.is_null() && !capabilities_ptr.is_null());
-
-  if (target.name() != resolved_name) {
-    // In cases where a package alias is resolved, we have to use the instance
-    // from the original request rather than for the package itself, which will
-    // always be the same.
-    CreateShellClient(
-        source, Identity(resolved_name, target.user_id(), instance_name),
-        target.name(), std::move(request));
-  } else {
-    if (!client_process_connection.is_null()) {
-      // The client already started a process for this instance, use it.
-      instance->StartWithClientProcessConnection(
-          std::move(request), std::move(client_process_connection));
-    } else {
-      // Otherwise we make our own process.
-      instance->StartWithFilePath(std::move(request),
-                                  util::UrlToFilePath(file_url.To<GURL>()));
+      if (target.name() != resolved_name) {
+        instance->StartWithClient(std::move(client));
+        CreateShellClientWithFactory(
+            source, Identity(resolved_name, target.user_id(), instance_name),
+            target.name(), std::move(request));
+      } else {
+        instance->StartWithFilePath(util::UrlToFilePath(file_url.To<GURL>()));
+      }
     }
   }
+
+  // Now that the instance has a ShellClient, we can connect to it.
+  instance->ConnectToClient(std::move(params));
 }
 
 bool Shell::LoadWithLoader(const Identity& target,
                            mojom::ShellClientRequest* request) {
   Loader* loader = GetLoaderForName(target.name());
   if (!loader)
     return false;
   loader->Load(target.name(), std::move(*request));
   return true;
 }
 
 Loader* Shell::GetLoaderForName(const std::string& name) {
   auto name_it = name_to_loader_.find(name);
   if (name_it != name_to_loader_.end())
     return name_it->second;
   return default_loader_.get();
 }
 
 void Shell::CleanupRunner(NativeRunner* runner) {
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo