Simplify the ApplicationLoader interface in preparation for changes.

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 11 matching lines @@
 #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/native_application_loader.h"
 #include "shell/out_of_process_dynamic_service_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()));
   }
 
   ~Setup() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Setup);
 };
 
 static base::LazyInstance<Setup>::Leaky setup = LAZY_INSTANCE_INITIALIZER;
 
-void InitContentHandlers(DynamicApplicationLoader* loader,
+void InitContentHandlers(NativeApplicationLoader* loader,
                          base::CommandLine* command_line) {
   // Default content handlers.
   loader->RegisterContentHandler("application/pdf", GURL("mojo:pdf_viewer"));
   loader->RegisterContentHandler("image/png", GURL("mojo:png_viewer"));
   loader->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 179 matching lines @@
         base::Bind(&ApplicationManager::RegisterExternalApplication,
                    base::Unretained(&application_manager_)));
   }
 
   scoped_ptr<DynamicServiceRunnerFactory> runner_factory;
   if (command_line->HasSwitch(switches::kEnableMultiprocess))
     runner_factory.reset(new OutOfProcessDynamicServiceRunnerFactory());
   else
     runner_factory.reset(new InProcessDynamicServiceRunnerFactory());
 
-  DynamicApplicationLoader* dynamic_application_loader =
-      new DynamicApplicationLoader(this, runner_factory.Pass());
-  InitContentHandlers(dynamic_application_loader, command_line);
-  application_manager_.set_default_loader(
-      scoped_ptr<ApplicationLoader>(dynamic_application_loader));
+  scoped_ptr<NativeApplicationLoader> native_application_loader(
+      new NativeApplicationLoader(this, runner_factory.Pass()));
+  InitContentHandlers(native_application_loader.get(), command_line);
+  application_manager_.set_native_application_loader(
+      scoped_ptr<NativeApplicationLoader>(native_application_loader.Pass()));
 
   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 38 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