Remove the old package manager

mojo/shell/standalone/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/shell/standalone/context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 15 matching lines @@
 #include "build/build_config.h"
 #include "components/tracing/tracing_switches.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/services/tracing/public/cpp/switches.h"
 #include "mojo/services/tracing/public/cpp/trace_provider_impl.h"
 #include "mojo/services/tracing/public/cpp/tracing_impl.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/package_manager/package_manager_impl.h"
-#include "mojo/shell/query_util.h"
 #include "mojo/shell/runner/host/in_process_native_runner.h"
 #include "mojo/shell/runner/host/out_of_process_native_runner.h"
-#include "mojo/shell/standalone/register_local_aliases.h"
 #include "mojo/shell/standalone/switches.h"
 #include "mojo/shell/standalone/tracer.h"
 #include "mojo/shell/switches.h"
 #include "mojo/util/filename_util.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 // Used to ensure we only init once.
 class Setup {
  public:
   Setup() { edk::Init(); }
 
   ~Setup() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Setup);
 };
 
-void InitContentHandlers(PackageManagerImpl* manager,
-                         const base::CommandLine& command_line) {
-  // Default content handlers.
-  manager->RegisterContentHandler("application/javascript",
-                                  GURL("mojo:html_viewer"));
-  manager->RegisterContentHandler("application/pdf", GURL("mojo:pdf_viewer"));
-  manager->RegisterContentHandler("image/gif", GURL("mojo:html_viewer"));
-  manager->RegisterContentHandler("image/jpeg", GURL("mojo:html_viewer"));
-  manager->RegisterContentHandler("image/png", GURL("mojo:html_viewer"));
-  manager->RegisterContentHandler("text/css", GURL("mojo:html_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);
-  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 "\,")
-  // Whatever takes 'parameters' and constructs a CommandLine is failing to
-  // un-escape the commas, we need to move this fix to that file.
-  base::ReplaceSubstringsAfterOffset(&handlers_spec, 0, "\\,", ",");
-#endif
-
-  std::vector<std::string> parts = base::SplitString(
-      handlers_spec, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-  if (parts.size() % 2 != 0) {
-    LOG(ERROR) << "Invalid value for switch " << switches::kContentHandlers
-               << ": must be a comma-separated list of mimetype/url pairs."
-               << handlers_spec;
-    return;
-  }
-
-  for (size_t i = 0; i < parts.size(); i += 2) {
-    GURL url(parts[i + 1]);
-    if (!url.is_valid()) {
-      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);
-  }
-}
-
 class TracingInterfaceProvider : public shell::mojom::InterfaceProvider {
  public:
   TracingInterfaceProvider(Tracer* tracer,
                            shell::mojom::InterfaceProviderRequest request)
       : tracer_(tracer), binding_(this, std::move(request)) {}
   ~TracingInterfaceProvider() override {}
 
   // shell::mojom::InterfaceProvider:
   void GetInterface(const mojo::String& interface_name,
                     ScopedMessagePipeHandle client_handle) override {
     if (tracer_ && interface_name == tracing::TraceProvider::Name_) {
       tracer_->ConnectToProvider(
           MakeRequest<tracing::TraceProvider>(std::move(client_handle)));
     }
   }
 
  private:
   Tracer* tracer_;
   StrongBinding<shell::mojom::InterfaceProvider> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingInterfaceProvider);
 };
 
 }  // namespace
 
-Context::Context()
-    : package_manager_(nullptr), main_entry_time_(base::Time::Now()) {}
+Context::Context() : 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();
 }
@@ skipping 11 matching lines @@
         "mojo_runner.trace");
   }
 
   EnsureEmbedderIsInitialized();
   task_runners_.reset(
       new TaskRunners(base::MessageLoop::current()->task_runner()));
 
   // TODO(vtl): This should be MASTER, not NONE.
   edk::InitIPCSupport(this, task_runners_->io_runner());
 
-  package_manager_ = new PackageManagerImpl(
-      shell_file_root, task_runners_->blocking_pool(), nullptr);
-  InitContentHandlers(package_manager_, command_line);
-
-  RegisterLocalAliases(package_manager_);
-
   scoped_ptr<NativeRunnerFactory> runner_factory;
   if (command_line.HasSwitch(switches::kSingleProcess)) {
 #if defined(COMPONENT_BUILD)
     LOG(ERROR) << "Running Mojo in single process component build, which isn't "
                << "supported because statics in apps interact. Use static build"
                << " or don't pass --single-process.";
 #endif
     runner_factory.reset(
         new InProcessNativeRunnerFactory(task_runners_->blocking_pool()));
   } else {
     runner_factory.reset(
         new OutOfProcessNativeRunnerFactory(task_runners_->blocking_pool()));
   }
   application_manager_.reset(new ApplicationManager(
-      make_scoped_ptr(package_manager_), std::move(runner_factory),
-      task_runners_->blocking_pool(), true));
+      std::move(runner_factory), task_runners_->blocking_pool(), true));
 
   shell::mojom::InterfaceProviderPtr tracing_remote_interfaces;
   shell::mojom::InterfaceProviderPtr tracing_local_interfaces;
   new TracingInterfaceProvider(&tracer_, GetProxy(&tracing_local_interfaces));
 
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
   params->set_source(Identity(GURL("mojo:shell"), std::string(),
                               GetPermissiveCapabilityFilter()));
   params->SetTarget(Identity(GURL("mojo:tracing"), std::string(),
                              GetPermissiveCapabilityFilter()));
@@ skipping 89 matching lines @@
         base::MessageLoop::current()->QuitWhenIdle();
       } else {
         app_complete_callback_.Run();
       }
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo