AddOriginMapping()

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 10 matching lines @@
 #include "mojo/common/trace_controller_impl.h"
 #include "mojo/common/tracing_impl.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "services/tracing/tracing.mojom.h"
 #include "shell/application_manager/application_loader.h"
 #include "shell/application_manager/application_manager.h"
+#include "shell/command_line_util.h"
 #include "shell/dynamic_application_loader.h"
 #include "shell/external_application_listener.h"
 #include "shell/filename_util.h"
 #include "shell/in_process_dynamic_service_runner.h"
 #include "shell/out_of_process_dynamic_service_runner.h"
 #include "shell/switches.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
@@ skipping 79 matching lines @@
   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->AddURLMapping(
       GURL("mojo:network_service"),
       context->ResolveShellFileURL("file:network_service.mojo"));
 
   // Command line URL mapping.
+  std::vector<URLResolver::OriginMapping> origin_mappings =
+      URLResolver::GetOriginMappings(command_line->argv());
+  for (const auto& origin_mapping : origin_mappings)
+    resolver->AddOriginMapping(GURL(origin_mapping.origin),
+                               GURL(origin_mapping.base_url));
+
   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);
@@ skipping 127 matching lines @@
     if (app_urls_.empty() && base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
   }
 }
 
 GURL Context::ResolveURL(const GURL& url) {
   return url_resolver_.ResolveMojoURL(url);
 }
 
 GURL Context::ResolveMappings(const GURL& url) {
-  return url_resolver_.ApplyURLMappings(url);
+  return url_resolver_.ApplyMappings(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