Clean up some unused methods from ApplicationManager

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"
@@ skipping 45 matching lines @@
       weak_ptr_factory_(this) {
   fetcher_->SetApplicationManager(this);
 }
 
 ApplicationManager::~ApplicationManager() {
   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_instance_);
 }
 
 void ApplicationManager::ConnectToApplication(
     ApplicationInstance* originator,
     URLRequestPtr app_url_request,
     const std::string& qualifier,
@@ skipping 204 matching lines @@
       qualifier = alias_iter->second.second;
     }
 
     LoadWithContentHandler(originator_identity, originator_filter,
                            alias_iter->second.first, qualifier, filter,
                            connect_callback, app, request.Pass(),
                            response.Pass());
     return;
   }
 
-  // TODO(aa): Sanity check that the thing we got looks vaguely like a mojo
-  // application. That could either mean looking for the platform-specific dll
-  // header, or looking for some specific mojo signature prepended to the
-  // library.
-  // TODO(vtl): (Maybe this should be done by the factory/runner?)
-
-  GURL base_resolved_url = GetBaseURLAndQuery(fetcher->GetURL(), nullptr);
-  NativeRunnerFactory::Options options;
-  if (url_to_native_options_.find(base_resolved_url) !=
-      url_to_native_options_.end()) {
-    DVLOG(2) << "Applying stored native options to resolved URL "
-             << fetcher->GetURL();
-    options = url_to_native_options_[base_resolved_url];
-  }
-
   // 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)) {
     if (app_url == GURL("mojo://core_services/") && qualifier == "Core")
       start_sandboxed = true;
     else if (app_url == GURL("mojo://html_viewer/"))
       start_sandboxed = true;
   }
 
   connect_callback.Run(Shell::kInvalidContentHandlerID);
 
   fetcher->AsPath(blocking_pool_,
                   base::Bind(&ApplicationManager::RunNativeApplication,
                              weak_ptr_factory_.GetWeakPtr(),
                              base::Passed(request.Pass()), start_sandboxed,
-                             options, base::Passed(fetcher.Pass())));
+                             base::Passed(fetcher.Pass())));
 }
 
 void ApplicationManager::RunNativeApplication(
     InterfaceRequest<Application> application_request,
     bool start_sandboxed,
-    const NativeRunnerFactory::Options& options,
     scoped_ptr<Fetcher> fetcher,
     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());
 
   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());
-  NativeRunner* runner = native_runner_factory_->Create(options).release();
+  NativeRunner* runner = native_runner_factory_->Create().release();
   native_runners_.push_back(runner);
-  runner->Start(path, start_sandboxed, NativeApplicationCleanup::DONT_DELETE,
-                application_request.Pass(),
+  runner->Start(path, start_sandboxed, application_request.Pass(),
                 base::Bind(&ApplicationManager::CleanupRunner,
                            weak_ptr_factory_.GetWeakPtr(), runner));
 }
 
 void ApplicationManager::RegisterContentHandler(
     const std::string& mime_type,
     const GURL& content_handler_url) {
   DCHECK(content_handler_url.is_valid())
       << "Content handler URL is invalid for mime type " << mime_type;
   mime_type_to_url_[mime_type] = content_handler_url;
@@ skipping 38 matching lines @@
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
                                          const GURL& url) {
   URLToLoaderMap::iterator it = url_to_loader_.find(url);
   if (it != url_to_loader_.end())
     delete it->second;
   url_to_loader_[url] = loader.release();
 }
 
-void ApplicationManager::SetLoaderForScheme(
-    scoped_ptr<ApplicationLoader> loader,
-    const std::string& scheme) {
-  SchemeToLoaderMap::iterator it = scheme_to_loader_.find(scheme);
-  if (it != scheme_to_loader_.end())
-    delete it->second;
-  scheme_to_loader_[scheme] = loader.release();
-}
-
-void ApplicationManager::SetNativeOptionsForURL(
-    const NativeRunnerFactory::Options& options,
-    const GURL& url) {
-  DCHECK(!url.has_query());  // Precondition.
-  // Apply mappings and resolution to get the resolved URL.
-  GURL resolved_url = fetcher_->ResolveURL(url);
-  DCHECK(!resolved_url.has_query());  // Still shouldn't have query.
-  // TODO(vtl): We should probably also remove/disregard the query string (and
-  // maybe canonicalize in other ways).
-  DVLOG(2) << "Storing native options for resolved URL " << resolved_url
-           << " (original URL " << url << ")";
-  url_to_native_options_[resolved_url] = options;
-}
-
 ApplicationLoader* ApplicationManager::GetLoaderForURL(const GURL& url) {
   auto url_it = url_to_loader_.find(GetBaseURLAndQuery(url, nullptr));
   if (url_it != url_to_loader_.end())
     return url_it->second;
-  auto scheme_it = scheme_to_loader_.find(url.scheme());
-  if (scheme_it != scheme_to_loader_.end())
-    return scheme_it->second;
   return default_loader_.get();
 }
 
 void ApplicationManager::OnApplicationInstanceError(
     ApplicationInstance* instance) {
   // Called from ~ApplicationInstance, so we do not need to call Destroy here.
   const Identity identity = instance->identity();
   base::Closure on_application_end = instance->on_application_end();
   // Remove the shell.
   auto it = identity_to_instance_.find(identity);
@@ skipping 32 matching lines @@
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
 Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo