Extract some stuff into PackageManager:

- content handler determination from ApplicationManager::HandleFetchCallback
- content handler registration
- renames BaseApplicationFetcher to PackageManagerImpl.

R=yzshen@chromium.org
BUG=

Review URL: https://codereview.chromium.org/1352663002

Cr-Commit-Position: refs/heads/master@{#349357}

4 files changed, 264 insertions, 0 deletions

diff --git a/mojo/package_manager/BUILD.gn b/mojo/package_manager/BUILD.gn
new file mode 100644
index 0000000..913a36d
--- /dev/null
+++ b/mojo/package_manager/BUILD.gn
@@ -0,0 +1,16 @@
+# Copyright 2015 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.
+
+source_set("package_manager") {
+  sources = [
+    "package_manager_impl.cc",
+    "package_manager_impl.h",
+  ]
+
+  deps = [
+    "//mojo/fetcher",
+    "//mojo/shell",
+    "//mojo/util:filename_util",
+  ]
+}
diff --git a/mojo/package_manager/DEPS b/mojo/package_manager/DEPS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/mojo/package_manager/DEPS
diff --git a/mojo/package_manager/package_manager_impl.cc b/mojo/package_manager/package_manager_impl.cc
new file mode 100644
index 0000000..f1a1fc6
--- /dev/null
+++ b/mojo/package_manager/package_manager_impl.cc
@@ -0,0 +1,172 @@
+// Copyright 2015 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/package_manager/package_manager_impl.h"
+
+#include "mojo/fetcher/about_fetcher.h"
+#include "mojo/fetcher/local_fetcher.h"
+#include "mojo/fetcher/network_fetcher.h"
+#include "mojo/fetcher/switches.h"
+#include "mojo/fetcher/update_fetcher.h"
+#include "mojo/shell/application_manager.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 package_manager {
+
+PackageManagerImpl::PackageManagerImpl(
+    const base::FilePath& shell_file_root)
+    : application_manager_(nullptr),
+      disable_cache_(base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableCache)) {
+  if (!shell_file_root.empty()) {
+    GURL mojo_root_file_url =
+        util::FilePathToFileURL(shell_file_root).Resolve(std::string());
+    url_resolver_.reset(new fetcher::URLResolver(mojo_root_file_url));
+  }
+}
+
+PackageManagerImpl::~PackageManagerImpl() {
+}
+
+void PackageManagerImpl::RegisterContentHandler(
+    const std::string& mime_type,
+    const GURL& content_handler_url) {
+  DCHECK(content_handler_url.is_valid())
+      << "Content handler URL is invalid for mime type " << mime_type;
+  mime_type_to_url_[mime_type] = content_handler_url;
+}
+
+void PackageManagerImpl::RegisterApplicationPackageAlias(
+    const GURL& alias,
+    const GURL& content_handler_package,
+    const std::string& qualifier) {
+  application_package_alias_[alias] =
+      std::make_pair(content_handler_package, qualifier);
+}
+
+void PackageManagerImpl::SetApplicationManager(
+    shell::ApplicationManager* manager) {
+  application_manager_ = manager;
+}
+
+GURL PackageManagerImpl::ResolveURL(const GURL& url) {
+  return url_resolver_.get() ? url_resolver_->ResolveMojoURL(url) : url;
+}
+
+void PackageManagerImpl::FetchRequest(
+    URLRequestPtr request,
+    const shell::Fetcher::FetchCallback& loader_callback) {
+  GURL url(request->url);
+  if (url.SchemeIs(fetcher::AboutFetcher::kAboutScheme)) {
+    fetcher::AboutFetcher::Start(url, loader_callback);
+    return;
+  }
+
+  GURL resolved_url = ResolveURL(url);
+
+  if (resolved_url.SchemeIsFile()) {
+    // LocalFetcher uses the network service to infer MIME types from URLs.
+    // Skip this for mojo URLs to avoid recursively loading the network service.
+    if (!network_service_ && !url.SchemeIs("mojo")) {
+      application_manager_->ConnectToService(GURL("mojo:network_service"),
+                                            &network_service_);
+    }
+    // Ownership of this object is transferred to |loader_callback|.
+    // TODO(beng): this is eff'n weird.
+    new fetcher::LocalFetcher(
+        network_service_.get(), resolved_url,
+        shell::GetBaseURLAndQuery(resolved_url, nullptr),
+        loader_callback);
+    return;
+  }
+
+#if 0
+  // TODO(beng): figure out how this should be integrated now that mapped_url
+  //             is toast.
+  // TODO(scottmg): to quote someone I know, if you liked this you shouldda put
+  //                a test on it.
+  if (url.SchemeIs("mojo") &&
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseUpdater)) {
+    application_manager_->ConnectToService(GURL("mojo:updater"), &updater_);
+    // Ownership of this object is transferred to |loader_callback|.
+    // TODO(beng): this is eff'n weird.
+    new fetcher::UpdateFetcher(url, updater_.get(), loader_callback);
+    return;
+  }
+#endif
+
+  if (!url_loader_factory_) {
+    application_manager_->ConnectToService(GURL("mojo:network_service"),
+                                           &url_loader_factory_);
+  }
+
+  // Ownership of this object is transferred to |loader_callback|.
+  // TODO(beng): this is eff'n weird.
+  new fetcher::NetworkFetcher(disable_cache_, request.Pass(),
+                              url_loader_factory_.get(), loader_callback);
+}
+
+bool PackageManagerImpl::HandleWithContentHandler(shell::Fetcher* fetcher,
+                                                  const GURL& unresolved_url,
+                                                  base::TaskRunner* task_runner,
+                                                  URLResponsePtr* new_response,
+                                                  GURL* content_handler_url,
+                                                  std::string* qualifier) {
+  // TODO(beng): it seems like some delegate should/would want to have a say in
+  //             configuring the qualifier also.
+  bool enable_multi_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableMultiprocess);
+
+  // The response begins with a #!mojo <content-handler-url>.
+  std::string shebang;
+  if (fetcher->PeekContentHandler(&shebang, content_handler_url)) {
+    *new_response = fetcher->AsURLResponse(
+        task_runner, static_cast<int>(shebang.size()));
+    *qualifier = enable_multi_process ? (*new_response)->site.To<std::string>()
+                                      : std::string();
+    return true;
+  }
+
+  // The response MIME type matches a registered content handler.
+  MimeTypeToURLMap::iterator iter = mime_type_to_url_.find(fetcher->MimeType());
+  if (iter != mime_type_to_url_.end()) {
+    *new_response = fetcher->AsURLResponse(task_runner, 0);
+    *content_handler_url = iter->second;
+    *qualifier = enable_multi_process ? (*new_response)->site.To<std::string>()
+                                      : std::string();
+    return true;
+  }
+
+  // The response URL matches a registered content handler.
+  auto alias_iter = application_package_alias_.find(unresolved_url);
+  if (alias_iter != application_package_alias_.end()) {
+    // We replace the qualifier with the one our package alias requested.
+    *new_response = URLResponse::New();
+    (*new_response)->url = unresolved_url.spec();
+
+    // Why can't we use this in single process mode? Because of
+    // base::AtExitManager. If you link in ApplicationRunner into your code, and
+    // then we make initialize multiple copies of the application, we end up
+    // with multiple AtExitManagers and will check on the second one being
+    // created.
+    //
+    // Why doesn't that happen when running different apps? Because
+    // your_thing.mojo!base::AtExitManager and
+    // my_thing.mojo!base::AtExitManager are different symbols.
+    *qualifier = enable_multi_process ? alias_iter->second.second
+                                      : std::string();
+    *content_handler_url = alias_iter->second.first;
+    return true;
+  }
+
+  return false;
+}
+
+}  // namespace package_manager
+}  // namespace mojo
diff --git a/mojo/package_manager/package_manager_impl.h b/mojo/package_manager/package_manager_impl.h
new file mode 100644
index 0000000..56961be4
--- /dev/null
+++ b/mojo/package_manager/package_manager_impl.h
@@ -0,0 +1,76 @@
+// Copyright 2015 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.
+
+#ifndef MOJO_PACKAGE_MANAGER_PACKAGE_MANAGER_IMPL_H_
+#define MOJO_PACKAGE_MANAGER_PACKAGE_MANAGER_IMPL_H_
+
+#include "base/files/file_path.h"
+#include "mojo/fetcher/url_resolver.h"
+#include "mojo/services/network/public/interfaces/network_service.mojom.h"
+#include "mojo/services/network/public/interfaces/url_loader_factory.mojom.h"
+#include "mojo/shell/package_manager.h"
+
+namespace mojo {
+namespace shell {
+class Fetcher;
+}
+namespace package_manager {
+
+// This is the default implementation of shell::PackageManager. It loads
+// http/s urls off the network as well as providing special handling for mojo:
+// and about: urls.
+class PackageManagerImpl : public shell::PackageManager {
+ public:
+  // mojo: urls are only supported if |shell_file_root| is non-empty.
+  explicit PackageManagerImpl(const base::FilePath& shell_file_root);
+  ~PackageManagerImpl() override;
+
+  // Register a content handler to handle content of |mime_type|.
+  void RegisterContentHandler(const std::string& mime_type,
+                              const GURL& content_handler_url);
+
+  // Registers a package alias. When attempting to load |alias|, it will
+  // instead redirect to |content_handler_package|, which is a content handler
+  // which will be passed the |alias| as the URLResponse::url. Different values
+  // of |alias| with the same |qualifier| that are in the same
+  // |content_handler_package| will run in the same process in multi-process
+  // mode.
+  void RegisterApplicationPackageAlias(
+      const GURL& alias,
+      const GURL& content_handler_package,
+      const std::string& qualifier);
+
+ private:
+  using ApplicationPackagedAlias = std::map<GURL, std::pair<GURL, std::string>>;
+  using MimeTypeToURLMap = std::map<std::string, GURL>;
+
+  // Overridden from shell::PackageManager:
+  void SetApplicationManager(shell::ApplicationManager* manager) override;
+  GURL ResolveURL(const GURL& url) override;
+  void FetchRequest(
+      URLRequestPtr request,
+      const shell::Fetcher::FetchCallback& loader_callback) override;
+  bool HandleWithContentHandler(shell::Fetcher* fetcher,
+                                const GURL& unresolved_url,
+                                base::TaskRunner* task_runner,
+                                URLResponsePtr* new_response,
+                                GURL* content_handler_url,
+                                std::string* qualifier) override;
+
+
+  shell::ApplicationManager* application_manager_;
+  scoped_ptr<fetcher::URLResolver> url_resolver_;
+  const bool disable_cache_;
+  NetworkServicePtr network_service_;
+  URLLoaderFactoryPtr url_loader_factory_;
+  ApplicationPackagedAlias application_package_alias_;
+  MimeTypeToURLMap mime_type_to_url_;
+
+  DISALLOW_COPY_AND_ASSIGN(PackageManagerImpl);
+};
+
+}  // namespace package_manager
+}  // namespace mojo
+
+#endif  // MOJO_PACKAGE_MANAGER_PACKAGE_MANAGER_IMPL_H_