Rename MojoURLResolver to URLResolver

shell/context.cc

 // Copyright 2013 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/context.h"
 
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 87 matching lines @@
       return;
     }
     // TODO(eseidel): We should also validate that the mimetype is valid
     // net/base/mime_util.h could do this, but we don't want to depend on net.
     loader->RegisterContentHandler(parts[i], url);
   }
 }
 
 bool ConfigureURLMappings(base::CommandLine* command_line,
                           Context* context) {
-  MojoURLResolver* resolver = context->mojo_url_resolver();
+  URLResolver* resolver = context->url_resolver();
 
   // Configure the resolution of unknown mojo: URLs.
   GURL base_url;
   if (command_line->HasSwitch(switches::kOrigin))
     base_url = GURL(command_line->GetSwitchValueASCII(switches::kOrigin));
   else
     // Use the shell's file root if the base was not specified.
     base_url = context->ResolveShellFileURL("");
 
   if (!base_url.is_valid())
     return false;
 
-  resolver->SetBaseURL(base_url);
+  resolver->SetMojoBaseURL(base_url);
 
   // The network service must be loaded from the filesystem.
   // This mapping is done before the command line URL mapping are processed, so
   // that it can be overridden.
-  resolver->AddCustomMapping(
+  resolver->AddURLMapping(
       GURL("mojo:network_service"),
       context->ResolveShellFileURL("file:network_service.mojo"));
 
   // Command line URL mapping.
   if (command_line->HasSwitch(switches::kURLMappings)) {
     const std::string mappings =
       command_line->GetSwitchValueASCII(switches::kURLMappings);
 
     base::StringPairs pairs;
     if (!base::SplitStringIntoKeyValuePairs(mappings, '=', ',', &pairs))
       return false;
     using StringPair = std::pair<std::string, std::string>;
     for (const StringPair& pair : pairs) {
       const GURL from(pair.first);
       const GURL to = context->ResolveCommandLineURL(pair.second);
       if (!from.is_valid() || !to.is_valid())
         return false;
-      resolver->AddCustomMapping(from, to);
+      resolver->AddURLMapping(from, to);
     }
   }
   return true;
 }
 
 class TracingServiceProvider : public ServiceProvider {
  public:
   explicit TracingServiceProvider(InterfaceRequest<ServiceProvider> request)
       : binding_(this, request.Pass()) {}
   ~TracingServiceProvider() override {}
@@ skipping 109 matching lines @@
 
 void Context::OnApplicationError(const GURL& url) {
   if (app_urls_.find(url) != app_urls_.end()) {
     app_urls_.erase(url);
     if (app_urls_.empty() && base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
   }
 }
 
 GURL Context::ResolveURL(const GURL& url) {
-  return mojo_url_resolver_.Resolve(url);
+  return url_resolver_.ResolveMojoURL(url);
 }
 
 GURL Context::ResolveMappings(const GURL& url) {
-  return mojo_url_resolver_.ApplyCustomMappings(url);
+  return url_resolver_.ApplyURLMappings(url);
 }
 
 void Context::Run(const GURL& url) {
   ServiceProviderPtr services;
   ServiceProviderPtr exposed_services;
 
   app_urls_.insert(url);
   application_manager_.ConnectToApplication(url, GURL(), GetProxy(&services),
                                             exposed_services.Pass());
 }
 
 ScopedMessagePipeHandle Context::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& service_name) {
   app_urls_.insert(application_url);
   return application_manager_.ConnectToServiceByName(application_url,
                                                      service_name).Pass();
 }
 
 }  // namespace shell
 }  // namespace mojo