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"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
+#include "mojo/services/authenticating_url_loader/public/interfaces/authenticating_url_loader_factory.mojom.h"
 #include "mojo/services/authentication/public/interfaces/authentication.mojom.h"
 #include "mojo/services/content_handler/public/interfaces/content_handler.mojom.h"
 #include "shell/application_manager/fetcher.h"
 #include "shell/application_manager/local_fetcher.h"
 #include "shell/application_manager/network_fetcher.h"
 #include "shell/application_manager/query_util.h"
 #include "shell/application_manager/shell_impl.h"
 
 using mojo::Application;
 using mojo::ApplicationPtr;
@@ skipping 68 matching lines @@
 bool ApplicationManager::TestAPI::HasFactoryForURL(const GURL& url) const {
   return manager_->identity_to_shell_impl_.find(Identity(url)) !=
          manager_->identity_to_shell_impl_.end();
 }
 
 ApplicationManager::ApplicationManager(const Options& options,
                                        Delegate* delegate)
     : options_(options),
       delegate_(delegate),
       blocking_pool_(nullptr),
-      initialized_authentication_service_(false),
+      initialized_authentication_interceptor_(false),
       weak_ptr_factory_(this) {
 }
 
 ApplicationManager::~ApplicationManager() {
 }
 
 void ApplicationManager::TerminateShellConnections() {
   identity_to_shell_impl_.clear();
 }
 
@@ skipping 67 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)) {
+  // NOTE: Attempting to initialize the apps used authentication for while
+  // connecting to those apps would result in a recursive loop, so it has to be
+  // explicitly avoided here. What this means in practice is that these apps
+  // cannot themselves require authentication to obtain.
+  if (!initialized_authentication_interceptor_ &&
+      !EndsWith(resolved_url.path(), "/authentication.mojo", true) &&
+      !EndsWith(resolved_url.path(), "/authenticating_url_loader.mojo", true)) {
     authentication::AuthenticationServicePtr authentication_service;
     ConnectToService(GURL("mojo:authentication"), &authentication_service);
-    url_loader_factory_->SetAuthenticationService(
-        authentication_service.Pass());
-    initialized_authentication_service_ = true;
+    mojo::AuthenticatingURLLoaderFactoryPtr url_loader_factory;
+    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_interceptor_ = 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