Change AuthenticatingURLLoader to be a URLLoaderInterceptor

shell/application_manager/application_manager.cc

 // Copyright 2014 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/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 170 matching lines @@
     new LocalFetcher(resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
                      callback);
     return;
   }
 
   if (!url_response_disk_cache_) {
     ConnectToService(GURL("mojo:url_response_disk_cache"),
                      &url_response_disk_cache_);
   }
 
-  if (!url_loader_factory_) {
-    ConnectToService(GURL("mojo:authenticating_url_loader"),
-                     &url_loader_factory_);
+  if (!network_service_) {
+    ConnectToService(GURL("mojo:network_service"), &network_service_);
   }
 
   // NOTE: Attempting to initialize the AuthenticationService while connecting
   // to the AuthenticationService would result in a recursive loop, so it has
   // to be explicitly avoided here. AuthenticatingURLLoaders work fine without
   // the AuthenticationService as long as authentication is not needed, so what
   // this means in practice is that the AuthenticationService cannot itself
   // require authentication to obtain.
   if (!initialized_authentication_service_ &&
       !EndsWith(resolved_url.path(), "/authentication.mojo", true)) {

[qsr, 2015/06/05 10:54:55]

I think we should now be able to not need mojo:authenticating_url_loader to be
bundle with the shell. You can use the network service without an interceptor,
so we should be able to get this.

[blundell, 2015/06/05 13:24:17]

Done.

     authentication::AuthenticationServicePtr authentication_service;
     ConnectToService(GURL("mojo:authentication"), &authentication_service);
-    url_loader_factory_->SetAuthenticationService(
-        authentication_service.Pass());
+    ConnectToService(GURL("mojo:authenticating_url_loader"),
+                     &url_loader_factory_);
+    mojo::URLLoaderInterceptorFactoryPtr interceptor_factory;
+    url_loader_factory_->CreateURLLoaderInterceptorFactory(
+        GetProxy(&interceptor_factory), authentication_service.Pass());
+    network_service_->RegisterURLLoaderInterceptor(interceptor_factory.Pass());
     initialized_authentication_service_ = true;
   }
 
   new NetworkFetcher(options_.disable_cache, options_.predictable_app_filenames,
                      resolved_url, url_response_disk_cache_.get(),
-                     url_loader_factory_.get(), callback);
+                     network_service_.get(), callback);
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services) {
   GURL application_url = GetBaseURLAndQuery(resolved_url, nullptr);
   ShellImpl* shell_impl = GetShellImpl(application_url);
   if (!shell_impl)
@@ skipping 276 matching lines @@
     return args_it->second;
   return std::vector<std::string>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell