Documents what ApplicationManager::Delegate do

shell/application_manager/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 "shell/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 29 matching lines @@
     return v2;
   if (!v2.size())
     return v1;
   std::vector<std::string> result(v1);
   result.insert(result.end(), v1.begin(), v1.end());
   return result;
 }
 
 }  // namespace
 
-ApplicationManager::Delegate::~Delegate() {
-}
-
-GURL ApplicationManager::Delegate::ResolveURL(const GURL& url) {
-  return url;
-}
-
-GURL ApplicationManager::Delegate::ResolveMappings(const GURL& url) {
-  return url;
-}
-
 class ApplicationManager::ContentHandlerConnection : public mojo::ErrorHandler {
  public:
   ContentHandlerConnection(ApplicationManager* manager,
                            const GURL& content_handler_url)
       : manager_(manager), content_handler_url_(content_handler_url) {
     ServiceProviderPtr services;
     manager->ConnectToApplication(content_handler_url, GURL(),
                                   mojo::GetProxy(&services), nullptr,
                                   base::Closure());
     mojo::MessagePipe pipe;
@@ skipping 75 matching lines @@
 
   // We check both the mapped and resolved urls for existing shell_impls because
   // external applications can be registered for the unresolved mojo:foo urls.
 
   GURL mapped_url = delegate_->ResolveMappings(requested_url);
   if (ConnectToRunningApplication(mapped_url, requestor_url, &services,
                                   &exposed_services)) {
     return;
   }
 
-  GURL resolved_url = delegate_->ResolveURL(mapped_url);
+  GURL resolved_url = delegate_->ResolveMojoURL(mapped_url);
   if (ConnectToRunningApplication(resolved_url, requestor_url, &services,
                                   &exposed_services)) {
     return;
   }
 
   // The application is not running, let's compute the parameters.
   std::vector<std::string> parameters =
       Concatenate(pre_redirect_parameters, GetArgsForURL(resolved_url));
 
   if (ConnectToApplicationWithLoader(mapped_url, requestor_url, &services,
@@ skipping 259 matching lines @@
 }
 
 void ApplicationManager::SetArgsForURL(const std::vector<std::string>& args,
                                        const GURL& url) {
   url_to_args_[url].insert(url_to_args_[url].end(), args.begin(), args.end());
   GURL mapped_url = delegate_->ResolveMappings(url);
   if (mapped_url != url) {
     url_to_args_[mapped_url].insert(url_to_args_[mapped_url].end(),
                                     args.begin(), args.end());
   }
-  GURL resolved_url = delegate_->ResolveURL(mapped_url);
+  GURL resolved_url = delegate_->ResolveMojoURL(mapped_url);
   if (resolved_url != mapped_url) {
     url_to_args_[resolved_url].insert(url_to_args_[resolved_url].end(),
                                       args.begin(), args.end());
   }
 }
 
 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 = delegate_->ResolveURL(delegate_->ResolveMappings(url));
+  GURL resolved_url =
+      delegate_->ResolveMojoURL(delegate_->ResolveMappings(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));
@@ skipping 45 matching lines @@
     return args_it->second;
   return std::vector<std::string>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell