Clang format slam.

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"
 #include "base/strings/string_util.h"
@@ skipping 98 matching lines @@
   //   Digest Start: 2
   //   Digest Reject: 3
   //   NTLM Start: 4
   //   NTLM Reject: 5
   //   Negotiate Start: 6
   //   Negotiate Reject: 7
   static const int kEventBucketsEnd =
       HttpAuth::AUTH_SCHEME_MAX * AUTH_EVENT_MAX;
   int event_bucket = auth_scheme * AUTH_EVENT_MAX + auth_event;
   DCHECK(event_bucket >= 0 && event_bucket < kEventBucketsEnd);
-  UMA_HISTOGRAM_ENUMERATION("Net.HttpAuthCount", event_bucket,
-                            kEventBucketsEnd);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.HttpAuthCount", event_bucket, kEventBucketsEnd);
 
   // Record the target of the authentication.
   //
   // The results map to:
   //   Basic Proxy: 0
   //   Basic Secure Proxy: 1
   //   Basic Server: 2
   //   Basic Secure Server: 3
   //   Digest Proxy: 4
   //   Digest Secure Proxy: 5
   //   Digest Server: 6
   //   Digest Secure Server: 7
   //   NTLM Proxy: 8
   //   NTLM Secure Proxy: 9
   //   NTLM Server: 10
   //   NTLM Secure Server: 11
   //   Negotiate Proxy: 12
   //   Negotiate Secure Proxy: 13
   //   Negotiate Server: 14
   //   Negotiate Secure Server: 15
   if (auth_event != AUTH_EVENT_START)
     return;
   static const int kTargetBucketsEnd =
       HttpAuth::AUTH_SCHEME_MAX * AUTH_TARGET_MAX;
   AuthTarget auth_target = DetermineAuthTarget(handler);
   int target_bucket = auth_scheme * AUTH_TARGET_MAX + auth_target;
   DCHECK(target_bucket >= 0 && target_bucket < kTargetBucketsEnd);
-  UMA_HISTOGRAM_ENUMERATION("Net.HttpAuthTarget", target_bucket,
-                            kTargetBucketsEnd);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.HttpAuthTarget", target_bucket, kTargetBucketsEnd);
 }
 
 }  // namespace
 
 HttpAuthController::HttpAuthController(
     HttpAuth::Target target,
     const GURL& auth_url,
     HttpAuthCache* http_auth_cache,
     HttpAuthHandlerFactory* http_auth_handler_factory)
     : 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),
       http_auth_cache_(http_auth_cache),
       http_auth_handler_factory_(http_auth_handler_factory) {
 }
 
 HttpAuthController::~HttpAuthController() {
   DCHECK(CalledOnValidThread());
 }
 
 int HttpAuthController::MaybeGenerateAuthToken(
-    const HttpRequestInfo* request, const CompletionCallback& callback,
+    const HttpRequestInfo* request,
+    const CompletionCallback& callback,
     const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   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,
+      credentials,
+      request,
       base::Bind(&HttpAuthController::OnIOComplete, base::Unretained(this)),
       &auth_token_);
   if (DisableOnAuthHandlerResult(rv))
     rv = OK;
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   else
     OnIOComplete(rv);
   return rv;
 }
 
 bool HttpAuthController::SelectPreemptiveAuth(const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   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 = http_auth_cache_->LookupByPath(
-      auth_origin_, auth_path_);
+  HttpAuthCache::Entry* entry =
+      http_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 = http_auth_handler_factory_->
-      CreatePreemptiveAuthHandlerFromString(entry->auth_challenge(), target_,
-                                            auth_origin_,
-                                            entry->IncrementNonceCount(),
-                                            net_log, &handler_preemptive);
+  int rv_create =
+      http_auth_handler_factory_->CreatePreemptiveAuthHandlerFromString(
+          entry->auth_challenge(),
+          target_,
+          auth_origin_,
+          entry->IncrementNonceCount(),
+          net_log,
+          &handler_preemptive);
   if (rv_create != OK)
     return false;
 
   // Set the state
   identity_.source = HttpAuth::IDENT_SRC_PATH_LOOKUP;
   identity_.invalid = false;
   identity_.credentials = entry->credentials();
   handler_.swap(handler_preemptive);
   return true;
 }
@@ skipping 58 matching lines @@
           InvalidateCurrentHandler(INVALIDATE_HANDLER_AND_CACHED_CREDENTIALS);
         }
         break;
       case HttpAuth::AUTHORIZATION_RESULT_DIFFERENT_REALM:
         // If the server changes the authentication realm in a
         // subsequent challenge, invalidate cached credentials for the
         // previous realm.  If the server rejects a preemptive
         // authorization and requests credentials for a different
         // realm, we keep the cached credentials.
         InvalidateCurrentHandler(
-            (identity_.source == HttpAuth::IDENT_SRC_PATH_LOOKUP) ?
-            INVALIDATE_HANDLER :
-            INVALIDATE_HANDLER_AND_CACHED_CREDENTIALS);
+            (identity_.source == HttpAuth::IDENT_SRC_PATH_LOOKUP)
+                ? INVALIDATE_HANDLER
+                : INVALIDATE_HANDLER_AND_CACHED_CREDENTIALS);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   identity_.invalid = true;
 
