Mandoline: Move ContentHandlerConnection into separate file

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/application/public/interfaces/content_handler.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
+#include "mojo/shell/content_handler_connection.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/local_fetcher.h"
 #include "mojo/shell/network_fetcher.h"
 #include "mojo/shell/query_util.h"
 #include "mojo/shell/shell_impl.h"
 #include "mojo/shell/switches.h"
 #include "mojo/shell/update_fetcher.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
 // Used by TestAPI.
 bool has_created_instance = false;
 
 }  // namespace
 
-class ApplicationManager::ContentHandlerConnection : public ErrorHandler {
- public:
-  ContentHandlerConnection(ApplicationManager* manager,
-                           const GURL& content_handler_url,
-                           const GURL& requestor_url,
-                           const std::string& qualifier)
-      : manager_(manager),
-        content_handler_url_(content_handler_url),
-        content_handler_qualifier_(qualifier) {
-    ServiceProviderPtr services;
-    mojo::URLRequestPtr request(mojo::URLRequest::New());
-    request->url = mojo::String::From(content_handler_url.spec());
-    manager->ConnectToApplicationInternal(
-        request.Pass(), qualifier, requestor_url, GetProxy(&services),
-        nullptr, base::Closure());
-    MessagePipe pipe;
-    content_handler_.Bind(
-        InterfacePtrInfo<ContentHandler>(pipe.handle0.Pass(), 0u));
-    services->ConnectToService(ContentHandler::Name_, pipe.handle1.Pass());
-    content_handler_.set_error_handler(this);
-  }
-
-  ContentHandler* content_handler() { return content_handler_.get(); }
-
-  GURL content_handler_url() { return content_handler_url_; }
-  std::string content_handler_qualifier() { return content_handler_qualifier_; }
-
- private:
-  // ErrorHandler implementation:
-  void OnConnectionError() override { manager_->OnContentHandlerError(this); }
-
-  ApplicationManager* manager_;
-  GURL content_handler_url_;
-  std::string content_handler_qualifier_;
-  ContentHandlerPtr content_handler_;
-
-  DISALLOW_COPY_AND_ASSIGN(ContentHandlerConnection);
-};
-
 // static
 ApplicationManager::TestAPI::TestAPI(ApplicationManager* manager)
     : manager_(manager) {
 }
 
 ApplicationManager::TestAPI::~TestAPI() {
 }
 
 bool ApplicationManager::TestAPI::HasCreatedInstance() {
   return has_created_instance;
 }
 
 bool ApplicationManager::TestAPI::HasFactoryForURL(const GURL& url) const {
   return manager_->identity_to_shell_impl_.find(Identity(url)) !=
          manager_->identity_to_shell_impl_.end();
 }
 
 ApplicationManager::ApplicationManager(Delegate* delegate)
     : delegate_(delegate), weak_ptr_factory_(this) {
 }
 
 ApplicationManager::~ApplicationManager() {
-  STLDeleteValues(&url_to_content_handler_);
+  URLToContentHandlerMap url_to_content_handler(url_to_content_handler_);
+  for (auto& pair : url_to_content_handler)
+    pair.second->CloseConnection();
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
   STLDeleteValues(&scheme_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_shell_impl_);
 }
 
 void ApplicationManager::ConnectToApplication(
     mojo::URLRequestPtr requested_url,
-    const GURL& requestor_url,
-    InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
-    const base::Closure& on_application_end) {
-  ConnectToApplicationInternal(
-      requested_url.Pass(), std::string(), requestor_url, services.Pass(),
-      exposed_services.Pass(), on_application_end);
-}
-
-void ApplicationManager::ConnectToApplicationInternal(
-    mojo::URLRequestPtr requested_url,
     const std::string& qualifier,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const base::Closure& on_application_end) {
   GURL requested_gurl(requested_url->url.To<std::string>());
   TRACE_EVENT_INSTANT1(
       "mojo_shell", "ApplicationManager::ConnectToApplication",
       TRACE_EVENT_SCOPE_THREAD, "requested_url", requested_gurl.spec());
   DCHECK(requested_gurl.is_valid());
@@ skipping 177 matching lines @@
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     // TODO(sky): this loses |requested_url|.
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From(redirect_url.spec());
     HttpHeaderPtr header = HttpHeader::New();
     header->name = "Referer";
     header->value = fetcher->GetRedirectReferer().spec();
     request->headers.push_back(header.Pass());
-    ConnectToApplicationInternal(request.Pass(), qualifier, requestor_url,
-                                 services.Pass(), exposed_services.Pass(),
-                                 on_application_end);
+    ConnectToApplication(request.Pass(), qualifier, requestor_url,
+                         services.Pass(), exposed_services.Pass(),
+                         on_application_end);
     return;
   }
 
   // We already checked if the application was running before we fetched it, but
   // it might have started while the fetch was outstanding. We don't want to
   // have two copies of the app running, so check again.
   //
   // Also, it's possible the original URL was redirected to an app that is
   // already running.
   if (ConnectToRunningApplication(requested_url, qualifier, requestor_url,
@@ skipping 187 matching lines @@
   base::Closure on_application_end = shell_impl->on_application_end();
   // Remove the shell.
   auto it = identity_to_shell_impl_.find(identity);
   DCHECK(it != identity_to_shell_impl_.end());
   delete it->second;
   identity_to_shell_impl_.erase(it);
   if (!on_application_end.is_null())
     on_application_end.Run();
 }
 
-void ApplicationManager::OnContentHandlerError(
+void ApplicationManager::OnContentHandlerConnectionClosed(
     ContentHandlerConnection* content_handler) {
   // Remove the mapping to the content handler.
   auto it = url_to_content_handler_.find(
       std::make_pair(content_handler->content_handler_url(),
                      content_handler->content_handler_qualifier()));
   DCHECK(it != url_to_content_handler_.end());
-  delete it->second;
   url_to_content_handler_.erase(it);
 }
 
 ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& interface_name) {
   ServiceProviderPtr services;
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(application_url.spec());
-  ConnectToApplication(request.Pass(), GURL(), GetProxy(&services), nullptr,
-                       base::Closure());
+  ConnectToApplication(request.Pass(), std::string(), GURL(),
+                       GetProxy(&services), nullptr, base::Closure());
   MessagePipe pipe;
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell
 }  // namespace mojo