Have the authenticating_url_loader cache token per-origin.

services/authenticating_url_loader/authenticating_url_loader_impl.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 "services/authenticating_url_loader/authenticating_url_loader_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 
 namespace mojo {
 
 AuthenticatingURLLoaderImpl::AuthenticatingURLLoaderImpl(
     InterfaceRequest<AuthenticatingURLLoader> request,
     authentication::AuthenticationService* authentication_service,
     NetworkService* network_service,
+    std::map<GURL, std::string>* cached_tokens,
     const Callback<void(AuthenticatingURLLoaderImpl*)>&
         connection_error_callback)
     : binding_(this, request.Pass()),
       authentication_service_(authentication_service),
       network_service_(network_service),
       connection_error_callback_(connection_error_callback),
-      request_authorization_state_(REQUEST_NOT_AUTHORIZED) {
+      request_authorization_state_(REQUEST_NOT_AUTHORIZED),
+      cached_tokens_(cached_tokens) {
   binding_.set_error_handler(this);
 }
 
 AuthenticatingURLLoaderImpl::~AuthenticatingURLLoaderImpl() {
 }
 
 void AuthenticatingURLLoaderImpl::Start(
     URLRequestPtr request,
     const Callback<void(URLResponsePtr)>& callback) {
   // TODO(blundell): If we need to handle requests with bodies, we'll need to
   // do something here.
   if (request->body) {
     LOG(ERROR)
         << "Cannot pass a request to AuthenticatingURLLoader that has a body";
     callback.Run(nullptr);
     return;
   }
-  url_ = request->url;
+  url_ = GURL(request->url);
   auto_follow_redirects_ = request->auto_follow_redirects;
   bypass_cache_ = request->bypass_cache;
   headers_ = request->headers.Clone();
   pending_start_callback_ = callback;
+  GURL url(request->url);

[blundell, 2015/05/27 15:43:44]

nit: unneeded, just use |url_|.

[qsr, 2015/05/27 16:02:26]

Missed one. Thanks.

+  if (cached_tokens_->find(url_.GetOrigin()) != cached_tokens_->end()) {
+    request->headers.push_back("Authorization: Bearer " +
+                               (*cached_tokens_)[url.GetOrigin()]);
+  }
   StartNetworkRequest(request.Pass());
 }
 
 void AuthenticatingURLLoaderImpl::StartNetworkRequest(URLRequestPtr request) {
   network_service_->CreateURLLoader(mojo::GetProxy(&url_loader_));
   url_loader_->Start(request.Pass(),
                      base::Bind(&AuthenticatingURLLoaderImpl::OnLoadComplete,
                                 base::Unretained(this)));
 }
 
@@ skipping 54 matching lines @@
 
 void AuthenticatingURLLoaderImpl::OnOAuth2TokenReceived(String token,
                                                         String error) {
   if (error) {
     LOG(ERROR) << "Error (" << error << ") while getting token";
     pending_start_callback_.Run(pending_response_.Pass());
     return;
   }
 
   DCHECK(token);
+  (*cached_tokens_)[url_.GetOrigin()] = token;
   token_ = token;
   mojo::Array<mojo::String> headers(0);
   if (headers_)
     headers = headers_.Clone();
   headers.push_back("Authorization: Bearer " + token.get());
 
   URLRequestPtr request(mojo::URLRequest::New());
-  request->url = url_;
+  request->url = url_.spec();
   request->auto_follow_redirects = auto_follow_redirects_;
   request->bypass_cache = bypass_cache_;
   request->headers = headers.Pass();
 
   StartNetworkRequest(request.Pass());
 }
 
 void AuthenticatingURLLoaderImpl::SetAuthenticationService(
     authentication::AuthenticationService* authentication_service) {
   authentication_service_ = authentication_service;
   if (authentication_service || !pending_response_)
     return;
 
   // We need authentication but have no AuthenticationService.
   DCHECK(!pending_start_callback_.is_null());
   pending_start_callback_.Run(pending_response_.Pass());
 }
 
 }  // namespace mojo