Remove round trip from data reduction proxy authentication

net/http/http_auth_controller.cc

 // Copyright (c) 2012 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 "net/http/http_auth_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/histogram.h"
+#if defined(SPDY_PROXY_AUTH_ORIGIN) && defined(SPDY_PROXY_AUTH_VALUE)
+#include "base/stringprintf.h"
+#endif
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
 #include "net/base/net_util.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_headers.h"
@@ skipping 147 matching lines @@
 }
 
 HttpAuthController::~HttpAuthController() {
   DCHECK(CalledOnValidThread());
 }
 
 int HttpAuthController::MaybeGenerateAuthToken(
     const HttpRequestInfo* request, const CompletionCallback& callback,
     const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
+
+#if defined(SPDY_PROXY_AUTH_ORIGIN) && defined(SPDY_PROXY_AUTH_VALUE)
+  if (target_ == HttpAuth::AUTH_PROXY) {
+    HttpAuthCache::Entry* entry =
+        http_auth_cache_->LookupByPath(auth_origin_, auth_path_);
+    if (entry) {
+      identity_.source = HttpAuth::IDENT_SRC_REALM_LOOKUP;
+      identity_.invalid = false;
+      identity_.credentials = entry->credentials();
+      if (!handler_.get()) {
+        std::string raw_response_headers = base::StringPrintf(
+            "HTTP/1.1 407 Internal Server Error\r\n"
+            "Proxy-Authenticate: SpdyProxy realm=\"%s\", ps=\"%s\"\r\n\r\n",
+            entry->realm().data(), entry->auth_challenge().data());
+        HttpAuth::ChooseBestChallenge(
+            http_auth_handler_factory_,
+            new HttpResponseHeaders(HttpUtil::AssembleRawHeaders(
+                raw_response_headers.data(), raw_response_headers.length())),
+            target_, auth_origin_, disabled_schemes_, net_log, &handler_);
+      }
+    }
+  }
+#endif
+
   bool needs_auth = HaveAuth() || SelectPreemptiveAuth(net_log);
   if (!needs_auth)
     return OK;
   const AuthCredentials* credentials = NULL;
   if (identity_.source != HttpAuth::IDENT_SRC_DEFAULT_CREDENTIALS)
     credentials = &identity_.credentials;
   DCHECK(auth_token_.empty());
   DCHECK(callback_.is_null());
   int rv = handler_->GenerateAuthToken(
       credentials, request,
@@ skipping 370 matching lines @@
   DCHECK(CalledOnValidThread());
   return disabled_schemes_.find(scheme) != disabled_schemes_.end();
 }
 
 void HttpAuthController::DisableAuthScheme(HttpAuth::Scheme scheme) {
   DCHECK(CalledOnValidThread());
   disabled_schemes_.insert(scheme);
 }
 
 }  // namespace net