Change AuthenticatingURLLoader to be a URLLoaderInterceptor

services/authenticating_url_loader/authenticating_url_loader_factory_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 "services/authenticating_url_loader/authenticating_url_loader_factory_impl.h"
 
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/stl_util.h"
 #include "mojo/public/cpp/application/application_impl.h"
-#include "mojo/services/authenticating_url_loader/public/interfaces/authenticating_url_loader.mojom.h"
-#include "services/authenticating_url_loader/authenticating_url_loader_impl.h"
+#include "services/authenticating_url_loader/authenticating_url_loader_interceptor_factory.h"
 
 namespace mojo {
 
 AuthenticatingURLLoaderFactoryImpl::AuthenticatingURLLoaderFactoryImpl(
     mojo::InterfaceRequest<AuthenticatingURLLoaderFactory> request,
     mojo::ApplicationImpl* app,
     std::map<GURL, std::string>* cached_tokens)
     : binding_(this, request.Pass()), app_(app), cached_tokens_(cached_tokens) {
-  app_->ConnectToService("mojo:network_service", &network_service_);
 }
 
 AuthenticatingURLLoaderFactoryImpl::~AuthenticatingURLLoaderFactoryImpl() {
 }
 
-std::string AuthenticatingURLLoaderFactoryImpl::GetCachedToken(
-    const GURL& url) {
-  GURL origin = url.GetOrigin();
-  if (cached_tokens_->find(origin) != cached_tokens_->end()) {
-    return (*cached_tokens_)[origin];
-  }
-  return "";
-}
-
-void AuthenticatingURLLoaderFactoryImpl::RetrieveToken(
-    const GURL& url,
-    const base::Callback<void(std::string)>& callback) {
-  if (!authentication_service_) {
-    callback.Run("");
-    return;
-  }
-  GURL origin = url.GetOrigin();
-  if (pendings_retrieve_token_.find(origin) == pendings_retrieve_token_.end()) {
-    if (cached_tokens_->find(origin) != cached_tokens_->end()) {
-      // Clear the cached token in case the request is due to that token being
-      // stale.
-      authentication_service_->ClearOAuth2Token((*cached_tokens_)[origin]);
-      cached_tokens_->erase(origin);
-    }
-    if (cached_accounts_.find(origin) != cached_accounts_.end()) {
-      OnAccountSelected(origin, cached_accounts_[origin], mojo::String());
-      return;
-    }
-    authentication_service_->SelectAccount(
-        true, base::Bind(&AuthenticatingURLLoaderFactoryImpl::OnAccountSelected,
-                         base::Unretained(this), origin));
-  }
-  pendings_retrieve_token_[origin].push_back(callback);
-}
-
-void AuthenticatingURLLoaderFactoryImpl::OnURLLoaderError(
-    AuthenticatingURLLoaderImpl* url_loader) {
-  auto it = std::find_if(
-      url_loaders_.begin(), url_loaders_.end(),
-      [url_loader](const std::unique_ptr<AuthenticatingURLLoaderImpl>& p) {
-        return p.get() == url_loader;
-      });
-  DCHECK(it != url_loaders_.end());
-  url_loaders_.erase(it);
-}
-
-void AuthenticatingURLLoaderFactoryImpl::CreateAuthenticatingURLLoader(
-    mojo::InterfaceRequest<AuthenticatingURLLoader> loader_request) {
-  url_loaders_.push_back(std::unique_ptr<AuthenticatingURLLoaderImpl>(
-      new AuthenticatingURLLoaderImpl(loader_request.Pass(), this)));
-}
-
-void AuthenticatingURLLoaderFactoryImpl::SetAuthenticationService(
+void AuthenticatingURLLoaderFactoryImpl::CreateURLLoaderInterceptorFactory(
+    mojo::InterfaceRequest<URLLoaderInterceptorFactory> factory_request,
     authentication::AuthenticationServicePtr authentication_service) {
-  // If the authentication service changes, all pending request needs to fail.
-  for (const auto& callbacks : pendings_retrieve_token_) {
-    for (const auto& callback : callbacks.second) {
-      callback.Run("");
-    }
-  }
-  pendings_retrieve_token_.clear();
-  authentication_service_ = authentication_service.Pass();
-  if (authentication_service_)
-    authentication_service_.set_error_handler(this);
-}
-
-void AuthenticatingURLLoaderFactoryImpl::OnConnectionError() {
-  SetAuthenticationService(nullptr);
-}
-
-void AuthenticatingURLLoaderFactoryImpl::OnAccountSelected(const GURL& origin,
-                                                           mojo::String account,
-                                                           mojo::String error) {
-  DCHECK(authentication_service_);
-  if (error) {
-    LOG(WARNING) << "Error (" << error << ") while selecting account";
-    ExecuteCallbacks(origin, "");
-    return;
-  }
-  cached_accounts_[origin] = account;
-  mojo::Array<mojo::String> scopes(1);
-  scopes[0] = "https://www.googleapis.com/auth/userinfo.email";
-  authentication_service_->GetOAuth2Token(
-      account, scopes.Pass(),
-      base::Bind(&AuthenticatingURLLoaderFactoryImpl::OnOAuth2TokenReceived,
-                 base::Unretained(this), origin));
-}
-
-void AuthenticatingURLLoaderFactoryImpl::OnOAuth2TokenReceived(
-    const GURL& origin,
-    mojo::String token,
-    mojo::String error) {
-  if (error) {
-    LOG(WARNING) << "Error (" << error << ") while getting token";
-    ExecuteCallbacks(origin, "");
-    return;
-  }
-  std::string string_token(token);
-  (*cached_tokens_)[origin] = string_token;
-  ExecuteCallbacks(origin, string_token);
-}
-
-void AuthenticatingURLLoaderFactoryImpl::ExecuteCallbacks(
-    const GURL& origin,
-    const std::string& result) {
-  for (auto& callback : pendings_retrieve_token_[origin]) {
-    callback.Run(result);
-  }
-  pendings_retrieve_token_.erase(origin);
+  new AuthenticatingURLLoaderInterceptorFactory(factory_request.Pass(),
+                                                authentication_service.Pass(),
+                                                app_, cached_tokens_);
 }
 
 }  // namespace mojo