Rename {In,OutOf}ProcessDynamicServiceRunner -> ...NativeRunner.

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 14 matching lines @@
 #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/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/in_process_native_runner.h"
+#include "shell/out_of_process_native_runner.h"
 #include "shell/switches.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 // Used to ensure we only init once.
 class Setup {
  public:
   Setup() {
-    embedder::Init(scoped_ptr<mojo::embedder::PlatformSupport>(
-        new mojo::embedder::SimplePlatformSupport()));
+    embedder::Init(make_scoped_ptr(new embedder::SimplePlatformSupport()));
   }
 
   ~Setup() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Setup);
 };
 
 bool ConfigureURLMappings(const base::CommandLine& command_line,
                           Context* context) {
@@ skipping 113 matching lines @@
     manager->SetNativeOptionsForURL(options, gurl);
   }
 }
 
 class TracingServiceProvider : public ServiceProvider {
  public:
   explicit TracingServiceProvider(InterfaceRequest<ServiceProvider> request)
       : binding_(this, request.Pass()) {}
   ~TracingServiceProvider() override {}
 
-  void ConnectToService(const mojo::String& service_name,
+  void ConnectToService(const String& service_name,
                         ScopedMessagePipeHandle client_handle) override {
     if (service_name == tracing::TraceController::Name_) {
       new TraceControllerImpl(
           MakeRequest<tracing::TraceController>(client_handle.Pass()));
     }
   }
 
  private:
   StrongBinding<ServiceProvider> binding_;
 
@@ skipping 76 matching lines @@
       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))
-    runner_factory.reset(new OutOfProcessDynamicServiceRunnerFactory(this));
+    runner_factory.reset(new OutOfProcessNativeRunnerFactory(this));
   else
-    runner_factory.reset(new InProcessDynamicServiceRunnerFactory(this));
+    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));
 
   InitContentHandlers(&application_manager_, command_line);
   InitNativeOptions(&application_manager_, command_line);
 
   ServiceProviderPtr tracing_service_provider_ptr;
@@ skipping 53 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