Add --force-in-process flag to shell.

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 37 matching lines @@
     embedder::Init(scoped_ptr<mojo::embedder::PlatformSupport>(
         new mojo::embedder::SimplePlatformSupport()));
   }
 
   ~Setup() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Setup);
 };
 
+bool ConfigureURLMappings(const base::CommandLine& command_line,
+                          Context* context) {
+  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->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"));
+
+  // Temporary mapping to avoid workflow breakages after app rename.
+  resolver->AddURLMapping(GURL("mojo:sample_app"), GURL("mojo:spinning_cube"));
+
+  // 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);
+      const GURL to = context->ResolveCommandLineURL(pair.second);
+      if (!from.is_valid() || !to.is_valid())
+        return false;
+      resolver->AddURLMapping(from, to);
+    }
+  }
+  return true;
+}
+
 void InitContentHandlers(ApplicationManager* manager,
-                         base::CommandLine* command_line) {
+                         const base::CommandLine& command_line) {
   // Default content handlers.
   manager->RegisterContentHandler("application/pdf", GURL("mojo:pdf_viewer"));
   manager->RegisterContentHandler("image/png", GURL("mojo:png_viewer"));
   manager->RegisterContentHandler("text/html", GURL("mojo:html_viewer"));
 
   // Command-line-specified content handlers.
   std::string handlers_spec =
-      command_line->GetSwitchValueASCII(switches::kContentHandlers);
+      command_line.GetSwitchValueASCII(switches::kContentHandlers);
   if (handlers_spec.empty())
     return;
 
 #if defined(OS_ANDROID)
   // TODO(eseidel): On Android we pass command line arguments is via the
   // 'parameters' key on the intent, which we specify during 'am shell start'
   // via --esa, however that expects comma-separated values and says:
   //   am shell --help:
   //     [--esa <EXTRA_KEY> <EXTRA_STRING_VALUE>[,<EXTRA_STRING_VALUE...]]
   //     (to embed a comma into a string escape it using "\,")
@@ skipping 17 matching lines @@
       LOG(ERROR) << "Invalid value for switch " << switches::kContentHandlers
                  << ": '" << parts[i + 1] << "' is not a valid URL.";
       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.
     manager->RegisterContentHandler(parts[i], url);
   }
 }
 
-bool ConfigureURLMappings(base::CommandLine* command_line, Context* context) {
-  URLResolver* resolver = context->url_resolver();
+void InitNativeOptions(ApplicationManager* manager,
+                       const base::CommandLine& command_line) {
+  std::vector<std::string> force_in_process_url_list;
+  base::SplitString(command_line.GetSwitchValueASCII(switches::kForceInProcess),
+                    ',', &force_in_process_url_list);
+  for (const auto& force_in_process_url : force_in_process_url_list) {
+    GURL gurl(force_in_process_url);
+    if (!gurl.is_valid()) {
+      LOG(ERROR) << "Invalid value for switch " << switches::kForceInProcess
+                 << ": '" << force_in_process_url << "'is not a valid URL.";
+      return;
+    }
 
-  // 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->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"));
-
-  // Temporary mapping to avoid workflow breakages after app rename.
-  resolver->AddURLMapping(GURL("mojo:sample_app"), GURL("mojo:spinning_cube"));
-
-  // 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);
-      const GURL to = context->ResolveCommandLineURL(pair.second);
-      if (!from.is_valid() || !to.is_valid())
-        return false;
-      resolver->AddURLMapping(from, to);
-    }
+    NativeRunnerFactory::Options options;
+    options.force_in_process = true;
+    manager->SetNativeOptionsForURL(options, gurl);
   }
-  return true;
 }
 
 class TracingServiceProvider : public ServiceProvider {
  public:
   explicit TracingServiceProvider(InterfaceRequest<ServiceProvider> request)
       : binding_(this, request.Pass()) {}
   ~TracingServiceProvider() override {}
 
   void ConnectToService(const mojo::String& service_name,
                         ScopedMessagePipeHandle client_handle) override {
@@ skipping 46 matching lines @@
 
 void Context::SetCommandLineCWD(const base::FilePath& path) {
   command_line_cwd_ = AddTrailingSlashIfNeeded(FilePathToFileURL(path));
 }
 
 GURL Context::ResolveCommandLineURL(const std::string& path) {
   return command_line_cwd_.Resolve(path);
 }
 
 bool Context::Init() {
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
 
-  if (command_line->HasSwitch(switches::kWaitForDebugger))
+  if (command_line.HasSwitch(switches::kWaitForDebugger))
     base::debug::WaitForDebugger(60, true);
 
   EnsureEmbedderIsInitialized();
   task_runners_.reset(
       new TaskRunners(base::MessageLoop::current()->message_loop_proxy()));
 
   // TODO(vtl): Probably these failures should be checked before |Init()|, and
   // this function simply shouldn't fail.
   if (!shell_file_root_.is_valid())
     return false;
   if (!ConfigureURLMappings(command_line, this))
     return false;
 
   // TODO(vtl): This should be MASTER, not NONE.
   embedder::InitIPCSupport(
       embedder::ProcessType::NONE, task_runners_->shell_runner(), this,
       task_runners_->io_runner(), embedder::ScopedPlatformHandle());
 
-  if (command_line->HasSwitch(switches::kEnableExternalApplications)) {
+  if (command_line.HasSwitch(switches::kEnableExternalApplications)) {
     listener_.reset(new ExternalApplicationListener(
         task_runners_->shell_runner(), task_runners_->io_runner()));
 
     base::FilePath socket_path =
-        command_line->GetSwitchValuePath(switches::kEnableExternalApplications);
+        command_line.GetSwitchValuePath(switches::kEnableExternalApplications);
     if (socket_path.empty())
       socket_path = ExternalApplicationListener::ConstructDefaultSocketPath();
 
     listener_->ListenInBackground(
         socket_path,
         base::Bind(&ApplicationManager::RegisterExternalApplication,
                    base::Unretained(&application_manager_)));
   }
 
   scoped_ptr<NativeRunnerFactory> runner_factory;
-  if (command_line->HasSwitch(switches::kEnableMultiprocess))
+  if (command_line.HasSwitch(switches::kEnableMultiprocess))
     runner_factory.reset(new OutOfProcessDynamicServiceRunnerFactory(this));
   else
     runner_factory.reset(new InProcessDynamicServiceRunnerFactory(this));
   application_manager_.set_blocking_pool(task_runners_->blocking_pool());
   application_manager_.set_native_runner_factory(runner_factory.Pass());
   application_manager_.set_disable_cache(
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableCache));
 
   InitContentHandlers(&application_manager_, command_line);
+  InitNativeOptions(&application_manager_, command_line);
 
   ServiceProviderPtr tracing_service_provider_ptr;
   new TracingServiceProvider(GetProxy(&tracing_service_provider_ptr));
   application_manager_.ConnectToApplication(
       GURL("mojo:tracing"), GURL(""), nullptr,
       tracing_service_provider_ptr.Pass());
 
   if (listener_)
     listener_->WaitForListening();
 
@@ skipping 45 matching lines @@
 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