Change AuthenticatingURLLoader to be a URLLoaderInterceptor

shell/application_manager/network_fetcher.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 "shell/application_manager/network_fetcher.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 21 matching lines @@
 #else
 #error "Unsupported."
 #endif
 };
 
 NetworkFetcher::NetworkFetcher(
     bool disable_cache,
     bool predictable_app_filenames,
     const GURL& url,
     mojo::URLResponseDiskCache* url_response_disk_cache,
-    mojo::AuthenticatingURLLoaderFactory* url_loader_factory,
+    mojo::NetworkService* network_service,
     const FetchCallback& loader_callback)
     : Fetcher(loader_callback),
       disable_cache_(disable_cache),
       predictable_app_filenames_(predictable_app_filenames),
       url_(url),
       url_response_disk_cache_(url_response_disk_cache),
       weak_ptr_factory_(this) {
-  StartNetworkRequest(url, url_loader_factory);
+  StartNetworkRequest(url, network_service);
 }
 
 NetworkFetcher::~NetworkFetcher() {
 }
 
 const GURL& NetworkFetcher::GetURL() const {
   return url_;
 }
 
 GURL NetworkFetcher::GetRedirectURL() const {
@@ skipping 149 matching lines @@
          magic == kMojoMagic;
 }
 
 bool NetworkFetcher::PeekFirstLine(std::string* line) {
   return BlockingPeekLine(response_->body.get(), line, kMaxShebangLength,
                           kPeekTimeout);
 }
 
 void NetworkFetcher::StartNetworkRequest(
     const GURL& url,
-    mojo::AuthenticatingURLLoaderFactory* url_loader_factory) {
+    mojo::NetworkService* network_service) {
   TRACE_EVENT_ASYNC_BEGIN1("mojo_shell", "NetworkFetcher::NetworkRequest", this,
                            "url", url.spec());
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   request->auto_follow_redirects = false;
   request->bypass_cache = disable_cache_;
   auto header = mojo::HttpHeader::New();
   header->name = "X-Architecture";
   header->value = kArchitecture;
   mojo::Array<mojo::HttpHeaderPtr> headers;
   headers.push_back(header.Pass());
   request->headers = headers.Pass();
 
-  url_loader_factory->CreateAuthenticatingURLLoader(GetProxy(&url_loader_));
+  network_service->CreateURLLoader(GetProxy(&url_loader_));
   url_loader_->Start(request.Pass(),
                      base::Bind(&NetworkFetcher::OnLoadComplete,
                                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkFetcher::OnLoadComplete(mojo::URLResponsePtr response) {
   TRACE_EVENT_ASYNC_END0("mojo_shell", "NetworkFetcher::NetworkRequest", this);
   scoped_ptr<Fetcher> owner(this);
   if (response->error) {
     LOG(ERROR) << "Error (" << response->error->code << ": "
                << response->error->description << ") while fetching "
                << response->url;
     loader_callback_.Run(nullptr);
     return;
   }
 
   if (response->status_code >= 400 && response->status_code < 600) {
     LOG(ERROR) << "Error (" << response->status_code << ": "
                << response->status_line << "): "
                << "while fetching " << response->url;
     loader_callback_.Run(nullptr);
     return;
   }
 
   response_ = response.Pass();
   loader_callback_.Run(owner.Pass());
 }
 
 }  // namespace shell