Cleanup runner and ApplicationInfo creation

R=sky@chromium.org
BUG=

Review URL: https://codereview.chromium.org/1748843002

Cr-Commit-Position: refs/heads/master@{#378380}

8 files changed, 188 insertions, 167 deletions

diff --git a/mash/task_viewer/task_viewer.cc b/mash/task_viewer/task_viewer.cc
index 948cd1a..15176d7 100644
--- a/mash/task_viewer/task_viewer.cc
+++ b/mash/task_viewer/task_viewer.cc
@@ -31,17 +31,14 @@ namespace mash {
 namespace task_viewer {
 namespace {
 
-using ListenerRequest =
-    mojo::InterfaceRequest<mojo::shell::mojom::ApplicationManagerListener>;
-using mojo::shell::mojom::ApplicationInfoPtr;
-
-class TaskViewerContents
-    : public views::WidgetDelegateView,
-      public ui::TableModel,
-      public views::ButtonListener,
-      public mojo::shell::mojom::ApplicationManagerListener {
+using mojo::shell::mojom::InstanceInfoPtr;
+
+class TaskViewerContents : public views::WidgetDelegateView,
+                           public ui::TableModel,
+                           public views::ButtonListener,
+                           public mojo::shell::mojom::InstanceListener {
  public:
-  TaskViewerContents(ListenerRequest request,
+  TaskViewerContents(mojo::shell::mojom::InstanceListenerRequest request,
                      package_manager::mojom::CatalogPtr catalog)
       : binding_(this, std::move(request)),
         catalog_(std::move(catalog)),
@@ -139,32 +136,30 @@ class TaskViewerContents
     process.Terminate(9, true);
   }
 
-  // Overridden from mojo::shell::mojom::ApplicationManagerListener:
-  void SetRunningApplications(
-      mojo::Array<ApplicationInfoPtr> applications) override {
+  // Overridden from mojo::shell::mojom::InstanceListener:
+  void SetExistingInstances(mojo::Array<InstanceInfoPtr> instances) override {
     // This callback should only be called with an empty model.
     DCHECK(instances_.empty());
     mojo::Array<mojo::String> names;
-    for (size_t i = 0; i < applications.size(); ++i) {
-      InsertInstance(applications[i]->id, applications[i]->name,
-                     applications[i]->pid);
-      names.push_back(applications[i]->name);
+    for (size_t i = 0; i < instances.size(); ++i) {
+      InsertInstance(instances[i]->id, instances[i]->name, instances[i]->pid);
+      names.push_back(instances[i]->name);
     }
     catalog_->GetEntries(std::move(names),
                          base::Bind(&TaskViewerContents::OnGotCatalogEntries,
                                     weak_ptr_factory_.GetWeakPtr()));
   }
-  void ApplicationInstanceCreated(ApplicationInfoPtr application) override {
-    DCHECK(!ContainsId(application->id));
-    InsertInstance(application->id, application->name, application->pid);
+  void InstanceCreated(InstanceInfoPtr instance) override {
+    DCHECK(!ContainsId(instance->id));
+    InsertInstance(instance->id, instance->name, instance->pid);
     observer_->OnItemsAdded(static_cast<int>(instances_.size()), 1);
     mojo::Array<mojo::String> names;
-    names.push_back(application->name);
+    names.push_back(instance->name);
     catalog_->GetEntries(std::move(names),
                          base::Bind(&TaskViewerContents::OnGotCatalogEntries,
                                     weak_ptr_factory_.GetWeakPtr()));
   }
-  void ApplicationInstanceDestroyed(uint32_t id) override {
+  void InstanceDestroyed(uint32_t id) override {
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
       if ((*it)->id == id) {
         observer_->OnItemsRemoved(
@@ -175,7 +170,7 @@ class TaskViewerContents
     }
     NOTREACHED();
   }
-  void ApplicationPIDAvailable(uint32_t id, uint32_t pid) override {
+  void InstancePIDAvailable(uint32_t id, uint32_t pid) override {
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
       if ((*it)->id == id) {
         (*it)->pid = pid;
@@ -243,7 +238,7 @@ class TaskViewerContents
     return columns;
   }
 
-  mojo::Binding<mojo::shell::mojom::ApplicationManagerListener> binding_;
+  mojo::Binding<mojo::shell::mojom::InstanceListener> binding_;
   package_manager::mojom::CatalogPtr catalog_;
 
   views::TableView* table_view_;
@@ -274,9 +269,9 @@ void TaskViewer::Initialize(mojo::Connector* connector,
   mojo::shell::mojom::ApplicationManagerPtr application_manager;
   connector->ConnectToInterface("mojo:shell", &application_manager);
 
-  mojo::shell::mojom::ApplicationManagerListenerPtr listener;
-  ListenerRequest request = GetProxy(&listener);
-  application_manager->AddListener(std::move(listener));
+  mojo::shell::mojom::InstanceListenerPtr listener;
+  mojo::shell::mojom::InstanceListenerRequest request = GetProxy(&listener);
+  application_manager->AddInstanceListener(std::move(listener));
 
   package_manager::mojom::CatalogPtr catalog;
   connector->ConnectToInterface("mojo:package_manager", &catalog);
diff --git a/mojo/services/package_manager/package_manager.cc b/mojo/services/package_manager/package_manager.cc
index 0eb697c..60618e20c 100644
--- a/mojo/services/package_manager/package_manager.cc
+++ b/mojo/services/package_manager/package_manager.cc
@@ -41,7 +41,7 @@ ApplicationInfo BuildApplicationInfoFromDictionary(
   ApplicationInfo info;
   std::string name_string;
   CHECK(value.GetString(ApplicationCatalogStore::kNameKey, &name_string));
-  CHECK(mojo::IsValidName(name_string));
+  CHECK(mojo::IsValidName(name_string)) << "Invalid Name: " << name_string;
   info.name = name_string;
   CHECK(value.GetString(ApplicationCatalogStore::kDisplayNameKey,
                         &info.display_name));
diff --git a/mojo/shell/BUILD.gn b/mojo/shell/BUILD.gn
index 4b9c2c7..60edc37 100644
--- a/mojo/shell/BUILD.gn
+++ b/mojo/shell/BUILD.gn
@@ -2,6 +2,7 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import("//mojo/public/mojo_application_manifest.gni")
 import("//mojo/public/tools/bindings/mojom.gni")
 import("//testing/test.gni")
 
@@ -35,6 +36,7 @@ source_set("shell") {
   ]
 
   deps = [
+    ":manifest",
     "//base",
     "//base/third_party/dynamic_annotations",
     "//mojo/common",
@@ -54,3 +56,8 @@ source_set("shell") {
   # For mojo/shell/application_loader.h
   allow_circular_includes_from = [ "//mojo/services/package_manager:lib" ]
 }
+
+mojo_application_manifest("manifest") {
+  application_name = "shell"
+  source = "manifest.json"
+}
diff --git a/mojo/shell/application_manager.cc b/mojo/shell/application_manager.cc
index e2d1de0..2d6a034 100644
--- a/mojo/shell/application_manager.cc
+++ b/mojo/shell/application_manager.cc
@@ -32,6 +32,15 @@
 
 namespace mojo {
 namespace shell {
+namespace {
+const char kPackageManagerName[] = "mojo:package_manager";
+
+void EmptyResolverCallback(const String& resolved_name,
+                           const String& resolved_qualifier,
+                           mojom::CapabilityFilterPtr base_filter,
+                           const String& file_url) {}
+
+}
 
 // Encapsulates a connection to an instance of an application, tracked by the
 // shell's ApplicationManager.
@@ -47,7 +56,12 @@ class ApplicationManager::Instance : public mojom::Connector,
       allow_any_application_(identity.filter().size() == 1 &&
       identity.filter().count("*") == 1),
       shell_client_(std::move(shell_client)),
-      pid_receiver_binding_(this) {
+      pid_receiver_binding_(this),
+      weak_factory_(this) {
+    if (identity_.name() == "mojo:shell" ||
+        manager_->GetLoaderForName(identity_.name())) {
+      pid_ = base::Process::Current().Pid();
+    }
     DCHECK_NE(kInvalidApplicationID, id_);
   }
 
@@ -76,20 +90,45 @@ class ApplicationManager::Instance : public mojom::Connector,
         Array<String>::From(interfaces), params->target().name());
   }
 
-  // Required before GetProcessId can be called.
-  void SetNativeRunner(NativeRunner* native_runner) {
-    native_runner_ = native_runner;
+  scoped_ptr<NativeRunner> StartWithFileURL(const GURL& file_url,
+                                            mojom::ShellClientRequest request,
+                                            bool start_sandboxed,
+                                            NativeRunnerFactory* factory) {
+    base::FilePath path = util::UrlToFilePath(file_url);
+    scoped_ptr<NativeRunner> runner = factory->Create(path);
+    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,
+      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));
+    return runner;
   }
 
-  void BindPIDReceiver(mojom::PIDReceiverRequest pid_receiver) {
-    pid_receiver_binding_.Bind(std::move(pid_receiver));
+  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;
   }
 
-  mojom::ShellClient* shell_client() { return shell_client_.get(); }
   const Identity& identity() const { return identity_; }
   uint32_t id() const { return id_; }
-  base::ProcessId pid() const { return pid_; }
-  void set_pid(base::ProcessId pid) { pid_ = pid; }
 
  private:
   // Connector implementation:
@@ -125,8 +164,7 @@ class ApplicationManager::Instance : public mojom::Connector,
 
   // PIDReceiver implementation:
   void SetPID(uint32_t pid) override {
-    // This will call us back to update pid_.
-    manager_->ApplicationPIDAvailable(id_, pid);
+    PIDAvailable(pid);
   }
 
   uint32_t GenerateUniqueID() const {
@@ -136,6 +174,11 @@ class ApplicationManager::Instance : public mojom::Connector,
     return id;
   }
 
+  void PIDAvailable(base::ProcessId pid) {
+    pid_ = pid;
+    manager_->NotifyPIDAvailable(id_, pid_);
+  }
+
   ApplicationManager* const manager_;
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
@@ -146,8 +189,9 @@ class ApplicationManager::Instance : public mojom::Connector,
   mojom::ShellClientPtr shell_client_;
   Binding<mojom::PIDReceiver> pid_receiver_binding_;
   BindingSet<mojom::Connector> connectors_;
-  NativeRunner* native_runner_ = nullptr;
+  NativeRunner* runner_ = nullptr;
   base::ProcessId pid_ = base::kNullProcessId;
+  base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
@@ -279,22 +323,20 @@ void ApplicationManager::CreateInstanceForHandle(
   target_id.set_filter(filter->filter.To<CapabilityFilter>());
   mojom::ShellClientRequest request;
   Instance* instance = CreateInstance(target_id, &request);
-  instance->BindPIDReceiver(std::move(pid_receiver));
-  scoped_ptr<NativeRunner> runner =
-      native_runner_factory_->Create(base::FilePath());
-  runner->InitHost(std::move(channel), std::move(request));
-  instance->SetNativeRunner(runner.get());
-  native_runners_.push_back(std::move(runner));
+  native_runners_.push_back(
+      instance->StartWithChannel(std::move(channel), std::move(request),
+                                 std::move(pid_receiver),
+                                 native_runner_factory_.get()));
 }
 
-void ApplicationManager::AddListener(
-    mojom::ApplicationManagerListenerPtr listener) {
-  Array<mojom::ApplicationInfoPtr> applications;
-  for (auto& entry : identity_to_instance_)
-    applications.push_back(CreateApplicationInfoForInstance(entry.second));
-  listener->SetRunningApplications(std::move(applications));
+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));
 
-  listeners_.AddInterfacePtr(std::move(listener));
+  instance_listeners_.AddInterfacePtr(std::move(listener));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -304,15 +346,22 @@ void ApplicationManager::InitPackageManager(
     scoped_ptr<package_manager::ApplicationCatalogStore> app_catalog) {
   scoped_ptr<Loader> loader(
       new package_manager::Loader(file_task_runner_, std::move(app_catalog)));
+  Loader* loader_raw = loader.get();
+  std::string name = kPackageManagerName;
+  SetLoaderForName(std::move(loader), name);
 
   mojom::ShellClientRequest request;
-  std::string name = "mojo:package_manager";
   CreateInstance(Identity(name), &request);
-  loader->Load(name, std::move(request));
-
-  SetLoaderForName(std::move(loader), name);
+  loader_raw->Load(name, std::move(request));
 
   ConnectToInterface(this, CreateShellIdentity(), name, &shell_resolver_);
+
+  // Seed the catalog with manifest info for the shell & package manager.
+  if (file_task_runner_) {
+    shell_resolver_->ResolveMojoName(name, base::Bind(&EmptyResolverCallback));
+    shell_resolver_->ResolveMojoName("mojo:shell",
+                                     base::Bind(&EmptyResolverCallback));
+  }
 }
 
 void ApplicationManager::TerminateShellConnections() {
@@ -327,10 +376,9 @@ void ApplicationManager::OnInstanceError(Instance* instance) {
   int id = instance->id();
   delete it->second;
   identity_to_instance_.erase(it);
-  listeners_.ForAllPtrs(
-      [this, id](mojom::ApplicationManagerListener* listener) {
-        listener->ApplicationInstanceDestroyed(id);
-      });
+  instance_listeners_.ForAllPtrs([this, id](mojom::InstanceListener* listener) {
+                                   listener->InstanceDestroyed(id);
+                                 });
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
@@ -341,19 +389,10 @@ ApplicationManager::Instance* ApplicationManager::GetExistingInstance(
   return it != identity_to_instance_.end() ? it->second : nullptr;
 }
 
-void ApplicationManager::ApplicationPIDAvailable(
-    uint32_t id,
-    base::ProcessId pid) {
-  for (auto& instance : identity_to_instance_) {
-    if (instance.second->id() == id) {
-      instance.second->set_pid(pid);
-      break;
-    }
-  }
-  listeners_.ForAllPtrs(
-      [this, id, pid](mojom::ApplicationManagerListener* listener) {
-        listener->ApplicationPIDAvailable(id, pid);
-      });
+void ApplicationManager::NotifyPIDAvailable(uint32_t id, base::ProcessId pid) {
+  instance_listeners_.ForAllPtrs([id, pid](mojom::InstanceListener* listener) {
+                                   listener->InstancePIDAvailable(id, pid);
+                                 });
 }
 
 bool ApplicationManager::ConnectToExistingInstance(
@@ -378,11 +417,10 @@ ApplicationManager::Instance* ApplicationManager::CreateInstance(
   DCHECK(identity_to_instance_.find(target_id) ==
          identity_to_instance_.end());
   identity_to_instance_[target_id] = instance;
-  mojom::ApplicationInfoPtr application_info =
-      CreateApplicationInfoForInstance(instance);
-  listeners_.ForAllPtrs(
-      [this, &application_info](mojom::ApplicationManagerListener* listener) {
-        listener->ApplicationInstanceCreated(application_info.Clone());
+  mojom::InstanceInfoPtr info = instance->CreateInstanceInfo();
+  instance_listeners_.ForAllPtrs(
+      [this, &info](mojom::InstanceListener* listener) {
+        listener->InstanceCreated(info.Clone());
       });
   instance->Initialize();
   return instance;
@@ -464,15 +502,10 @@ void ApplicationManager::OnGotResolvedName(
         target.name(), std::move(request));
   } else {
     bool start_sandboxed = false;
-    base::FilePath path = util::UrlToFilePath(file_url.To<GURL>());
-    scoped_ptr<NativeRunner> runner = native_runner_factory_->Create(path);
-    runner->Start(path, target, start_sandboxed, std::move(request),
-                  base::Bind(&ApplicationManager::ApplicationPIDAvailable,
-                             weak_ptr_factory_.GetWeakPtr(), instance->id()),
-                  base::Bind(&ApplicationManager::CleanupRunner,
-                             weak_ptr_factory_.GetWeakPtr(), runner.get()));
-    instance->SetNativeRunner(runner.get());
-    native_runners_.push_back(std::move(runner));
+    native_runners_.push_back(
+        instance->StartWithFileURL(file_url.To<GURL>(), std::move(request),
+                                   start_sandboxed,
+                                   native_runner_factory_.get()));
   }
 }
 
@@ -501,18 +534,5 @@ void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   }
 }
 
-mojom::ApplicationInfoPtr ApplicationManager::CreateApplicationInfoForInstance(
-    Instance* instance) const {
-  mojom::ApplicationInfoPtr info(mojom::ApplicationInfo::New());
-  info->id = instance->id();
-  info->name = instance->identity().name();
-  info->qualifier = instance->identity().qualifier();
-  if (instance->identity().name() == "mojo:shell")
-    info->pid = base::Process::Current().Pid();
-  else
-    info->pid = instance->pid();
-  return info;
-}
-
 }  // namespace shell
 }  // namespace mojo
diff --git a/mojo/shell/application_manager.h b/mojo/shell/application_manager.h
index 55e0bc7..ff81be1 100644
--- a/mojo/shell/application_manager.h
+++ b/mojo/shell/application_manager.h
@@ -110,7 +110,7 @@ class ApplicationManager : public ShellClient,
                                const String& name,
                                mojom::CapabilityFilterPtr filter,
                                mojom::PIDReceiverRequest pid_receiver) override;
-  void AddListener(mojom::ApplicationManagerListenerPtr listener) override;
+  void AddInstanceListener(mojom::InstanceListenerPtr listener) override;
 
   void InitPackageManager(
       scoped_ptr<package_manager::ApplicationCatalogStore> app_catalog);
@@ -125,7 +125,7 @@ class ApplicationManager : public ShellClient,
 
   Instance* GetExistingInstance(const Identity& identity) const;
 
-  void ApplicationPIDAvailable(uint32_t id, base::ProcessId pid);
+  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,
@@ -170,9 +170,6 @@ class ApplicationManager : public ShellClient,
 
   void CleanupRunner(NativeRunner* runner);
 
-  mojom::ApplicationInfoPtr CreateApplicationInfoForInstance(
-      Instance* instance) const;
-
   package_manager::mojom::ShellResolverPtr shell_resolver_;
 
   // Loader management.
@@ -189,7 +186,7 @@ class ApplicationManager : public ShellClient,
   // The Instance created by the shell embedder, if any.
   Instance* embedder_instance_ = nullptr;
 
-  InterfacePtrSet<mojom::ApplicationManagerListener> listeners_;
+  InterfacePtrSet<mojom::InstanceListener> instance_listeners_;
 
   base::Callback<void(const Identity&)> instance_quit_callback_;
   base::TaskRunner* file_task_runner_;
diff --git a/mojo/shell/manifest.json b/mojo/shell/manifest.json
new file mode 100644
index 0000000..609708d
--- /dev/null
+++ b/mojo/shell/manifest.json
@@ -0,0 +1,5 @@
+{
+  "name": "mojo:shell",
+  "display_name": "Shell",
+  "capabilities": {}
+}
diff --git a/mojo/shell/public/interfaces/application_manager.mojom b/mojo/shell/public/interfaces/application_manager.mojom
index 2193a32..943c767 100644
--- a/mojo/shell/public/interfaces/application_manager.mojom
+++ b/mojo/shell/public/interfaces/application_manager.mojom
@@ -6,35 +6,34 @@ module mojo.shell.mojom;
 
 import "mojo/shell/public/interfaces/shell.mojom";
 
-struct ApplicationInfo {
+struct InstanceInfo {
   uint32 id;
   string name;
   string qualifier;
   uint32 pid;
 };
 
-// Implemented by an application that wishes to be informed when the list of
-// running applications changes.
-interface ApplicationManagerListener {
+// Implemented by a client that wishes to be informed when the list of running
+// instances changes.
+interface InstanceListener {
   // Called once when the listener is added via
-  // ApplicationManager::AddListener() to provide the initial list of running
-  // applications that the listener observes changes against.
-  SetRunningApplications(array<ApplicationInfo> applications);
+  // ApplicationManager::AddInstanceListener() to provide the initial list of
+  // instances that the listener observes changes against.
+  SetExistingInstances(array<InstanceInfo> instances);
 
-  // Called when the application manager has started tracking an application.
+  // Called when the application manager has started tracking an instance.
   // This happens when the application manager first handles a request to launch
-  // the application, and before any process or content handler is created for
-  // it.
-  ApplicationInstanceCreated(ApplicationInfo application);
+  // the instance, before any process is created for it.
+  InstanceCreated(InstanceInfo instance);
 
-  // Called when the application manager has stopped tracking an application.
+  // Called when the application manager has stopped tracking an instance.
   // (i.e. when it has ended/quit).
-  ApplicationInstanceDestroyed(uint32 id);
+  InstanceDestroyed(uint32 id);
 
-  // Called when a pid is available for the application. This could be because a
+  // Called when a pid is available for the instance. This could be because a
   // process was created by the runner for it, or because an existing content
   // handler process was assigned.
-  ApplicationPIDAvailable(uint32 id, uint32 pid);
+  InstancePIDAvailable(uint32 id, uint32 pid);
 };
 
 // Implemented by an object in the application manager associated with a
@@ -56,6 +55,6 @@ interface ApplicationManager {
                           CapabilityFilter filter,
                           PIDReceiver& pid_receiver);
 
-  // The listener is removed when the pipe is closed.
-  AddListener(ApplicationManagerListener listener);
+  // The listener is removed when the |listener| pipe is closed.
+  AddInstanceListener(InstanceListener listener);
 };
diff --git a/mojo/shell/tests/application_manager_apptest.cc b/mojo/shell/tests/application_manager_apptest.cc
index e5a3cd5b..d5bd7e0 100644
--- a/mojo/shell/tests/application_manager_apptest.cc
+++ b/mojo/shell/tests/application_manager_apptest.cc
@@ -65,7 +65,7 @@ class ApplicationManagerAppTestDelegate
 }  // namespace
 
 class ApplicationManagerAppTest : public mojo::test::ApplicationTestBase,
-                                  public mojom::ApplicationManagerListener {
+                                  public mojom::InstanceListener {
  public:
   ApplicationManagerAppTest() : delegate_(nullptr), binding_(this) {}
   ~ApplicationManagerAppTest() override {}
@@ -75,8 +75,8 @@ class ApplicationManagerAppTest : public mojo::test::ApplicationTestBase,
   }
 
  protected:
-  struct ApplicationInfo {
-    ApplicationInfo(uint32_t id, const std::string& name)
+  struct InstanceInfo {
+    InstanceInfo(uint32_t id, const std::string& name)
         : id(id), name(name), pid(base::kNullProcessId) {}
 
     uint32_t id;
@@ -88,17 +88,18 @@ class ApplicationManagerAppTest : public mojo::test::ApplicationTestBase,
     mojom::ApplicationManagerPtr application_manager;
     connector()->ConnectToInterface("mojo:shell", &application_manager);
 
-    application_manager->AddListener(binding_.CreateInterfacePtrAndBind());
+    application_manager->AddInstanceListener(
+        binding_.CreateInterfacePtrAndBind());
     binding_.WaitForIncomingMethodCall();
   }
 
-  bool ContainsApplicationWithName(const std::string& name) const {
-    for (const auto& application : initial_applications_) {
-      if (application.name == name)
+  bool ContainsInstanceWithName(const std::string& name) const {
+    for (const auto& instance : initial_instances_) {
+      if (instance.name == name)
         return true;
     }
-    for (const auto& application : applications_) {
-      if (application.name == name)
+    for (const auto& instance : instances_) {
+      if (instance.name == name)
         return true;
     }
     return false;
@@ -109,8 +110,8 @@ class ApplicationManagerAppTest : public mojo::test::ApplicationTestBase,
     return delegate_->target_id();
   }
 
-  const std::vector<ApplicationInfo>& applications() const {
-    return applications_;
+  const std::vector<InstanceInfo>& instances() const {
+    return instances_;
   }
 
   ApplicationManagerAppTestDelegate* delegate() { return delegate_; }
@@ -122,41 +123,38 @@ class ApplicationManagerAppTest : public mojo::test::ApplicationTestBase,
     return delegate_;
   }
 
-  // mojom::ApplicationManagerListener:
-  void SetRunningApplications(
-      Array<mojom::ApplicationInfoPtr> applications) override {
-    for (size_t i = 0; i < applications.size(); ++i) {
-      initial_applications_.push_back(ApplicationInfo(applications[i]->id,
-                                                      applications[i]->name));
+  // mojom::InstanceListener:
+  void SetExistingInstances(Array<mojom::InstanceInfoPtr> instances) override {
+    for (size_t i = 0; i < instances.size(); ++i) {
+      initial_instances_.push_back(InstanceInfo(instances[i]->id,
+                                                instances[i]->name));
     }
   }
-  void ApplicationInstanceCreated(
-      mojom::ApplicationInfoPtr application) override {
-    applications_.push_back(
-        ApplicationInfo(application->id, application->name));
+  void InstanceCreated(mojom::InstanceInfoPtr instance) override {
+    instances_.push_back(InstanceInfo(instance->id, instance->name));
   }
-  void ApplicationInstanceDestroyed(uint32_t id) override {
-    for (auto it = applications_.begin(); it != applications_.end(); ++it) {
-      auto& application = *it;
-      if (application.id == id) {
-        applications_.erase(it);
+  void InstanceDestroyed(uint32_t id) override {
+    for (auto it = instances_.begin(); it != instances_.end(); ++it) {
+      auto& instance = *it;
+      if (instance.id == id) {
+        instances_.erase(it);
         break;
       }
     }
   }
-  void ApplicationPIDAvailable(uint32_t id, uint32_t pid) override {
-    for (auto& application : applications_) {
-      if (application.id == id) {
-        application.pid = pid;
+  void InstancePIDAvailable(uint32_t id, uint32_t pid) override {
+    for (auto& instance : instances_) {
+      if (instance.id == id) {
+        instance.pid = pid;
         break;
       }
     }
   }
 
   ApplicationManagerAppTestDelegate* delegate_;
-  Binding<mojom::ApplicationManagerListener> binding_;
-  std::vector<ApplicationInfo> applications_;
-  std::vector<ApplicationInfo> initial_applications_;
+  Binding<mojom::InstanceListener> binding_;
+  std::vector<InstanceInfo> instances_;
+  std::vector<InstanceInfo> initial_instances_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationManagerAppTest);
 };
@@ -181,24 +179,24 @@ TEST_F(ApplicationManagerAppTest, CreateInstanceForHandle) {
 
   // 3. Validate that this test suite's name was received from the application
   //    manager.
-  EXPECT_TRUE(ContainsApplicationWithName("mojo:mojo_shell_apptests"));
+  EXPECT_TRUE(ContainsInstanceWithName("mojo:mojo_shell_apptests"));
 
   // 4. Validate that the right applications/processes were created.
   //    Note that the target process will be created even if the tests are
   //    run with --single-process.
-  EXPECT_EQ(2u, applications().size());
+  EXPECT_EQ(2u, instances().size());
   {
-    auto& application = applications().front();
-    EXPECT_EQ(remote_id, application.id);
-    EXPECT_EQ("exe:application_manager_apptest_driver", application.name);
-    EXPECT_NE(base::kNullProcessId, application.pid);
+    auto& instance = instances().front();
+    EXPECT_EQ(remote_id, instance.id);
+    EXPECT_EQ("exe:application_manager_apptest_driver", instance.name);
+    EXPECT_NE(base::kNullProcessId, instance.pid);
   }
   {
-    auto& application = applications().back();
+    auto& instance = instances().back();
     // We learn about the target process id via a ping from it.
-    EXPECT_EQ(target_id(), application.id);
-    EXPECT_EQ("exe:application_manager_apptest_target", application.name);
-    EXPECT_NE(base::kNullProcessId, application.pid);
+    EXPECT_EQ(target_id(), instance.id);
+    EXPECT_EQ("exe:application_manager_apptest_target", instance.name);
+    EXPECT_NE(base::kNullProcessId, instance.pid);
   }
 
   driver.set_connection_error_handler(