-  bool can_send_auth = (target_ != HttpAuth::AUTH_SERVER ||
-                        !do_not_send_server_auth);
+  bool can_send_auth =
+      (target_ != HttpAuth::AUTH_SERVER || !do_not_send_server_auth);
 
   do {
     if (!handler_.get() && can_send_auth) {
       // Find the best authentication challenge that we support.
       HttpAuth::ChooseBestChallenge(http_auth_handler_factory_,
                                     headers.get(),
                                     target_,
                                     auth_origin_,
                                     disabled_schemes_,
                                     net_log,
@@ skipping 44 matching lines @@
       }
     } else {
       auth_info_ = NULL;
     }
 
     // If we get here and we don't have a handler_, that's because we
     // invalidated it due to not having any viable identities to use with it. Go
     // back and try again.
     // TODO(asanka): Instead we should create a priority list of
     //     <handler,identity> and iterate through that.
-  } while(!handler_.get());
+  } while (!handler_.get());
   return OK;
 }
 
 void HttpAuthController::ResetAuth(const AuthCredentials& credentials) {
   DCHECK(CalledOnValidThread());
   DCHECK(identity_.invalid || credentials.Empty());
 
   if (identity_.invalid) {
     // Update the credentials.
     identity_.source = HttpAuth::IDENT_SRC_EXTERNAL;
@@ skipping 15 matching lines @@
   //
   // TODO(wtc): For NTLM_SSPI, we add the same auth entry to the cache in
   // round 1 and round 2, which is redundant but correct.  It would be nice
   // to add an auth entry to the cache only once, preferrably in round 1.
   // See http://crbug.com/21015.
   switch (identity_.source) {
     case HttpAuth::IDENT_SRC_NONE:
     case HttpAuth::IDENT_SRC_DEFAULT_CREDENTIALS:
       break;
     default:
-      http_auth_cache_->Add(auth_origin_, handler_->realm(),
-                            handler_->auth_scheme(), handler_->challenge(),
-                            identity_.credentials, auth_path_);
+      http_auth_cache_->Add(auth_origin_,
+                            handler_->realm(),
+                            handler_->auth_scheme(),
+                            handler_->challenge(),
+                            identity_.credentials,
+                            auth_path_);
       break;
   }
 }
 
 bool HttpAuthController::HaveAuthHandler() const {
   return handler_.get() != NULL;
 }
 
 bool HttpAuthController::HaveAuth() const {
   return handler_.get() && !identity_.invalid;
@@ skipping 12 matching lines @@
   identity_ = HttpAuth::Identity();
 }
 
 void HttpAuthController::InvalidateRejectedAuthFromCache() {
   DCHECK(CalledOnValidThread());
   DCHECK(HaveAuth());
 
   // Clear the cache entry for the identity we just failed on.
   // Note: we require the credentials to match before invalidating
   // since the entry in the cache may be newer than what we used last time.
-  http_auth_cache_->Remove(auth_origin_, handler_->realm(),
-                           handler_->auth_scheme(), identity_.credentials);
+  http_auth_cache_->Remove(auth_origin_,
+                           handler_->realm(),
+                           handler_->auth_scheme(),
+                           identity_.credentials);
 }
 
 bool HttpAuthController::SelectNextAuthIdentityToTry() {
   DCHECK(CalledOnValidThread());
   DCHECK(handler_.get());
   DCHECK(identity_.invalid);
 
   // Try to use the username:password encoded into the URL first.
   if (target_ == HttpAuth::AUTH_SERVER && auth_url_.has_username() &&
       !embedded_identity_used_) {
     identity_.source = HttpAuth::IDENT_SRC_URL;
     identity_.invalid = false;
     // Extract the username:password from the URL.
     base::string16 username;
     base::string16 password;
     GetIdentityFromURL(auth_url_, &username, &password);
     identity_.credentials.Set(username, password);
     embedded_identity_used_ = true;
     // TODO(eroman): If the password is blank, should we also try combining
     // with a password from the cache?
     UMA_HISTOGRAM_BOOLEAN("net.HttpIdentSrcURL", true);
     return true;
   }
 
   // Check the auth cache for a realm entry.
-  HttpAuthCache::Entry* entry =
-      http_auth_cache_->Lookup(auth_origin_, handler_->realm(),
-                               handler_->auth_scheme());
+  HttpAuthCache::Entry* entry = http_auth_cache_->Lookup(
+      auth_origin_, handler_->realm(), handler_->auth_scheme());
 
   if (entry) {
     identity_.source = HttpAuth::IDENT_SRC_REALM_LOOKUP;
     identity_.invalid = false;
     identity_.credentials = entry->credentials();
     return true;
   }
 
   // Use default credentials (single sign on) if this is the first attempt
   // at identity.  Do not allow multiple times as it will infinite loop.
@@ skipping 78 matching lines @@
   DCHECK(CalledOnValidThread());
   disabled_schemes_.insert(scheme);
 }
 
 void HttpAuthController::DisableEmbeddedIdentity() {
   DCHECK(CalledOnValidThread());
   embedded_identity_used_ = true;
 }
 
 }  // namespace net