Fixes CRLF and trailing white spaces.

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@10982 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 22 insertions, 22 deletions

diff --git a/net/http/http_auth.h b/net/http/http_auth.h
index 7442898..041581e 100644
--- a/net/http/http_auth.h
+++ b/net/http/http_auth.h
@@ -17,7 +17,7 @@ class HttpResponseHeaders;
 class HttpAuth {
  public:
 
-   // Http authentication can be done the the proxy server, origin server, 
+   // Http authentication can be done the the proxy server, origin server,
    // or both. This enum tracks who the target is.
    enum Target {
      AUTH_PROXY = 0,
@@ -46,7 +46,7 @@ class HttpAuth {
      IDENT_SRC_EXTERNAL,
    };
 
-   // Helper structure used by HttpNetworkTransaction to track 
+   // Helper structure used by HttpNetworkTransaction to track
    // the current identity being used for authorization.
    struct Identity {
      Identity() : source(IDENT_SRC_NONE), invalid(true) { }
@@ -108,7 +108,7 @@ class HttpAuth {
     std::string scheme() const {
       return std::string(scheme_begin_, scheme_end_);
     }
-    
+
     // Returns false if there was a parse error.
     bool valid() const {
       return valid_;
@@ -134,7 +134,7 @@ class HttpAuth {
 
     // If value() has quotemarks, unquote it.
     std::string unquoted_value() const;
-    
+
     // True if the name-value pair's value has quote marks.
     bool value_is_quoted() const { return value_is_quoted_; }
 
diff --git a/net/http/http_auth_cache.cc b/net/http/http_auth_cache.cc
index 39db6418..3076a89 100644
--- a/net/http/http_auth_cache.cc
+++ b/net/http/http_auth_cache.cc
@@ -104,7 +104,7 @@ HttpAuthCache::Entry* HttpAuthCache::Add(const GURL& origin,
 
   // Check for existing entry (we will re-use it if present).
   HttpAuthCache::Entry* entry = LookupByRealm(origin, handler->realm());
-  
+
   if (!entry) {
     // Failsafe to prevent unbounded memory growth of the cache.
     if (entries_.size() >= kMaxNumRealmEntries) {
diff --git a/net/http/http_auth_handler_basic.h b/net/http/http_auth_handler_basic.h
index 2db2fcb..1424c8f 100644
--- a/net/http/http_auth_handler_basic.h
+++ b/net/http/http_auth_handler_basic.h
@@ -18,7 +18,7 @@ class HttpAuthHandlerBasic : public HttpAuthHandler {
                                           const ProxyInfo*);
  protected:
   virtual bool Init(std::string::const_iterator challenge_begin,
-                    std::string::const_iterator challenge_end); 
+                    std::string::const_iterator challenge_end);
 
 };
 
diff --git a/net/http/http_auth_handler_digest_unittest.cc b/net/http/http_auth_handler_digest_unittest.cc
index bb21d8b..c4abe26 100644
--- a/net/http/http_auth_handler_digest_unittest.cc
+++ b/net/http/http_auth_handler_digest_unittest.cc
@@ -35,7 +35,7 @@ TEST(HttpAuthHandlerDigestTest, ParseChallenge) {
       HttpAuthHandlerDigest::ALGORITHM_UNSPECIFIED,
       HttpAuthHandlerDigest::QOP_UNSPECIFIED
     },
-    
+
     {// Check that when algorithm has an unsupported value, parsing fails.
       "Digest nonce=\"xyz\", algorithm=\"awezum\", realm=\"Thunder\"",
       false,
@@ -92,7 +92,7 @@ TEST(HttpAuthHandlerDigestTest, ParseChallenge) {
 
     scoped_refptr<HttpAuthHandlerDigest> digest = new HttpAuthHandlerDigest;
     bool ok = digest->ParseChallenge(challenge.begin(), challenge.end());
-    
+
     EXPECT_EQ(tests[i].parsed_success, ok);
     EXPECT_STREQ(tests[i].parsed_realm, digest->realm_.c_str());
     EXPECT_STREQ(tests[i].parsed_nonce, digest->nonce_.c_str());
@@ -244,7 +244,7 @@ TEST(HttpAuthHandlerDigestTest, AssembleCredentials) {
     std::string creds = digest->AssembleCredentials(tests[i].req_method,
         tests[i].req_path, tests[i].username, tests[i].password,
         tests[i].cnonce, tests[i].nonce_count);
-    
+
     EXPECT_STREQ(tests[i].expected_creds, creds.c_str());
   }
 }
diff --git a/net/http/http_chunked_decoder.cc b/net/http/http_chunked_decoder.cc
index 14d1631..e030dc0 100644
--- a/net/http/http_chunked_decoder.cc
+++ b/net/http/http_chunked_decoder.cc
@@ -136,7 +136,7 @@ int HttpChunkedDecoder::ScanForChunkRemaining(const char* buf, int buf_len) {
     } else {
       DLOG(ERROR) << "missing chunk-size";
       return ERR_INVALID_CHUNKED_ENCODING;
-    } 
+    }
     line_buf_.clear();
   } else {
     // Save the partial line; wait for more data.
diff --git a/net/http/http_chunked_decoder.h b/net/http/http_chunked_decoder.h
index 0e41bb1..1eb3ea0 100644
--- a/net/http/http_chunked_decoder.h
+++ b/net/http/http_chunked_decoder.h
@@ -92,7 +92,7 @@ class HttpChunkedDecoder {
   // Convert string |start| of length |len| to a numeric value.
   // |start| is a string of type "chunk-size" (hex string).
   // If the conversion succeeds, return true and place the result in |out|.
-  static bool ParseChunkSize(const char* start, int len, int* out); 
+  static bool ParseChunkSize(const char* start, int len, int* out);
 
   // Indicates the number of bytes remaining for the current chunk.
   int chunk_remaining_;
diff --git a/net/http/http_response_headers.cc b/net/http/http_response_headers.cc
index 47d2f85..536a571 100644
--- a/net/http/http_response_headers.cc
+++ b/net/http/http_response_headers.cc
@@ -510,7 +510,7 @@ void HttpResponseHeaders::ParseStatusLine(
     raw_headers_.append(" 200 OK");
     response_code_ = 200;
     return;
-  } 
+  }
   raw_headers_.push_back(' ');
   raw_headers_.append(code, p);
   raw_headers_.push_back(' ');
@@ -967,7 +967,7 @@ int64 HttpResponseHeaders::GetContentLength() const {
 
   int64 result;
   bool ok = StringToInt64(content_length_val, &result);
-  if (!ok || result < 0) 
+  if (!ok || result < 0)
     return -1;
 
   return result;
diff --git a/net/http/http_response_headers_unittest.cc b/net/http/http_response_headers_unittest.cc
index 79064b6..a8d76304 100644
--- a/net/http/http_response_headers_unittest.cc
+++ b/net/http/http_response_headers_unittest.cc
@@ -103,7 +103,7 @@ TEST(HttpResponseHeadersTest, NormalizeHeadersLeadingWhitespace) {
     "HTTP/1.1 202 Accepted\n"
     "Set-Cookie: a, b\n",
 
-    202, 
+    202,
     HttpVersion(1,1),
     HttpVersion(1,1)
   };
diff --git a/net/http/http_util.h b/net/http/http_util.h
index 9966c60..91f893c 100644
--- a/net/http/http_util.h
+++ b/net/http/http_util.h
@@ -108,9 +108,9 @@ class HttpUtil {
   // starts with 1.0 and is decremented by 0.2 for each successive entry
   // in the list until it reaches 0.2. All the entries after that are
   // assigned the same qvalue of 0.2. Also, note that the 1st language
-  // will not have a qvalue added because the absence of a qvalue implicitly 
+  // will not have a qvalue added because the absence of a qvalue implicitly
   // means q=1.0.
-  // 
+  //
   // When making a http request, this should be used to determine what
   // to put in Accept-Language header. If a comma separated list of language
   // codes *without* qvalue is sent, web servers regard all
diff --git a/net/http/http_version.h b/net/http/http_version.h
index 8ea8fd5..f6fe70b 100644
--- a/net/http/http_version.h
+++ b/net/http/http_version.h
@@ -29,7 +29,7 @@ class HttpVersion {
   }
 
   // Overloaded operators:
-  
+
   bool operator==(const HttpVersion& v) const {
     return value_ == v.value_;
   }
diff --git a/net/http/md4.cc b/net/http/md4.cc
index b457f2d..da1e8d3 100644
--- a/net/http/md4.cc
+++ b/net/http/md4.cc
@@ -126,10 +126,10 @@ static void md4step(Uint32 state[4], const Uint8 *data)
   RD1(A,B,C,D, 8,3); RD1(D,A,B,C, 9,7); RD1(C,D,A,B,10,11); RD1(B,C,D,A,11,19);
   RD1(A,B,C,D,12,3); RD1(D,A,B,C,13,7); RD1(C,D,A,B,14,11); RD1(B,C,D,A,15,19);
 
-  RD2(A,B,C,D, 0,3); RD2(D,A,B,C, 4,5); RD2(C,D,A,B, 8, 9); RD2(B,C,D,A,12,13); 
-  RD2(A,B,C,D, 1,3); RD2(D,A,B,C, 5,5); RD2(C,D,A,B, 9, 9); RD2(B,C,D,A,13,13); 
-  RD2(A,B,C,D, 2,3); RD2(D,A,B,C, 6,5); RD2(C,D,A,B,10, 9); RD2(B,C,D,A,14,13); 
-  RD2(A,B,C,D, 3,3); RD2(D,A,B,C, 7,5); RD2(C,D,A,B,11, 9); RD2(B,C,D,A,15,13); 
+  RD2(A,B,C,D, 0,3); RD2(D,A,B,C, 4,5); RD2(C,D,A,B, 8, 9); RD2(B,C,D,A,12,13);
+  RD2(A,B,C,D, 1,3); RD2(D,A,B,C, 5,5); RD2(C,D,A,B, 9, 9); RD2(B,C,D,A,13,13);
+  RD2(A,B,C,D, 2,3); RD2(D,A,B,C, 6,5); RD2(C,D,A,B,10, 9); RD2(B,C,D,A,14,13);
+  RD2(A,B,C,D, 3,3); RD2(D,A,B,C, 7,5); RD2(C,D,A,B,11, 9); RD2(B,C,D,A,15,13);
 
   RD3(A,B,C,D, 0,3); RD3(D,A,B,C, 8,9); RD3(C,D,A,B, 4,11); RD3(B,C,D,A,12,15);
   RD3(A,B,C,D, 2,3); RD3(D,A,B,C,10,9); RD3(C,D,A,B, 6,11); RD3(B,C,D,A,14,15);
diff --git a/net/http/md4.h b/net/http/md4.h
index 419ec39..b416e26 100644
--- a/net/http/md4.h
+++ b/net/http/md4.h
@@ -51,7 +51,7 @@ namespace weak_crypto {
 
 /**
  * MD4Sum - computes the MD4 sum over the input buffer per RFC 1320
- * 
+ *
  * @param input
  *        buffer containing input data
  * @param inputLen