Move runner stuff into a runner namespace.

mojo/runner/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 "mojo/runner/context.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 18 matching lines @@
 #include "mojo/runner/in_process_native_runner.h"
 #include "mojo/runner/out_of_process_native_runner.h"
 #include "mojo/runner/switches.h"
 #include "mojo/services/tracing/tracing.mojom.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/application_manager.h"
 #include "mojo/util/filename_util.h"
 #include "url/gurl.h"
 
 namespace mojo {
-namespace shell {
+namespace runner {
 namespace {
 
 // Used to ensure we only init once.
 class Setup {
  public:
   Setup() {
     embedder::Init(make_scoped_ptr(new embedder::SimplePlatformSupport()));
   }
 
   ~Setup() {}
@@ skipping 46 matching lines @@
       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,
+void InitContentHandlers(shell::ApplicationManager* manager,
                          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);
   if (handlers_spec.empty())
@@ skipping 26 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);
   }
 }
 
-void InitNativeOptions(ApplicationManager* manager,
+void InitNativeOptions(shell::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;
     }
 
-    NativeRunnerFactory::Options options;
+    shell::NativeRunnerFactory::Options options;
     options.force_in_process = true;
     manager->SetNativeOptionsForURL(options, gurl);
   }
 }
 
 class TracingServiceProvider : public ServiceProvider {
  public:
   explicit TracingServiceProvider(InterfaceRequest<ServiceProvider> request)
       : binding_(this, request.Pass()) {}
   ~TracingServiceProvider() override {}
@@ skipping 71 matching lines @@
   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());
 
-  scoped_ptr<NativeRunnerFactory> runner_factory;
+  scoped_ptr<shell::NativeRunnerFactory> runner_factory;
   if (command_line.HasSwitch(switches::kEnableMultiprocess))
     runner_factory.reset(new OutOfProcessNativeRunnerFactory(this));
   else
     runner_factory.reset(new InProcessNativeRunnerFactory(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));
 
@@ skipping 46 matching lines @@
   if (app_urls_.find(url) != app_urls_.end()) {
     app_urls_.erase(url);
     if (app_urls_.empty() && base::MessageLoop::current()->is_running()) {
       DCHECK_EQ(base::MessageLoop::current()->task_runner(),
                 task_runners_->shell_runner());
       base::MessageLoop::current()->Quit();
     }
   }
 }
 
-}  // namespace shell
+}  // namespace runner
 }  // namespace mojo