Extract some stuff into PackageManager

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 11 matching lines @@
 #include "build/build_config.h"
 #include "components/devtools_service/public/cpp/switches.h"
 #include "components/devtools_service/public/interfaces/devtools_service.mojom.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #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/fetcher/base_application_fetcher.h"
+#include "mojo/package_manager/package_manager_impl.h"
 #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/public/cpp/switches.h"
 #include "mojo/services/tracing/public/interfaces/tracing.mojom.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/connect_to_application_params.h"
 #include "mojo/shell/query_util.h"
 #include "mojo/shell/switches.h"
 #include "mojo/util/filename_util.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace runner {
 namespace {
 
 // Used to ensure we only init once.
 class Setup {
  public:
   Setup() {
     embedder::Init(make_scoped_ptr(new embedder::SimplePlatformSupport()));
   }
 
   ~Setup() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Setup);
 };
 
-void InitContentHandlers(shell::ApplicationManager* manager,
+void InitContentHandlers(package_manager::PackageManagerImpl* 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"));
   manager->RegisterContentHandler("text/plain", GURL("mojo:html_viewer"));
 
   // Command-line-specified content handlers.
   std::string handlers_spec =
       command_line.GetSwitchValueASCII(switches::kContentHandlers);
@@ skipping 82 matching lines @@
 
  private:
   StrongBinding<ServiceProvider> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingServiceProvider);
 };
 
 }  // namespace
 
 Context::Context(const base::FilePath& shell_file_root)
-    : application_manager_(new shell::ApplicationManager(make_scoped_ptr(
-          new fetcher::BaseApplicationFetcher(shell_file_root)))),
-      main_entry_time_(base::Time::Now()) {}
+    : shell_file_root_(shell_file_root), main_entry_time_(base::Time::Now()) {}
 
 Context::~Context() {
   DCHECK(!base::MessageLoop::current());
 }
 
 // static
 void Context::EnsureEmbedderIsInitialized() {
   static base::LazyInstance<Setup>::Leaky setup = LAZY_INSTANCE_INITIALIZER;
   setup.Get();
 }
 
 bool Context::Init() {
   TRACE_EVENT0("mojo_shell", "Context::Init");
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
   EnsureEmbedderIsInitialized();
   task_runners_.reset(
       new TaskRunners(base::MessageLoop::current()->task_runner()));
 
   // TODO(vtl): This should be MASTER, not NONE.
   embedder::InitIPCSupport(
       embedder::ProcessType::NONE, task_runners_->shell_runner(), this,
       task_runners_->io_runner(), embedder::ScopedPlatformHandle());
 
+  package_manager_ = new package_manager::PackageManagerImpl(shell_file_root_);
+  InitContentHandlers(package_manager_, command_line);
+
+  application_manager_.reset(
+      new shell::ApplicationManager(make_scoped_ptr(package_manager_)));
+
   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());
 
-  InitContentHandlers(application_manager_.get(), command_line);
-
   ServiceProviderPtr service_provider_ptr;
   ServiceProviderPtr tracing_service_provider_ptr;
   new TracingServiceProvider(GetProxy(&tracing_service_provider_ptr));
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From("mojo:tracing");
   application_manager_->ConnectToApplication(
       nullptr, request.Pass(), std::string(), GetProxy(&service_provider_ptr),
       tracing_service_provider_ptr.Pass(),
       shell::GetPermissiveCapabilityFilter(), base::Closure(),
       shell::EmptyConnectCallback());
@@ skipping 78 matching lines @@
         base::MessageLoop::current()->Quit();
       } else {
         app_complete_callback_.Run();
       }
     }
   }
 }
 
 }  // namespace runner
 }  // namespace mojo