Replace ChildController with ShellClientFactory

mojo/shell/application_manager.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/application_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 88 matching lines @@
     runner_ = runner.get();
     runner_->Start(path, identity_, start_sandboxed, std::move(request),
                    base::Bind(&Instance::PIDAvailable,
                               weak_factory_.GetWeakPtr()),
                    base::Bind(&ApplicationManager::CleanupRunner,
                               manager_->weak_ptr_factory_.GetWeakPtr(),
                               runner_));
     return runner;
   }
 
-  scoped_ptr<NativeRunner> StartWithChannel(
-      ScopedHandle channel,
+  scoped_ptr<NativeRunner> StartWithFactory(
+      mojom::ShellClientFactoryPtr shell_client_factory,
+      const String& name,
       mojom::ShellClientRequest request,
       mojom::PIDReceiverRequest pid_receiver_request,
       NativeRunnerFactory* factory) {
     pid_receiver_binding_.Bind(std::move(pid_receiver_request));
     scoped_ptr<NativeRunner> runner = factory->Create(base::FilePath());
     runner_ = runner.get();
-    runner_->InitHost(std::move(channel), std::move(request));
+    runner_->InitHost(std::move(shell_client_factory), name,
+                      std::move(request));
     return runner;
   }
 
   mojom::InstanceInfoPtr CreateInstanceInfo() const {
     mojom::InstanceInfoPtr info(mojom::InstanceInfo::New());
     info->id = id_;
     info->name = identity_.name();
     info->qualifier = identity_.qualifier();
     info->pid = pid_;
     return info;
@@ skipping 174 matching lines @@
 //     implementation:
 
 void ApplicationManager::Create(Connection* connection,
                                 mojom::ApplicationManagerRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ApplicationManager, mojom::ApplicationManager implemetation:
 
-void ApplicationManager::CreateInstanceForHandle(
-    ScopedHandle channel,
+void ApplicationManager::CreateInstanceForFactory(
+    mojom::ShellClientFactoryPtr factory,
     const String& name,
     mojom::CapabilityFilterPtr filter,
     mojom::PIDReceiverRequest pid_receiver) {
   // We don't call ConnectToClient() here since the instance was created
   // manually by other code, not in response to a Connect() request. The newly
   // created instance is identified by |name| and may be subsequently reached by
   // client code using this identity.
   // TODO(beng): obtain userid from the inbound connection.
   Identity target_id(name, std::string(), mojom::Connector::kUserInherit);
   target_id.set_filter(filter->filter.To<CapabilityFilter>());
   mojom::ShellClientRequest request;
   Instance* instance = CreateInstance(target_id, &request);
   native_runners_.push_back(
-      instance->StartWithChannel(std::move(channel), std::move(request),
+      instance->StartWithFactory(std::move(factory), name, std::move(request),
                                  std::move(pid_receiver),
                                  native_runner_factory_.get()));
 }
 
 void ApplicationManager::AddInstanceListener(
     mojom::InstanceListenerPtr listener) {
   Array<mojom::InstanceInfoPtr> instances;
   for (auto& instance : identity_to_instance_)
     instances.push_back(instance.second->CreateInstanceInfo());
   listener->SetExistingInstances(std::move(instances));
@@ skipping 197 matching lines @@
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo