Pass application ids via AcceptConnection & ConnectToApplication callback.

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 14 matching lines @@
 #include "mojo/shell/switches.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
 // Used by TestAPI.
 bool has_created_instance = false;
 
-void OnEmptyOnConnectCallback(uint32_t content_handler_id) {}
+void OnEmptyOnConnectCallback(uint32_t remote_id, uint32_t content_handler_id) {
+}
 
 }  // namespace
 
 // static
 ApplicationManager::TestAPI::TestAPI(ApplicationManager* manager)
     : manager_(manager) {
 }
 
 ApplicationManager::TestAPI::~TestAPI() {
 }
@@ skipping 21 matching lines @@
       native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
   package_manager_->SetApplicationManager(this);
   SetLoaderForURL(make_scoped_ptr(new ShellApplicationLoader(this)),
                   GURL("mojo:shell"));
 }
 
 ApplicationManager::~ApplicationManager() {
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
+  for (auto& runner : native_runners_)
+    runner.reset();
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void ApplicationManager::ConnectToApplication(
     scoped_ptr<ConnectToApplicationParams> params) {
   TRACE_EVENT_INSTANT1("mojo_shell", "ApplicationManager::ConnectToApplication",
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
@@ skipping 62 matching lines @@
     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(
-    int id,
+    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);
@@ skipping 12 matching lines @@
   return application_request;
 }
 
 InterfaceRequest<Application> ApplicationManager::CreateInstance(
     const Identity& target_id,
     const base::Closure& on_application_end,
     ApplicationInstance** resulting_instance) {
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ApplicationInstance* instance = new ApplicationInstance(
-      std::move(application), this, target_id, Shell::kInvalidContentHandlerID,
+      std::move(application), this, target_id, 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;
 }
 
 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(Shell::kInvalidContentHandlerID);
+    params->connect_callback().Run(Shell::kInvalidApplicationID,
+                                   Shell::kInvalidApplicationID);
     return;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     // TODO(sky): this loses the original URL info.
     URLRequestPtr new_request = URLRequest::New();
     new_request->url = redirect_url.spec();
     HttpHeaderPtr header = HttpHeader::New();
@@ skipping 15 matching lines @@
   Identity target = params->target();
   Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
   InterfaceRequest<Application> 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 != Shell::kInvalidContentHandlerID) {
+  if (content_handler_id != Shell::kInvalidApplicationID) {
     app->set_requesting_content_handler_id(content_handler_id);
-    connect_callback.Run(content_handler_id);
+    connect_callback.Run(app->id(), content_handler_id);
     return;
   }
 
   // TODO(erg): Have a better way of switching the sandbox on. For now, switch
   // it on hard coded when we're using some of the sandboxable core services.
   bool start_sandboxed = false;
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoNoSandbox)) {
     start_sandboxed = (target.url() == GURL("mojo://core_services/") &&
                           target.qualifier() == "Core") ||
                       target.url() == GURL("mojo://html_viewer/");
   }
 
-  connect_callback.Run(Shell::kInvalidContentHandlerID);
+  connect_callback.Run(app->id(), Shell::kInvalidApplicationID);
 
   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(
@@ skipping 81 matching lines @@
     }
   }
 }
 
 Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo