ApplicationImpl->ShellConnection, mojom::Application->mojom::ShellClient

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 122 matching lines @@
     InterfaceRequest<mojom::PIDReceiver> pid_receiver) {
   // Instances created by others are considered unique, and thus have no
   // identity. As such they cannot be connected to by anyone else, and so we
   // never call ConnectToClient().
   // TODO(beng): GetPermissiveCapabilityFilter() here obviously cannot make it
   //             to production. See note in application_manager.mojom.
   //             http://crbug.com/555392
   CapabilityFilter local_filter = filter->filter.To<CapabilityFilter>();
   Identity target_id(url, std::string(), local_filter);
   ApplicationInstance* instance = nullptr;
-  InterfaceRequest<mojom::Application> application_request =
+  InterfaceRequest<mojom::ShellClient> request =
       CreateInstance(target_id, base::Closure(), &instance);
   instance->BindPIDReceiver(std::move(pid_receiver));
   scoped_ptr<NativeRunner> runner =
       native_runner_factory_->Create(base::FilePath());
-  runner->InitHost(std::move(channel), std::move(application_request));
+  runner->InitHost(std::move(channel), std::move(request));
   instance->SetNativeRunner(runner.get());
   native_runners_.push_back(std::move(runner));
 }
 
 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));
 
   listeners_.AddInterfacePtr(std::move(listener));
 }
 
 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);
       });
 }
 
-InterfaceRequest<mojom::Application>
+InterfaceRequest<mojom::ShellClient>
     ApplicationManager::CreateAndConnectToInstance(
         scoped_ptr<ConnectToApplicationParams> params,
         ApplicationInstance** resulting_instance) {
   ApplicationInstance* instance = nullptr;
-  InterfaceRequest<mojom::Application> application_request =
+  InterfaceRequest<mojom::ShellClient> request =
       CreateInstance(params->target(), params->on_application_end(), &instance);
   instance->ConnectToClient(std::move(params));
   if (resulting_instance)
     *resulting_instance = instance;
-  return application_request;
+  return request;
 }
 
-InterfaceRequest<mojom::Application> ApplicationManager::CreateInstance(
+InterfaceRequest<mojom::ShellClient> ApplicationManager::CreateInstance(
     const Identity& target_id,
     const base::Closure& on_application_end,
     ApplicationInstance** resulting_instance) {
-  mojom::ApplicationPtr application;
-  InterfaceRequest<mojom::Application> application_request =
-      GetProxy(&application);
+  mojom::ShellClientPtr shell_client;
+  InterfaceRequest<mojom::ShellClient> request = GetProxy(&shell_client);
   ApplicationInstance* instance = new ApplicationInstance(
-      std::move(application), this, target_id,
+      std::move(shell_client), this, target_id,
       mojom::Shell::kInvalidApplicationID, on_application_end);
   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());
       });
   instance->InitializeApplication();
   if (resulting_instance)
     *resulting_instance = instance;
-  return application_request;
+  return request;
 }
 
 void ApplicationManager::HandleFetchCallback(
     scoped_ptr<ConnectToApplicationParams> params,
     scoped_ptr<Fetcher> fetcher) {
   if (!fetcher) {
     // Network error. Drop |params| to tell the requestor.
     params->connect_callback().Run(mojom::Shell::kInvalidApplicationID,
                                    mojom::Shell::kInvalidApplicationID);
     return;
@@ skipping 19 matching lines @@
   // have two copies of the app running, so check again.
   if (ConnectToRunningApplication(&params))
     return;
 
   Identity source = params->source();
   Identity target = params->target();
   mojom::Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
-  InterfaceRequest<mojom::Application> request(
+  InterfaceRequest<mojom::ShellClient> request(
       CreateAndConnectToInstance(std::move(params), &app));
 
   uint32_t content_handler_id = package_manager_->HandleWithContentHandler(
       fetcher.get(), source, target.url(), target.filter(), &request);
   if (content_handler_id != mojom::Shell::kInvalidApplicationID) {
     app->set_requesting_content_handler_id(content_handler_id);
     connect_callback.Run(app->id(), content_handler_id);
     return;
   }
 
@@ skipping 11 matching lines @@
 
   fetcher->AsPath(
       task_runner_,
       base::Bind(&ApplicationManager::RunNativeApplication,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(request)), start_sandboxed,
                  base::Passed(std::move(fetcher)), base::Unretained(app)));
 }
 
 void ApplicationManager::RunNativeApplication(
-    InterfaceRequest<mojom::Application> application_request,
+    InterfaceRequest<mojom::ShellClient> request,
     bool start_sandboxed,
     scoped_ptr<Fetcher> fetcher,
     ApplicationInstance* instance,
     const base::FilePath& path,
     bool path_exists) {
   // We only passed fetcher to keep it alive. Done with it now.
   fetcher.reset();
 
-  DCHECK(application_request.is_pending());
+  DCHECK(request.is_pending());
 
   if (!path_exists) {
     LOG(ERROR) << "Library not started because library path '" << path.value()
                << "' does not exist.";
     return;
   }
 
   TRACE_EVENT1("mojo_shell", "ApplicationManager::RunNativeApplication", "path",
                path.AsUTF8Unsafe());
   scoped_ptr<NativeRunner> runner = native_runner_factory_->Create(path);
-  runner->Start(path, start_sandboxed, std::move(application_request),
+  runner->Start(path, 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));
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
                                          const GURL& url) {
@@ skipping 52 matching lines @@
     }
   }
 }
 
 mojom::Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo