Move fetchers into mojo/shell/fetcher

mojo/shell/package_manager/package_manager_impl.cc

 // 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/shell/package_manager/package_manager_impl.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "mojo/application/public/interfaces/content_handler.mojom.h"
-#include "mojo/fetcher/about_fetcher.h"
-#include "mojo/fetcher/data_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/connect_util.h"
+#include "mojo/shell/fetcher/about_fetcher.h"
+#include "mojo/shell/fetcher/data_fetcher.h"
+#include "mojo/shell/fetcher/local_fetcher.h"
+#include "mojo/shell/fetcher/network_fetcher.h"
+#include "mojo/shell/fetcher/switches.h"
 #include "mojo/shell/package_manager/content_handler_connection.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 shell {
 
 PackageManagerImpl::PackageManagerImpl(
     const base::FilePath& shell_file_root,
     base::TaskRunner* task_runner)
     : application_manager_(nullptr),
       disable_cache_(base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableCache)),
       content_handler_id_counter_(0u),
       task_runner_(task_runner),
       shell_file_root_(shell_file_root) {
   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));
+    url_resolver_.reset(new URLResolver(mojo_root_file_url));
   }
 }
 
 PackageManagerImpl::~PackageManagerImpl() {
   IdentityToContentHandlerMap identity_to_content_handler(
       identity_to_content_handler_);
   for (auto& pair : identity_to_content_handler)
     pair.second->CloseConnection();
 }
 
@@ skipping 14 matching lines @@
 }
 
 void PackageManagerImpl::SetApplicationManager(ApplicationManager* manager) {
   application_manager_ = manager;
 }
 
 void PackageManagerImpl::FetchRequest(
     URLRequestPtr request,
     const Fetcher::FetchCallback& loader_callback) {
   GURL url(request->url);
-  if (url.SchemeIs(fetcher::AboutFetcher::kAboutScheme)) {
-    fetcher::AboutFetcher::Start(url, loader_callback);
+  if (url.SchemeIs(AboutFetcher::kAboutScheme)) {
+    AboutFetcher::Start(url, loader_callback);
     return;
   }
 
   if (url.SchemeIs(url::kDataScheme)) {
-    fetcher::DataFetcher::Start(url, loader_callback);
+    DataFetcher::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") && !url.SchemeIs("exe")) {
       ConnectToService(application_manager_, 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,
-        GetBaseURLAndQuery(resolved_url, nullptr),
-        shell_file_root_, loader_callback);
+    new LocalFetcher(network_service_.get(), resolved_url,
+                     GetBaseURLAndQuery(resolved_url, nullptr),
+                     shell_file_root_, loader_callback);
     return;
   }
 
   if (!url_loader_factory_) {
     ConnectToService(application_manager_, 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_, std::move(request),
-                              url_loader_factory_.get(), loader_callback);
+  new NetworkFetcher(disable_cache_, std::move(request),
+                     url_loader_factory_.get(), loader_callback);
 }
 
 uint32_t PackageManagerImpl::HandleWithContentHandler(
     Fetcher* fetcher,
     const Identity& source,
     const GURL& target_url,
     const CapabilityFilter& target_filter,
     InterfaceRequest<Application>* application_request) {
   Identity content_handler_identity;
   URLResponsePtr response;
@@ skipping 97 matching lines @@
 void PackageManagerImpl::OnContentHandlerConnectionClosed(
     ContentHandlerConnection* connection) {
   // Remove the mapping.
   auto it = identity_to_content_handler_.find(connection->identity());
   DCHECK(it != identity_to_content_handler_.end());
   identity_to_content_handler_.erase(it);
 }
 
 }  // namespace shell
 }  // namespace mojo