Remove the net_log member from HttpAuthController.

net/http/http_auth_controller.cc

 // Copyright (c) 2010 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/string_util.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_util.h"
 #include "net/http/http_auth_handler_factory.h"
@@ skipping 32 matching lines @@
   }
 
   return msg;
 }
 
 }  // namespace
 
 HttpAuthController::HttpAuthController(
     HttpAuth::Target target,
     const GURL& auth_url,
-    scoped_refptr<HttpNetworkSession> session,
-    const BoundNetLog& net_log)
+    scoped_refptr<HttpNetworkSession> session)
     : target_(target),
       auth_url_(auth_url),
       auth_origin_(auth_url.GetOrigin()),
       auth_path_(HttpAuth::AUTH_PROXY ? std::string() : auth_url.path()),
       embedded_identity_used_(false),
       default_credentials_used_(false),
-      session_(session),
-      net_log_(net_log) {
+      session_(session) {
 }
 
 HttpAuthController::~HttpAuthController() {}
 
 int HttpAuthController::MaybeGenerateAuthToken(const HttpRequestInfo* request,
-                                               CompletionCallback* callback) {
-  bool needs_auth = HaveAuth() || SelectPreemptiveAuth();
+                                               CompletionCallback* callback,
+                                               const BoundNetLog& net_log) {
+  bool needs_auth = HaveAuth() || SelectPreemptiveAuth(net_log);
   if (!needs_auth)
     return OK;
   const std::wstring* username = NULL;
   const std::wstring* password = NULL;
   if (identity_.source != HttpAuth::IDENT_SRC_DEFAULT_CREDENTIALS) {
     username = &identity_.username;
     password = &identity_.password;
   }
   DCHECK(auth_token_.empty());
   return handler_->GenerateAuthToken(username, password, request, callback,
                                      &auth_token_);
 }
 
-bool HttpAuthController::SelectPreemptiveAuth() {
+bool HttpAuthController::SelectPreemptiveAuth(const BoundNetLog& net_log) {
   DCHECK(!HaveAuth());
   DCHECK(identity_.invalid);
 
   // Don't do preemptive authorization if the URL contains a username/password,
   // since we must first be challenged in order to use the URL's identity.
   if (auth_url_.has_username())
     return false;
 
   // SelectPreemptiveAuth() is on the critical path for each request, so it
   // is expected to be fast. LookupByPath() is fast in the common case, since
   // the number of http auth cache entries is expected to be very small.
   // (For most users in fact, it will be 0.)
   HttpAuthCache::Entry* entry = session_->auth_cache()->LookupByPath(
       auth_origin_, auth_path_);
   if (!entry)
     return false;
 
   // Try to create a handler using the previous auth challenge.
   scoped_ptr<HttpAuthHandler> handler_preemptive;
   int rv_create = session_->http_auth_handler_factory()->
       CreatePreemptiveAuthHandlerFromString(entry->auth_challenge(), target_,
                                             auth_origin_,
                                             entry->IncrementNonceCount(),
-                                            net_log_, &handler_preemptive);
+                                            net_log, &handler_preemptive);
   if (rv_create != OK)
     return false;
 
   // Set the state
   identity_.source = HttpAuth::IDENT_SRC_PATH_LOOKUP;
   identity_.invalid = false;
   identity_.username = entry->username();
   identity_.password = entry->password();
   handler_.swap(handler_preemptive);
   return true;
 }
 
 void HttpAuthController::AddAuthorizationHeader(
     HttpRequestHeaders* authorization_headers) {
   DCHECK(HaveAuth());
   DCHECK(!auth_token_.empty());
   authorization_headers->SetHeader(
       HttpAuth::GetAuthorizationHeaderName(target_), auth_token_);
   auth_token_.clear();
 }
 
 int HttpAuthController::HandleAuthChallenge(
     scoped_refptr<HttpResponseHeaders> headers,
     bool do_not_send_server_auth,
-    bool establishing_tunnel) {
+    bool establishing_tunnel,
+    const BoundNetLog& net_log) {
   DCHECK(headers);
   DCHECK(auth_origin_.is_valid());
 
   LOG(INFO) << "The " << HttpAuth::GetAuthTargetString(target_) << " "
             << auth_origin_ << " requested auth"
             << AuthChallengeLogMessage(headers.get());
 
   // The auth we tried just failed, hence it can't be valid. Remove it from
   // the cache so it won't be used again.
   // TODO(wtc): IsFinalRound is not the right condition.  In a multi-round
   // auth sequence, the server may fail the auth in round 1 if our first
   // authorization header is broken.  We should inspect response_.headers to
   // determine if the server already failed the auth or wants us to continue.
   // See http://crbug.com/21015.
   if (HaveAuth() && handler_->IsFinalRound()) {
     InvalidateRejectedAuthFromCache();
     handler_.reset();
     identity_ = HttpAuth::Identity();
   }
 
   identity_.invalid = true;
 
   if (target_ != HttpAuth::AUTH_SERVER || !do_not_send_server_auth) {
     // Find the best authentication challenge that we support.
     HttpAuth::ChooseBestChallenge(session_->http_auth_handler_factory(),
-                                  headers, target_, auth_origin_, net_log_,
+                                  headers, target_, auth_origin_, net_log,
                                   &handler_);
   }
 
   if (!handler_.get()) {
     if (establishing_tunnel) {
       LOG(ERROR) << "Can't perform auth to the "
                  << HttpAuth::GetAuthTargetString(target_) << " "
                  << auth_origin_ << " when establishing a tunnel"
                  << AuthChallengeLogMessage(headers.get());
 
@@ skipping 143 matching lines @@
 
   auth_info_ = new AuthChallengeInfo;
   auth_info_->is_proxy = target_ == HttpAuth::AUTH_PROXY;
   auth_info_->host_and_port = ASCIIToWide(GetHostAndPort(auth_origin_));
   auth_info_->scheme = ASCIIToWide(handler_->scheme());
   // TODO(eroman): decode realm according to RFC 2047.
   auth_info_->realm = ASCIIToWide(handler_->realm());
 }
 
 }  // namespace net