Clang format slam.

net/http/http_auth_handler_digest.cc

 // Copyright (c) 2011 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_handler_digest.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/md5.h"
@@ skipping 111 matching lines @@
   // for the new challenge.
   std::string original_realm;
   while (parameters.GetNext()) {
     if (LowerCaseEqualsASCII(parameters.name(), "stale")) {
       if (LowerCaseEqualsASCII(parameters.value(), "true"))
         return HttpAuth::AUTHORIZATION_RESULT_STALE;
     } else if (LowerCaseEqualsASCII(parameters.name(), "realm")) {
       original_realm = parameters.value();
     }
   }
-  return (original_realm_ != original_realm) ?
-      HttpAuth::AUTHORIZATION_RESULT_DIFFERENT_REALM :
-      HttpAuth::AUTHORIZATION_RESULT_REJECT;
+  return (original_realm_ != original_realm)
+             ? HttpAuth::AUTHORIZATION_RESULT_DIFFERENT_REALM
+             : HttpAuth::AUTHORIZATION_RESULT_REJECT;
 }
 
 bool HttpAuthHandlerDigest::Init(HttpAuthChallengeTokenizer* challenge) {
   return ParseChallenge(challenge);
 }
 
 int HttpAuthHandlerDigest::GenerateAuthTokenImpl(
-    const AuthCredentials* credentials, const HttpRequestInfo* request,
-    const CompletionCallback& callback, std::string* auth_token) {
+    const AuthCredentials* credentials,
+    const HttpRequestInfo* request,
+    const CompletionCallback& callback,
+    std::string* auth_token) {
   // Generate a random client nonce.
   std::string cnonce = nonce_generator_->GenerateNonce();
 
   // Extract the request method and path -- the meaning of 'path' is overloaded
   // in certain cases, to be a hostname.
   std::string method;
   std::string path;
   GetRequestMethodAndPath(request, &method, &path);
 
-  *auth_token = AssembleCredentials(method, path, *credentials,
-                                    cnonce, nonce_count_);
+  *auth_token =
+      AssembleCredentials(method, path, *credentials, cnonce, nonce_count_);
   return OK;
 }
 
 HttpAuthHandlerDigest::HttpAuthHandlerDigest(
-    int nonce_count, const NonceGenerator* nonce_generator)
+    int nonce_count,
+    const NonceGenerator* nonce_generator)
     : stale_(false),
       algorithm_(ALGORITHM_UNSPECIFIED),
       qop_(QOP_UNSPECIFIED),
       nonce_count_(nonce_count),
       nonce_generator_(nonce_generator) {
   DCHECK(nonce_generator_);
 }
 
 HttpAuthHandlerDigest::~HttpAuthHandlerDigest() {
 }
@@ skipping 30 matching lines @@
 
   // FAIL -- Couldn't match auth-scheme.
   if (!LowerCaseEqualsASCII(challenge->scheme(), "digest"))
     return false;
 
   HttpUtil::NameValuePairsIterator parameters = challenge->param_pairs();
 
   // Loop through all the properties.
   while (parameters.GetNext()) {
     // FAIL -- couldn't parse a property.
-    if (!ParseChallengeProperty(parameters.name(),
-                                parameters.value()))
+    if (!ParseChallengeProperty(parameters.name(), parameters.value()))
       return false;
   }
 
   // Check if tokenizer failed.
   if (!parameters.valid())
     return false;
 
   // Check that a minimum set of properties were provided.
   if (nonce_.empty())
     return false;
@@ skipping 122 matching lines @@
 std::string HttpAuthHandlerDigest::AssembleCredentials(
     const std::string& method,
     const std::string& path,
     const AuthCredentials& credentials,
     const std::string& cnonce,
     int nonce_count) const {
   // the nonce-count is an 8 digit hex string.
   std::string nc = base::StringPrintf("%08x", nonce_count);
 
   // TODO(eroman): is this the right encoding?
-  std::string authorization = (std::string("Digest username=") +
-                               HttpUtil::Quote(
-                                   base::UTF16ToUTF8(credentials.username())));
+  std::string authorization =
+      (std::string("Digest username=") +
+       HttpUtil::Quote(base::UTF16ToUTF8(credentials.username())));
   authorization += ", realm=" + HttpUtil::Quote(original_realm_);
   authorization += ", nonce=" + HttpUtil::Quote(nonce_);
   authorization += ", uri=" + HttpUtil::Quote(path);
 
   if (algorithm_ != ALGORITHM_UNSPECIFIED) {
     authorization += ", algorithm=" + AlgorithmToString(algorithm_);
   }
-  std::string response = AssembleResponseDigest(method, path, credentials,
-                                                cnonce, nc);
+  std::string response =
+      AssembleResponseDigest(method, path, credentials, cnonce, nc);
   // No need to call HttpUtil::Quote() as the response digest cannot contain
   // any characters needing to be escaped.
   authorization += ", response=\"" + response + "\"";
 
   if (!opaque_.empty()) {
     authorization += ", opaque=" + HttpUtil::Quote(opaque_);
   }
   if (qop_ != QOP_UNSPECIFIED) {
     // TODO(eroman): Supposedly IIS server requires quotes surrounding qop.
     authorization += ", qop=" + QopToString(qop_);
     authorization += ", nc=" + nc;
     authorization += ", cnonce=" + HttpUtil::Quote(cnonce);
   }
 
   return authorization;
 }
 
 }  // namespace net