Eliminate Quit() from Shell, and roll Shell & Connector together.

mojo/shell/application_instance.cc

 // Copyright 2015 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_instance.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 11 matching lines @@
 ApplicationInstance::ApplicationInstance(
     mojom::ShellClientPtr shell_client,
     ApplicationManager* manager,
     const Identity& identity)
     : manager_(manager),
       id_(GenerateUniqueID()),
       identity_(identity),
       allow_any_application_(identity.filter().size() == 1 &&
                              identity.filter().count("*") == 1),
       shell_client_(std::move(shell_client)),
-      binding_(this),
       pid_receiver_binding_(this),
-      queue_requests_(false),
       native_runner_(nullptr),
       pid_(base::kNullProcessId) {
   DCHECK_NE(kInvalidApplicationID, id_);
 }
 
-ApplicationInstance::~ApplicationInstance() {
-  for (auto request : queued_client_requests_)
-    request->connect_callback().Run(kInvalidApplicationID);
-  STLDeleteElements(&queued_client_requests_);
-}
+ApplicationInstance::~ApplicationInstance() {}
 
 void ApplicationInstance::InitializeApplication() {
-  shell_client_->Initialize(binding_.CreateInterfacePtrAndBind(),
+  shell_client_->Initialize(connectors_.CreateInterfacePtrAndBind(this),
                             identity_.url().spec(), id_, identity_.user_id());
-  binding_.set_connection_error_handler([this]() { OnConnectionError(); });
+  connectors_.set_connection_error_handler(
+      base::Bind(&ApplicationManager::OnApplicationInstanceError,
+                 base::Unretained(manager_), base::Unretained(this)));
 }
 
 void ApplicationInstance::ConnectToClient(scoped_ptr<ConnectParams> params) {
-  if (queue_requests_) {
-    queued_client_requests_.push_back(params.release());
-    return;
-  }
+  params->connect_callback().Run(id_);
+  AllowedInterfaces interfaces;
+  interfaces.insert("*");
+  if (!params->source().is_null())
+    interfaces = GetAllowedInterfaces(params->source().filter(), identity_);
 
-  CallAcceptConnection(std::move(params));
+  ApplicationInstance* source =
+      manager_->GetApplicationInstance(params->source());
+  uint32_t source_id = source ? source->id() : kInvalidApplicationID;
+  shell_client_->AcceptConnection(
+      params->source().url().spec(), params->source().user_id(), source_id,
+      params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
+      Array<String>::From(interfaces), params->target().url().spec());
 }
 
 void ApplicationInstance::SetNativeRunner(NativeRunner* native_runner) {
   native_runner_ = native_runner;
 }
 
 void ApplicationInstance::BindPIDReceiver(
     InterfaceRequest<mojom::PIDReceiver> pid_receiver) {
   pid_receiver_binding_.Bind(std::move(pid_receiver));
 }
 
-// Shell implementation:
-void ApplicationInstance::GetConnector(mojom::ConnectorRequest request) {
-  connectors_.AddBinding(this, std::move(request));
-}
-
-void ApplicationInstance::QuitApplication() {
-  queue_requests_ = true;
-  shell_client_->OnQuitRequested(
-      base::Bind(&ApplicationInstance::OnQuitRequestedResult,
-                 base::Unretained(this)));
-}
-
 // Connector implementation:
 void ApplicationInstance::Connect(
     const String& app_url,
     uint32_t user_id,
     shell::mojom::InterfaceProviderRequest remote_interfaces,
     shell::mojom::InterfaceProviderPtr local_interfaces,
     const ConnectCallback& callback) {
   GURL url = app_url.To<GURL>();
   if (!url.is_valid()) {
     LOG(ERROR) << "Error: invalid URL: " << app_url;
@@ skipping 25 matching lines @@
   manager_->ApplicationPIDAvailable(id_, pid);
 }
 
 uint32_t ApplicationInstance::GenerateUniqueID() const {
   static uint32_t id = kInvalidApplicationID;
   ++id;
   CHECK_NE(kInvalidApplicationID, id);
   return id;
 }
 
-void ApplicationInstance::CallAcceptConnection(
-    scoped_ptr<ConnectParams> params) {
-  params->connect_callback().Run(id_);
-  AllowedInterfaces interfaces;
-  interfaces.insert("*");
-  if (!params->source().is_null())
-    interfaces = GetAllowedInterfaces(params->source().filter(), identity_);
-
-  ApplicationInstance* source =
-      manager_->GetApplicationInstance(params->source());
-  uint32_t source_id = source ? source->id() : kInvalidApplicationID;
-  shell_client_->AcceptConnection(
-      params->source().url().spec(), params->source().user_id(), source_id,
-      params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
-      Array<String>::From(interfaces), params->target().url().spec());
-}
-
-void ApplicationInstance::OnConnectionError() {
-  std::vector<ConnectParams*> queued_client_requests;
-  queued_client_requests_.swap(queued_client_requests);
-  auto manager = manager_;
-  manager_->OnApplicationInstanceError(this);
-  //|this| is deleted.
-
-  // If any queued requests came to shell during time it was shutting down,
-  // start them now.
-  for (auto request : queued_client_requests)
-    manager->Connect(make_scoped_ptr(request));
-}
-
-void ApplicationInstance::OnQuitRequestedResult(bool can_quit) {
-  if (can_quit)
-    return;
-
-  queue_requests_ = false;
-  for (auto request : queued_client_requests_)
-    CallAcceptConnection(make_scoped_ptr(request));
-
-  queued_client_requests_.clear();
-}
-
 }  // namespace shell
 }  // namespace mojo