Fixes CRLF and trailing white spaces.

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

53 files changed, 238 insertions, 238 deletions

diff --git a/net/base/cookie_monster.h b/net/base/cookie_monster.h
index c9e48d7..580e176 100644
--- a/net/base/cookie_monster.h
+++ b/net/base/cookie_monster.h
@@ -53,7 +53,7 @@ class CookieMonster {
    public:
     // Default is to exclude httponly, which means:
     // - reading operations will not return httponly cookies.
-    // - writing operations will not write httponly cookies. 
+    // - writing operations will not write httponly cookies.
     CookieOptions() : exclude_httponly_(true) {}
     void set_exclude_httponly() { exclude_httponly_ = true; }
     void set_include_httponly() { exclude_httponly_ = false; }
diff --git a/net/base/cookie_monster_unittest.cc b/net/base/cookie_monster_unittest.cc
index 48843d1..1878285 100644
--- a/net/base/cookie_monster_unittest.cc
+++ b/net/base/cookie_monster_unittest.cc
@@ -533,7 +533,7 @@ TEST(CookieMonsterTest, HttpOnlyTest) {
 
   // Create a httponly cookie.
   EXPECT_TRUE(cm.SetCookieWithOptions(url_google, "A=B; httponly", options));
-  
+
   // Check httponly read protection.
   EXPECT_EQ("", cm.GetCookies(url_google));
   EXPECT_EQ("A=B", cm.GetCookiesWithOptions(url_google, options));
diff --git a/net/base/file_stream.h b/net/base/file_stream.h
index eaf6a0d..28b40e7 100644
--- a/net/base/file_stream.h
+++ b/net/base/file_stream.h
@@ -70,12 +70,12 @@ class FileStream {
   // not complete synchronously, then ERR_IO_PENDING is returned, and the
   // callback will be notified on the current thread (via the MessageLoop) when
   // the read has completed.
-  // 
+  //
   // In the case of an asychronous read, the memory pointed to by |buf| must
   // remain valid until the callback is notified.  However, it is valid to
   // destroy or close the file stream while there is an asynchronous read in
   // progress.  That will cancel the read and allow the buffer to be freed.
-  // 
+  //
   // This method should not be called if the stream was opened WRITE_ONLY.
   //
   // You can pass NULL as the callback for synchronous I/O.
@@ -90,7 +90,7 @@ class FileStream {
 
   // Call this method to write data at the current stream position.  Up to
   // buf_len bytes will be written from buf. (In other words, partial writes are
-  // allowed.)  Returns the number of bytes written, or an error code if the 
+  // allowed.)  Returns the number of bytes written, or an error code if the
   // operation could not be performed.
   //
   // If opened with PLATFORM_FILE_ASYNC, then a non-null callback
@@ -98,12 +98,12 @@ class FileStream {
   // not complete synchronously, then ERR_IO_PENDING is returned, and the
   // callback will be notified on the current thread (via the MessageLoop) when
   // the write has completed.
-  // 
+  //
   // In the case of an asychronous write, the memory pointed to by |buf| must
   // remain valid until the callback is notified.  However, it is valid to
   // destroy or close the file stream while there is an asynchronous write in
   // progress.  That will cancel the write and allow the buffer to be freed.
-  // 
+  //
   // This method should not be called if the stream was opened READ_ONLY.
   //
   // You can pass NULL as the callback for synchronous I/O.
diff --git a/net/base/file_stream_posix.cc b/net/base/file_stream_posix.cc
index 151cf5d..34f7889 100644
--- a/net/base/file_stream_posix.cc
+++ b/net/base/file_stream_posix.cc
@@ -106,7 +106,7 @@ int64 FileStream::Seek(Whence whence, int64 offset) {
 
   // If we're in async, make sure we don't have a request in flight.
   DCHECK(!async_context_.get() || !async_context_->callback());
-  
+
   off_t res = lseek(file_, static_cast<off_t>(offset),
                     static_cast<int>(whence));
   if (res == static_cast<off_t>(-1))
diff --git a/net/base/file_stream_unittest.cc b/net/base/file_stream_unittest.cc
index f96d57f..318eb93 100644
--- a/net/base/file_stream_unittest.cc
+++ b/net/base/file_stream_unittest.cc
@@ -35,7 +35,7 @@ class FileStreamTest : public PlatformTest {
 
 TEST_F(FileStreamTest, BasicOpenClose) {
   net::FileStream stream;
-  int rv = stream.Open(temp_file_path(), 
+  int rv = stream.Open(temp_file_path(),
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
   EXPECT_EQ(net::OK, rv);
 }
@@ -103,7 +103,7 @@ TEST_F(FileStreamTest, BasicRead) {
   EXPECT_TRUE(ok);
 
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
+  int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -133,8 +133,8 @@ TEST_F(FileStreamTest, AsyncRead) {
   EXPECT_TRUE(ok);
 
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
-              base::PLATFORM_FILE_READ | 
+  int flags = base::PLATFORM_FILE_OPEN |
+              base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_ASYNC;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -168,7 +168,7 @@ TEST_F(FileStreamTest, BasicRead_FromOffset) {
   EXPECT_TRUE(ok);
 
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
+  int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -202,8 +202,8 @@ TEST_F(FileStreamTest, AsyncRead_FromOffset) {
   EXPECT_TRUE(ok);
 
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
-              base::PLATFORM_FILE_READ | 
+  int flags = base::PLATFORM_FILE_OPEN |
+              base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_ASYNC;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -237,7 +237,7 @@ TEST_F(FileStreamTest, AsyncRead_FromOffset) {
 
 TEST_F(FileStreamTest, SeekAround) {
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
+  int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_READ;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -260,7 +260,7 @@ TEST_F(FileStreamTest, SeekAround) {
 
 TEST_F(FileStreamTest, BasicWrite) {
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_CREATE_ALWAYS | 
+  int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
               base::PLATFORM_FILE_WRITE;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -281,8 +281,8 @@ TEST_F(FileStreamTest, BasicWrite) {
 
 TEST_F(FileStreamTest, AsyncWrite) {
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_CREATE_ALWAYS | 
-              base::PLATFORM_FILE_WRITE | 
+  int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
+              base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -311,7 +311,7 @@ TEST_F(FileStreamTest, AsyncWrite) {
 
 TEST_F(FileStreamTest, BasicWrite_FromOffset) {
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
+  int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_WRITE;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
@@ -340,7 +340,7 @@ TEST_F(FileStreamTest, AsyncWrite_FromOffset) {
   EXPECT_TRUE(ok);
 
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
+  int flags = base::PLATFORM_FILE_OPEN |
               base::PLATFORM_FILE_WRITE |
               base::PLATFORM_FILE_ASYNC;
   int rv = stream.Open(temp_file_path(), flags);
@@ -373,8 +373,8 @@ TEST_F(FileStreamTest, BasicReadWrite) {
   EXPECT_TRUE(ok);
 
   net::FileStream stream;
-  int flags = base::PLATFORM_FILE_OPEN | 
-              base::PLATFORM_FILE_READ | 
+  int flags = base::PLATFORM_FILE_OPEN |
+              base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE;
   int rv = stream.Open(temp_file_path(), flags);
   EXPECT_EQ(net::OK, rv);
diff --git a/net/base/gzip_filter.cc b/net/base/gzip_filter.cc
index af7609b..79395a2 100644
--- a/net/base/gzip_filter.cc
+++ b/net/base/gzip_filter.cc
@@ -41,7 +41,7 @@ bool GZipFilter::InitDecoding(Filter::FilterType filter_type) {
       decoding_mode_ = DECODE_MODE_DEFLATE;
       break;
     }
-    case Filter::FILTER_TYPE_GZIP_HELPING_SDCH:      
+    case Filter::FILTER_TYPE_GZIP_HELPING_SDCH:
       possible_sdch_pass_through_ =  true;  // Needed to optionally help sdch.
       // Fall through to GZIP case.
     case Filter::FILTER_TYPE_GZIP: {
@@ -105,7 +105,7 @@ Filter::FilterStatus GZipFilter::ReadFilteredData(char* dest_buffer,
         break;
       }
       case Filter::FILTER_ERROR: {
-        if (possible_sdch_pass_through_ && 
+        if (possible_sdch_pass_through_ &&
             GZIP_GET_INVALID_HEADER == gzip_header_status_) {
           decoding_status_ = DECODING_DONE;  // Become a pass through filter.
           return CopyOut(dest_buffer, dest_len);
diff --git a/net/base/listen_socket.cc b/net/base/listen_socket.cc
index b2185a2..a172e46 100644
--- a/net/base/listen_socket.cc
+++ b/net/base/listen_socket.cc
@@ -216,7 +216,7 @@ void ListenSocket::Send(const std::string& str, bool append_linefeed) {
 }
 
 // TODO (ibrar): We can add these functions into OS dependent files
-#if defined(OS_WIN) 
+#if defined(OS_WIN)
 // MessageLoop watcher callback
 void ListenSocket::OnObjectSignaled(HANDLE object) {
   WSANETWORKEVENTS ev;
@@ -224,10 +224,10 @@ void ListenSocket::OnObjectSignaled(HANDLE object) {
     // TODO
     return;
   }
-  
+
   // The object was reset by WSAEnumNetworkEvents.  Watch for the next signal.
   watcher_.StartWatching(object, this);
-  
+
   if (ev.lNetworkEvents == 0) {
     // Occasionally the event is set even though there is no new data.
     // The net seems to think that this is ignorable.
diff --git a/net/base/listen_socket_unittest.cc b/net/base/listen_socket_unittest.cc
index aaac099..6ae798a 100644
--- a/net/base/listen_socket_unittest.cc
+++ b/net/base/listen_socket_unittest.cc
@@ -33,7 +33,7 @@ void ListenSocketTester::SetUp() {
   ASSERT_EQ(0, pthread_mutex_init(&lock_, NULL ));
   sem_unlink(kSemaphoreName);
   semaphore_ = sem_open(kSemaphoreName, O_CREAT, 0, 0);
-  ASSERT_NE(SEM_FAILED, semaphore_); 
+  ASSERT_NE(SEM_FAILED, semaphore_);
 #endif
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
@@ -132,7 +132,7 @@ bool ListenSocketTester::NextAction(int timeout) {
     timeout--;
     if (timeout <= 0)
       return false;
-    if (result == 0) 
+    if (result == 0)
       break;
   }
   pthread_mutex_lock(&lock_);
@@ -163,7 +163,7 @@ int ListenSocketTester::ClearTestSocket() {
 #endif
         PlatformThread::Sleep(1);
         time_out++;
-        if (time_out > 10) 
+        if (time_out > 10)
           break;
         continue;  // still trying
       }
@@ -199,14 +199,14 @@ void ListenSocketTester::SendFromTester() {
   ReportAction(ListenSocketTestAction(ACTION_SEND));
 }
 
-void ListenSocketTester::DidAccept(ListenSocket *server, 
+void ListenSocketTester::DidAccept(ListenSocket *server,
                                    ListenSocket *connection) {
   connection_ = connection;
   connection_->AddRef();
   ReportAction(ListenSocketTestAction(ACTION_ACCEPT));
 }
 
-void ListenSocketTester::DidRead(ListenSocket *connection, 
+void ListenSocketTester::DidRead(ListenSocket *connection,
                                  const std::string& data) {
   ReportAction(ListenSocketTestAction(ACTION_READ, data));
 }
diff --git a/net/base/listen_socket_unittest.h b/net/base/listen_socket_unittest.h
index 5a04099..382508e 100644
--- a/net/base/listen_socket_unittest.h
+++ b/net/base/listen_socket_unittest.h
@@ -30,7 +30,7 @@
 #if defined(OS_POSIX)
 // Used same name as in Windows to avoid #ifdef where refrenced
 #define SOCKET int
-const int INVALID_SOCKET = -1; 
+const int INVALID_SOCKET = -1;
 const int SOCKET_ERROR = -1;
 #endif
 
@@ -73,7 +73,7 @@ class ListenSocketTester :
  public:
   ListenSocketTester()
       : thread_(NULL),
-        loop_(NULL), 
+        loop_(NULL),
         server_(NULL),
         connection_(NULL){
   }
diff --git a/net/base/mime_sniffer.cc b/net/base/mime_sniffer.cc
index d982f85..d67682b 100644
--- a/net/base/mime_sniffer.cc
+++ b/net/base/mime_sniffer.cc
@@ -144,9 +144,9 @@ static const MagicNumber kMagicNumbers[] = {
   MAGIC_NUMBER("image/jpeg", "\xFF\xD8\xFF")
   MAGIC_NUMBER("image/bmp", "BM")
   // Source: Mozilla
-  MAGIC_NUMBER("text/plain", "#!")  // Script 
-  MAGIC_NUMBER("text/plain", "%!")  // Script, similar to PS 
-  MAGIC_NUMBER("text/plain", "From")  
+  MAGIC_NUMBER("text/plain", "#!")  // Script
+  MAGIC_NUMBER("text/plain", "%!")  // Script, similar to PS
+  MAGIC_NUMBER("text/plain", "From")
   MAGIC_NUMBER("text/plain", ">From")
   // Chrome specific
   MAGIC_NUMBER("application/x-gzip", "\x1F\x8B\x08")
diff --git a/net/base/mime_sniffer_unittest.cc b/net/base/mime_sniffer_unittest.cc
index caf258b..96eb441 100644
--- a/net/base/mime_sniffer_unittest.cc
+++ b/net/base/mime_sniffer_unittest.cc
@@ -298,7 +298,7 @@ TEST(MimeSnifferTest, XMLTest) {
 // Test content which is >= 512 bytes, and includes no open angle bracket.
 // http://code.google.com/p/chromium/issues/detail?id=3521
 TEST(MimeSnifferTest, XMLTestLargeNoAngledBracket) {
-  // Make a large input, with 600 bytes of "x". 
+  // Make a large input, with 600 bytes of "x".
   std::string content;
   content.resize(600);
   std::fill(content.begin(), content.end(), 'x');
diff --git a/net/base/nss_memio.c b/net/base/nss_memio.c
index ca3421e..f32ca5d 100644
--- a/net/base/nss_memio.c
+++ b/net/base/nss_memio.c
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 // Written in NSPR style to also be suitable for adding to the NSS demo suite
 
-/* memio is a simple NSPR I/O layer that lets you decouple NSS from 
+/* memio is a simple NSPR I/O layer that lets you decouple NSS from
  * the real network.  It's rather like openssl's memory bio,
  * and is useful when your app absolutely, positively doesn't
  * want to let NSS do its own networking.
@@ -38,21 +38,21 @@ struct memio_buffer {
 };
 
 
-/* The 'secret' field of a PRFileDesc created by memio_CreateIOLayer points 
+/* The 'secret' field of a PRFileDesc created by memio_CreateIOLayer points
  * to one of these.
- * In the public header, we use struct memio_Private as a typesafe alias 
+ * In the public header, we use struct memio_Private as a typesafe alias
  * for this.  This causes a few ugly typecasts in the private file, but
  * seems safer.
  */
 struct PRFilePrivate {
     /* read requests are satisfied from this buffer */
-    struct memio_buffer readbuf;    
+    struct memio_buffer readbuf;
 
     /* write requests are satisfied from this buffer */
-    struct memio_buffer writebuf;   
+    struct memio_buffer writebuf;
 
     /* SSL needs to know socket peer's name */
-    PRNetAddr peername;             
+    PRNetAddr peername;
 
     /* if set, empty I/O returns EOF instead of EWOULDBLOCK */
     int eof;
@@ -120,7 +120,7 @@ static int memio_buffer_used(const struct memio_buffer *mb)
 
 /* How many bytes can be read out of the buffer without wrapping */
 static int memio_buffer_used_contiguous(const struct memio_buffer *mb)
-{ 
+{
     return (((mb->tail >= mb->head) ? mb->tail : mb->bufsize) - mb->head);
 }
 
@@ -132,7 +132,7 @@ static int memio_buffer_unused(const struct memio_buffer *mb)
 
 /* How many bytes can be written into the buffer without wrapping */
 static int memio_buffer_unused_contiguous(const struct memio_buffer *mb)
-{ 
+{
     if (mb->head > mb->tail) return mb->head - mb->tail - 1;
     return mb->bufsize - mb->tail - (mb->head == 0);
 }
@@ -236,7 +236,7 @@ static PRStatus PR_CALLBACK memio_Shutdown(PRFileDesc *fd, PRIntn how)
  * out of the buffer, return it to the next call that
  * tries to read from an empty buffer.
  */
-static int PR_CALLBACK memio_Recv(PRFileDesc *fd, void *buf, PRInt32 len, 
+static int PR_CALLBACK memio_Recv(PRFileDesc *fd, void *buf, PRInt32 len,
                                   PRIntn flags, PRIntervalTime timeout)
 {
     struct PRFilePrivate *secret;
@@ -323,11 +323,11 @@ static PRStatus memio_GetSocketOption(PRFileDesc *fd, PRSocketOptionData *data)
 
 /*--------------- private memio data -----------------------*/
 
-/* 
+/*
  * Implement just the bare minimum number of methods needed to make ssl happy.
  *
- * Oddly, PR_Recv calls ssl_Recv calls ssl_SocketIsBlocking calls 
- * PR_GetSocketOption, so we have to provide an implementation of 
+ * Oddly, PR_Recv calls ssl_Recv calls ssl_SocketIsBlocking calls
+ * PR_GetSocketOption, so we have to provide an implementation of
  * PR_GetSocketOption that just says "I'm nonblocking".
  */
 
diff --git a/net/base/nss_memio.h b/net/base/nss_memio.h
index b766007..0bee53e 100644
--- a/net/base/nss_memio.h
+++ b/net/base/nss_memio.h
@@ -8,7 +8,7 @@
 
 #ifdef __cplusplus
 extern "C" {
-#endif 
+#endif
 
 #include "prio.h"
 
@@ -27,7 +27,7 @@ typedef struct memio_Private memio_Private;
  5) While at the same time doing plaintext nonblocking NSPR I/O as
     usual to the nspr file descriptor returned by SSL_ImportFD,
     your app must shuttle encrypted data between
-    the real network and memio's network buffers.  
+    the real network and memio's network buffers.
     memio_GetReadParams/memio_PutReadResult
     are the hooks you need to pump data into memio's input buffer,
     and memio_GetWriteParams/memio_PutWriteResult
@@ -55,7 +55,7 @@ memio_Private *memio_GetSecret(PRFileDesc *fd);
 int memio_GetReadParams(memio_Private *secret, char **buf);
 
 /* Tell memio how many bytes were read from the network.
- * If bytes_read is 0, causes EOF to be reported to 
+ * If bytes_read is 0, causes EOF to be reported to
  * NSS after it reads the last byte from the circular buffer.
  * If bytes_read is < 0, it is treated as an NSPR error code.
  * See nspr/pr/src/md/unix/unix_errors.c for how to
@@ -81,6 +81,6 @@ void memio_PutWriteResult(memio_Private *secret, int bytes_written);
 
 #ifdef __cplusplus
 }
-#endif 
+#endif
 
 #endif
diff --git a/net/base/sdch_manager.cc b/net/base/sdch_manager.cc
index 458c3a4..ac63c6c 100644
--- a/net/base/sdch_manager.cc
+++ b/net/base/sdch_manager.cc
@@ -142,12 +142,12 @@ const bool SdchManager::IsInSupportedDomain(const GURL& url) {
 
 bool SdchManager::CanFetchDictionary(const GURL& referring_url,
                                      const GURL& dictionary_url) const {
-  /* The user agent may retrieve a dictionary from the dictionary URL if all of 
+  /* The user agent may retrieve a dictionary from the dictionary URL if all of
      the following are true:
        1 The dictionary URL host name matches the referrer URL host name
        2 The dictionary URL host name domain matches the parent domain of the
            referrer URL host name
-       3 The parent domain of the referrer URL host name is not a top level 
+       3 The parent domain of the referrer URL host name is not a top level
            domain
        4 The dictionary URL is not an HTTPS URL.
    */
@@ -365,7 +365,7 @@ bool SdchManager::Dictionary::CanSet(const std::string& domain,
                                      const GURL& dictionary_url) {
   if (!SdchManager::Global()->IsInSupportedDomain(dictionary_url))
     return false;
-  /* 
+  /*
   A dictionary is invalid and must not be stored if any of the following are
   true:
     1. The dictionary has no Domain attribute.
@@ -459,7 +459,7 @@ bool SdchManager::Dictionary::CanUse(const GURL referring_url) {
 bool SdchManager::Dictionary::CanAdvertise(const GURL& target_url) {
   if (!SdchManager::Global()->IsInSupportedDomain(target_url))
     return false;
-  /* The specific rules of when a dictionary should be advertised in an 
+  /* The specific rules of when a dictionary should be advertised in an
      Avail-Dictionary header are modeled after the rules for cookie scoping. The
      terms "domain-match" and "pathmatch" are defined in RFC 2965 [6]. A
      dictionary may be advertised in the Avail-Dictionaries header exactly when
@@ -489,7 +489,7 @@ bool SdchManager::Dictionary::PathMatch(const std::string& path,
   /*  Must be either:
   1. P2 is equal to P1
   2. P2 is a prefix of P1 and either the final character in P2 is "/" or the
-      character following P2 in P1 is "/". 
+      character following P2 in P1 is "/".
       */
   if (path == restriction)
     return true;
diff --git a/net/base/ssl_client_socket_mac.cc b/net/base/ssl_client_socket_mac.cc
index d351db5..0d10030 100644
--- a/net/base/ssl_client_socket_mac.cc
+++ b/net/base/ssl_client_socket_mac.cc
@@ -119,11 +119,11 @@ int NetErrorFromOSStatus(OSStatus status) {
       return ERR_CERT_INVALID;
     case errSSLPeerCertRevoked:
       return ERR_CERT_REVOKED;
-    
+
     case errSSLClosedGraceful:
     case noErr:
       return OK;
-      
+
     case errSSLBadRecordMac:
     case errSSLBufferOverflow:
     case errSSLDecryptionFail:
@@ -168,7 +168,7 @@ OSStatus OSStatusFromNetError(int net_error) {
 int KeySizeOfCipherSuite(SSLCipherSuite suite) {
   switch (suite) {
     // SSL 2 only
-    
+
     case SSL_RSA_WITH_DES_CBC_MD5:
       return 56;
     case SSL_RSA_WITH_3DES_EDE_CBC_MD5:
@@ -178,9 +178,9 @@ int KeySizeOfCipherSuite(SSLCipherSuite suite) {
       return 128;
     case SSL_NO_SUCH_CIPHERSUITE:                // **
       return 0;
-    
+
     // SSL 2, 3, TLS
-    
+
     case SSL_NULL_WITH_NULL_NULL:
     case SSL_RSA_WITH_NULL_MD5:
     case SSL_RSA_WITH_NULL_SHA:                  // **
@@ -217,9 +217,9 @@ int KeySizeOfCipherSuite(SSLCipherSuite suite) {
     case SSL_RSA_WITH_IDEA_CBC_SHA:              // **
     case SSL_DH_anon_WITH_RC4_128_MD5:
       return 128;
-    
+
     // TLS AES options (see RFC 3268)
-    
+
     case TLS_RSA_WITH_AES_128_CBC_SHA:
     case TLS_DH_DSS_WITH_AES_128_CBC_SHA:        // **
     case TLS_DH_RSA_WITH_AES_128_CBC_SHA:        // **
@@ -234,7 +234,7 @@ int KeySizeOfCipherSuite(SSLCipherSuite suite) {
     case TLS_DHE_RSA_WITH_AES_256_CBC_SHA:
     case TLS_DH_anon_WITH_AES_256_CBC_SHA:
       return 256;
-    
+
     default:
       return -1;
   }
@@ -287,13 +287,13 @@ int SSLClientSocketMac::ReconnectIgnoringLastError(
 
 void SSLClientSocketMac::Disconnect() {
   completed_handshake_ = false;
-  
+
   if (ssl_context_) {
     SSLClose(ssl_context_);
     SSLDisposeContext(ssl_context_);
     ssl_context_ = NULL;
   }
-  
+
   transport_->Disconnect();
 }
 
@@ -342,7 +342,7 @@ int SSLClientSocketMac::Write(const char* buf, int buf_len,
 
   user_buf_ = const_cast<char*>(buf);
   user_buf_len_ = buf_len;
-  
+
   next_state_ = STATE_PAYLOAD_WRITE;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
@@ -353,15 +353,15 @@ int SSLClientSocketMac::Write(const char* buf, int buf_len,
 void SSLClientSocketMac::GetSSLInfo(SSLInfo* ssl_info) {
   DCHECK(completed_handshake_);
   OSStatus status;
-  
+
   ssl_info->Reset();
-  
+
   // set cert
   CFArrayRef certs;
   status = SSLCopyPeerCertificates(ssl_context_, &certs);
   if (!status) {
     DCHECK(CFArrayGetCount(certs) > 0);
-    
+
     SecCertificateRef client_cert =
         static_cast<SecCertificateRef>(
           const_cast<void*>(CFArrayGetValueAtIndex(certs, 0)));
@@ -370,17 +370,17 @@ void SSLClientSocketMac::GetSSLInfo(SSLInfo* ssl_info) {
         client_cert, X509Certificate::SOURCE_FROM_NETWORK);
     CFRelease(certs);
   }
-  
+
   // update status
   ssl_info->cert_status = server_cert_status_;
-  
+
   // security info
   SSLCipherSuite suite;
   status = SSLGetNegotiatedCipher(ssl_context_, &suite);
   if (!status)
     ssl_info->security_bits = KeySizeOfCipherSuite(suite);
 }
-  
+
 void SSLClientSocketMac::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(user_callback_);
@@ -459,78 +459,78 @@ int SSLClientSocketMac::DoConnectComplete(int result) {
     return result;
 
   OSStatus status = noErr;
-  
+
   status = SSLNewContext(false, &ssl_context_);
   if (status)
     return NetErrorFromOSStatus(status);
-  
+
   status = SSLSetProtocolVersionEnabled(ssl_context_,
                                         kSSLProtocol2,
                                         ssl_config_.ssl2_enabled);
   if (status)
     return NetErrorFromOSStatus(status);
-  
+
   status = SSLSetProtocolVersionEnabled(ssl_context_,
                                         kSSLProtocol3,
                                         ssl_config_.ssl3_enabled);
   if (status)
     return NetErrorFromOSStatus(status);
-  
+
   status = SSLSetProtocolVersionEnabled(ssl_context_,
                                         kTLSProtocol1,
                                         ssl_config_.tls1_enabled);
   if (status)
     return NetErrorFromOSStatus(status);
-  
+
   status = SSLSetIOFuncs(ssl_context_, SSLReadCallback, SSLWriteCallback);
   if (status)
     return NetErrorFromOSStatus(status);
-  
+
   status = SSLSetConnection(ssl_context_, this);
   if (status)
     return NetErrorFromOSStatus(status);
-  
+
   status = SSLSetPeerDomainName(ssl_context_, hostname_.c_str(),
                                 hostname_.length());
   if (status)
     return NetErrorFromOSStatus(status);
-  
+
   next_state_ = STATE_HANDSHAKE;
   return OK;
 }
 
 int SSLClientSocketMac::DoHandshake() {
   OSStatus status = SSLHandshake(ssl_context_);
-  
+
   if (status == errSSLWouldBlock)
     next_state_ = STATE_HANDSHAKE;
-  
+
   if (status == noErr)
     completed_handshake_ = true;
-  
+
   int net_error = NetErrorFromOSStatus(status);
-  
+
   // At this point we have a connection. For now, we're going to use the default
   // certificate verification that the system does, and accept its answer for
   // the cert status. In the future, we'll need to call SSLSetEnableCertVerify
   // to disable cert verification and do the verification ourselves. This allows
   // very fine-grained control over what we'll accept for certification.
   // TODO(avi): ditto
-  
+
   // TODO(wtc): for now, always check revocation.
   server_cert_status_ = CERT_STATUS_REV_CHECKING_ENABLED;
   if (net_error)
     server_cert_status_ |= MapNetErrorToCertStatus(net_error);
-  
+
   return net_error;
 }
 
 int SSLClientSocketMac::DoReadComplete(int result) {
   if (result < 0)
     return result;
-  
+
   recv_buffer_tail_slop_ -= result;
-    
+
   return result;
 }
 
@@ -539,10 +539,10 @@ void SSLClientSocketMac::OnWriteComplete(int result) {
     pending_send_error_ = result;
     return;
   }
-  
+
   send_buffer_.erase(send_buffer_.begin(),
                      send_buffer_.begin() + result);
-  
+
   if (!send_buffer_.empty())
     SSLWriteCallback(this, NULL, NULL);
 }
@@ -553,22 +553,22 @@ int SSLClientSocketMac::DoPayloadRead() {
                             user_buf_,
                             user_buf_len_,
                             &processed);
-  
+
   // There's a subtle difference here in semantics of the "would block" errors.
   // In our code, ERR_IO_PENDING means the whole operation is async, while
   // errSSLWouldBlock means that the stream isn't ending (and is often returned
   // along with partial data). So even though "would block" is returned, if we
   // have data, let's just return it.
-  
+
   if (processed > 0) {
     next_state_ = STATE_NONE;
     return processed;
   }
-  
+
   if (status == errSSLWouldBlock) {
     next_state_ = STATE_PAYLOAD_READ;
   }
-  
+
   return NetErrorFromOSStatus(status);
 }
 
@@ -578,10 +578,10 @@ int SSLClientSocketMac::DoPayloadWrite() {
                              user_buf_,
                              user_buf_len_,
                              &processed);
-  
+
   if (processed > 0)
     return processed;
-  
+
   return NetErrorFromOSStatus(status);
 }
 
@@ -665,40 +665,40 @@ OSStatus SSLClientSocketMac::SSLReadCallback(SSLConnectionRef connection,
   SSLClientSocketMac* us =
       const_cast<SSLClientSocketMac*>(
           static_cast<const SSLClientSocketMac*>(connection));
-  
+
   // If we have I/O in flight, promise we'll get back to them and use the
   // existing callback to do so
-  
+
   if (us->next_io_state_ == STATE_READ_COMPLETE) {
     *data_length = 0;
     return errSSLWouldBlock;
   }
-  
+
   // Start with what's in the buffer
-  
+
   size_t total_read = us->recv_buffer_.size() - us->recv_buffer_head_slop_ -
                       us->recv_buffer_tail_slop_;
-  
+
   // Resize the buffer if needed
-  
+
   if (us->recv_buffer_.size() - us->recv_buffer_head_slop_ < *data_length) {
     us->recv_buffer_.resize(us->recv_buffer_head_slop_ + *data_length);
     us->recv_buffer_tail_slop_ = *data_length - total_read;
   }
-  
+
   int rv = 1;  // any old value to spin the loop below
   while (rv > 0 && total_read < *data_length) {
     rv = us->transport_->Read(&us->recv_buffer_[us->recv_buffer_head_slop_ +
                                                 total_read],
                               us->recv_buffer_tail_slop_,
                               &us->io_callback_);
-    
+
     if (rv > 0) {
       total_read += rv;
       us->recv_buffer_tail_slop_ -= rv;
     }
-  } 
-  
+  }
+
   *data_length = total_read;
   if (total_read) {
     memcpy(data, &us->recv_buffer_[us->recv_buffer_head_slop_], total_read);
@@ -714,31 +714,31 @@ OSStatus SSLClientSocketMac::SSLReadCallback(SSLConnectionRef connection,
       us->recv_buffer_head_slop_ = 0;
     }
   }
-  
+
   if (rv == ERR_IO_PENDING) {
     us->next_io_state_ = STATE_READ_COMPLETE;
   }
-  
+
   if (rv < 0)
     return OSStatusFromNetError(rv);
-  
+
   return noErr;
 }
 
 // static
-OSStatus SSLClientSocketMac::SSLWriteCallback(SSLConnectionRef connection, 
-                                              const void* data, 
+OSStatus SSLClientSocketMac::SSLWriteCallback(SSLConnectionRef connection,
+                                              const void* data,
                                               size_t* data_length) {
   SSLClientSocketMac* us =
       const_cast<SSLClientSocketMac*>(
           static_cast<const SSLClientSocketMac*>(connection));
-  
+
   if (us->pending_send_error_ != OK) {
     OSStatus status = OSStatusFromNetError(us->pending_send_error_);
     us->pending_send_error_ = OK;
     return status;
   }
-  
+
   if (data)
     us->send_buffer_.insert(us->send_buffer_.end(),
                             static_cast<const char*>(data),
@@ -751,14 +751,14 @@ OSStatus SSLClientSocketMac::SSLWriteCallback(SSLConnectionRef connection,
     if (rv > 0) {
       us->send_buffer_.erase(us->send_buffer_.begin(),
                              us->send_buffer_.begin() + rv);
-      
+
     }
   } while (rv > 0 && !us->send_buffer_.empty());
-  
+
   if (rv < 0 && rv != ERR_IO_PENDING) {
     return OSStatusFromNetError(rv);
   }
-  
+
   // always lie to our caller
   return noErr;
 }
diff --git a/net/base/ssl_client_socket_mac.h b/net/base/ssl_client_socket_mac.h
index c8a43ce..0bff718 100644
--- a/net/base/ssl_client_socket_mac.h
+++ b/net/base/ssl_client_socket_mac.h
@@ -31,7 +31,7 @@ class SSLClientSocketMac : public SSLClientSocket {
 
   // SSLClientSocket methods:
   virtual void GetSSLInfo(SSLInfo* ssl_info);
-  
+
   // ClientSocket methods:
   virtual int Connect(CompletionCallback* callback);
   virtual int ReconnectIgnoringLastError(CompletionCallback* callback);
@@ -55,12 +55,12 @@ class SSLClientSocketMac : public SSLClientSocket {
   int DoHandshake();
   int DoReadComplete(int result);
   void OnWriteComplete(int result);
-  
+
   static OSStatus SSLReadCallback(SSLConnectionRef connection,
                                   void* data,
                                   size_t* data_length);
-  static OSStatus SSLWriteCallback(SSLConnectionRef connection, 
-                                   const void* data, 
+  static OSStatus SSLWriteCallback(SSLConnectionRef connection,
+                                   const void* data,
                                    size_t* data_length);
 
   CompletionCallbackImpl<SSLClientSocketMac> io_callback_;
@@ -87,12 +87,12 @@ class SSLClientSocketMac : public SSLClientSocket {
   };
   State next_state_;
   State next_io_state_;
-  
+
   int server_cert_status_;
 
   bool completed_handshake_;
   SSLContextRef ssl_context_;
-  
+
   // These are buffers for holding data during I/O. The "slop" is the amount of
   // space at the ends of the receive buffer that are allocated for holding data
   // but don't (yet).
diff --git a/net/base/telnet_server.cc b/net/base/telnet_server.cc
index 3260951..8cd2451 100644
--- a/net/base/telnet_server.cc
+++ b/net/base/telnet_server.cc
@@ -22,7 +22,7 @@
 #if defined(OS_POSIX)
 // Used same name as in Windows to avoid #ifdef where refrenced
 #define SOCKET int
-const int INVALID_SOCKET = -1; 
+const int INVALID_SOCKET = -1;
 const int SOCKET_ERROR = -1;
 struct event;  // From libevent
 #endif
@@ -259,7 +259,7 @@ void TelnetServer::Read() {
         break;
 #else
     if (len == SOCKET_ERROR) {
-      if (errno == EWOULDBLOCK || errno == EAGAIN) 
+      if (errno == EWOULDBLOCK || errno == EAGAIN)
         break;
 #endif
     } else if (len == 0) {
diff --git a/net/base/test_completion_callback_unittest.cc b/net/base/test_completion_callback_unittest.cc
index 9967482..1d333f7 100644
--- a/net/base/test_completion_callback_unittest.cc
+++ b/net/base/test_completion_callback_unittest.cc
@@ -16,7 +16,7 @@ using net::CompletionCallback;
 
 const int kMagicResult = 8888;
 
-// ExampleEmployer is a toy version of HostResolver 
+// ExampleEmployer is a toy version of HostResolver
 // TODO: restore damage done in extracting example from real code
 // (e.g. bring back real destructor, bring back comments)
 class ExampleEmployer {
@@ -37,7 +37,7 @@ class ExampleEmployer {
 };
 
 // Helper class; this is how ExampleEmployer puts work on a different thread
-class ExampleEmployer::ExampleWorker 
+class ExampleEmployer::ExampleWorker
     : public base::RefCountedThreadSafe<ExampleWorker> {
  public:
   ExampleWorker(ExampleEmployer* employer, CompletionCallback* callback)
@@ -70,7 +70,7 @@ void ExampleEmployer::ExampleWorker::DoWork() {
       reply = NULL;
     }
   }
-  
+
   // Does nothing if it got posted.
   delete reply;
 }
diff --git a/net/base/x509_certificate_mac.cc b/net/base/x509_certificate_mac.cc
index 3ab62e9..f20d683 100644
--- a/net/base/x509_certificate_mac.cc
+++ b/net/base/x509_certificate_mac.cc
@@ -87,21 +87,21 @@ OSStatus GetCertFieldsForOID(X509Certificate::OSCertHandle cert_handle,
                              CSSM_FIELD_PTR* fields) {
   *num_of_fields = 0;
   *fields = NULL;
-  
+
   CSSM_DATA cert_data;
   OSStatus status = SecCertificateGetData(cert_handle, &cert_data);
   if (status)
     return status;
-  
+
   CSSM_CL_HANDLE cl_handle;
   status = SecCertificateGetCLHandle(cert_handle, &cl_handle);
   if (status)
     return status;
-  
+
   status = CSSM_CL_CertGetAllFields(cl_handle, &cert_data, num_of_fields,
                                     fields);
   return status;
-}    
+}
 
 void GetCertGeneralNamesForOID(X509Certificate::OSCertHandle cert_handle,
                                CSSM_OID oid, CE_GeneralNameType name_type,
@@ -112,14 +112,14 @@ void GetCertGeneralNamesForOID(X509Certificate::OSCertHandle cert_handle,
                                         &fields);
   if (status)
     return;
-  
+
   for (size_t field = 0; field < num_of_fields; ++field) {
     if (CSSMOIDEqual(&fields[field].FieldOid, &oid)) {
       CSSM_X509_EXTENSION_PTR cssm_ext =
           (CSSM_X509_EXTENSION_PTR)fields[field].FieldValue.Data;
       CE_GeneralNames* alt_name =
           (CE_GeneralNames*) cssm_ext->value.parsedValue;
-      
+
       for (size_t name = 0; name < alt_name->numNames; ++name) {
         const CE_GeneralName& name_struct = alt_name->generalName[name];
         // For future extension: We're assuming that these values are of types
@@ -146,15 +146,15 @@ void GetCertGeneralNamesForOID(X509Certificate::OSCertHandle cert_handle,
 
 void GetCertDateForOID(X509Certificate::OSCertHandle cert_handle,
                        CSSM_OID oid, Time* result) {
-  *result = Time::Time(); 
-  
+  *result = Time::Time();
+
   uint32 num_of_fields;
   CSSM_FIELD_PTR fields;
   OSStatus status = GetCertFieldsForOID(cert_handle, oid, &num_of_fields,
                                         &fields);
   if (status)
     return;
-  
+
   for (size_t field = 0; field < num_of_fields; ++field) {
     if (CSSMOIDEqual(&fields[field].FieldOid, &oid)) {
       CSSM_X509_TIME* x509_time =
@@ -163,10 +163,10 @@ void GetCertDateForOID(X509Certificate::OSCertHandle cert_handle,
           std::string(reinterpret_cast<std::string::value_type*>
                       (x509_time->time.Data),
                       x509_time->time.Length);
-      
+
       DCHECK(x509_time->timeType == BER_TAG_UTC_TIME ||
              x509_time->timeType == BER_TAG_GENERALIZED_TIME);
-      
+
       struct tm time;
       const char* parse_string;
       if (x509_time->timeType == BER_TAG_UTC_TIME)
@@ -178,9 +178,9 @@ void GetCertDateForOID(X509Certificate::OSCertHandle cert_handle,
         // this is a rather broken cert.
         return;
       }
-      
+
       strptime(time_string.c_str(), parse_string, &time);
-      
+
       Time::Exploded exploded;
       exploded.year         = time.tm_year + 1900;
       exploded.month        = time.tm_mon + 1;
@@ -190,7 +190,7 @@ void GetCertDateForOID(X509Certificate::OSCertHandle cert_handle,
       exploded.minute       = time.tm_min;
       exploded.second       = time.tm_sec;
       exploded.millisecond  = 0;
-      
+
       *result = Time::FromUTCExploded(exploded);
       break;
     }
@@ -209,12 +209,12 @@ void X509Certificate::Initialize() {
   if (!status) {
     ParsePrincipal(name, &issuer_);
   }
-  
+
   GetCertDateForOID(cert_handle_, CSSMOID_X509V1ValidityNotBefore,
                     &valid_start_);
   GetCertDateForOID(cert_handle_, CSSMOID_X509V1ValidityNotAfter,
                     &valid_expiry_);
-  
+
   fingerprint_ = CalculateFingerprint(cert_handle_);
 
   // Store the certificate in the cache in case we need it later.
@@ -228,7 +228,7 @@ X509Certificate* X509Certificate::CreateFromPickle(const Pickle& pickle,
   int length;
   if (!pickle.ReadData(pickle_iter, &data, &length))
     return NULL;
-  
+
   return CreateFromBytes(data, length);
 }
 
@@ -250,10 +250,10 @@ bool X509Certificate::HasExpired() const {
 
 void X509Certificate::GetDNSNames(std::vector<std::string>* dns_names) const {
   dns_names->clear();
-  
+
   GetCertGeneralNamesForOID(cert_handle_, CSSMOID_SubjectAltName, GNT_DNSName,
                             dns_names);
-  
+
   if (dns_names->empty())
     dns_names->push_back(subject_.common_name);
 }
@@ -264,7 +264,7 @@ int X509Certificate::Verify(const std::string& hostname,
   NOTIMPLEMENTED();
   return ERR_NOT_IMPLEMENTED;
 }
-  
+
 // Returns true if the certificate is an extended-validation certificate.
 //
 // The certificate has already been verified by the HTTP library.  cert_status
diff --git a/net/disk_cache/disk_cache_perftest.cc b/net/disk_cache/disk_cache_perftest.cc
index 74cac65..785f93f 100644
--- a/net/disk_cache/disk_cache_perftest.cc
+++ b/net/disk_cache/disk_cache_perftest.cc
@@ -222,7 +222,7 @@ TEST_F(DiskCacheTest, BlockFilesPerformance) {
   memset(buffer, 0, sizeof(buffer));
   disk_cache::Addr* address = reinterpret_cast<disk_cache::Addr*>(buffer);
   ASSERT_EQ(sizeof(*address), sizeof(*buffer));
-  
+
   PerfTimeLogger timer1("Fill three block-files");
 
   // Fill up the 32-byte block file (use three files).
diff --git a/net/disk_cache/disk_cache_test_util.cc b/net/disk_cache/disk_cache_test_util.cc
index 4920e54..9a15209 100644
--- a/net/disk_cache/disk_cache_test_util.cc
+++ b/net/disk_cache/disk_cache_test_util.cc
@@ -50,8 +50,8 @@ std::wstring GetCachePath() {
 
 bool CreateCacheTestFile(const wchar_t* name) {
   using namespace disk_cache;
-  int flags = base::PLATFORM_FILE_CREATE_ALWAYS | 
-              base::PLATFORM_FILE_READ | 
+  int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
+              base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE;
 
   scoped_refptr<File> file(new File(
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index bb7cc2e..a79b3f7 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -607,7 +607,7 @@ void DiskCacheEntryTest::ZeroLengthIO() {
   std::string key1("the first key");
   disk_cache::Entry *entry1;
   ASSERT_TRUE(cache_->CreateEntry(key1, &entry1));
-  
+
   EXPECT_EQ(0, entry1->ReadData(0, 0, NULL, 0, NULL));
   EXPECT_EQ(0, entry1->WriteData(0, 0, NULL, 0, NULL, false));
 
diff --git a/net/disk_cache/file.h b/net/disk_cache/file.h
index b457e88..53c72bd 100644
--- a/net/disk_cache/file.h
+++ b/net/disk_cache/file.h
@@ -20,7 +20,7 @@ class FileIOCallback {
   // Notified of the actual number of bytes read or written. This value is
   // negative if an error occurred.
   virtual void OnFileIOComplete(int bytes_copied) = 0;
-  
+
   virtual ~FileIOCallback() {}
 };
 
diff --git a/net/disk_cache/stress_cache.cc b/net/disk_cache/stress_cache.cc
index e35a195..4c19cd8 100644
--- a/net/disk_cache/stress_cache.cc
+++ b/net/disk_cache/stress_cache.cc
@@ -179,7 +179,7 @@ void CrashHandler(const std::string& str) {
 
 int main(int argc, const char* argv[]) {
   // Setup an AtExitManager so Singleton objects will be destructed.
-  base::AtExitManager at_exit_manager; 
+  base::AtExitManager at_exit_manager;
 
   if (argc < 2)
     return MasterCode();
diff --git a/net/ftp/ftp_request_info.h b/net/ftp/ftp_request_info.h
index b1d3e1c..235a264 100644
--- a/net/ftp/ftp_request_info.h
+++ b/net/ftp/ftp_request_info.h
@@ -7,7 +7,7 @@
 
 class FtpRequestInfo {
  public:
-  // The requested URL. 
+  // The requested URL.
   GURL url;
 
   // Any upload data.
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
diff --git a/net/proxy/proxy_config_service_fixed.h b/net/proxy/proxy_config_service_fixed.h
index 5120093..9b8b589 100644
--- a/net/proxy/proxy_config_service_fixed.h
+++ b/net/proxy/proxy_config_service_fixed.h
@@ -19,7 +19,7 @@ class ProxyConfigServiceFixed : public ProxyConfigService {
     config->proxy_rules = pi_.proxy_server().ToURI();
     return OK;
   }
-  
+
  private:
   ProxyInfo pi_;
 };
diff --git a/net/proxy/proxy_config_service_win.cc b/net/proxy/proxy_config_service_win.cc
index e3dc95e..d4d18e3 100644
--- a/net/proxy/proxy_config_service_win.cc
+++ b/net/proxy/proxy_config_service_win.cc
@@ -40,7 +40,7 @@ int ProxyConfigServiceWin::GetProxyConfig(ProxyConfig* config) {
     config->proxy_rules = WideToASCII(ie_config.lpszProxy);
   if (ie_config.lpszProxyBypass) {
     std::string proxy_bypass = WideToASCII(ie_config.lpszProxyBypass);
-    
+
     StringTokenizer proxy_server_bypass_list(proxy_bypass, "; \t\n\r");
     while (proxy_server_bypass_list.GetNext()) {
       std::string bypass_url_domain = proxy_server_bypass_list.token();
diff --git a/net/proxy/proxy_resolver_mac.cc b/net/proxy/proxy_resolver_mac.cc
index 796847d..4ac2b18 100644
--- a/net/proxy/proxy_resolver_mac.cc
+++ b/net/proxy/proxy_resolver_mac.cc
@@ -26,7 +26,7 @@ CFTypeRef GetValueFromDictionary(CFDictionaryRef dict,
   CFTypeRef value = CFDictionaryGetValue(dict, key);
   if (!value)
     return value;
-  
+
   if (CFGetTypeID(value) != expected_type) {
     scoped_cftyperef<CFStringRef> expected_type_ref(
         CFCopyTypeIDDescription(expected_type));
@@ -41,7 +41,7 @@ CFTypeRef GetValueFromDictionary(CFDictionaryRef dict,
                  << " instead";
     return NULL;
   }
-  
+
   return value;
 }
 
@@ -54,7 +54,7 @@ bool GetBoolFromDictionary(CFDictionaryRef dict,
                                                            CFNumberGetTypeID());
   if (!number)
     return default_value;
-  
+
   int int_value;
   if (CFNumberGetValue(number, kCFNumberIntType, &int_value))
     return int_value;
@@ -86,7 +86,7 @@ net::ProxyServer GetProxyServerFromDictionary(net::ProxyServer::Scheme scheme,
     return net::ProxyServer();  // Invalid.
   }
   std::string host = base::SysCFStringRefToUTF8(host_ref);
-  
+
   CFNumberRef port_ref =
       (CFNumberRef)GetValueFromDictionary(dict, port_key,
                                           CFNumberGetTypeID());
@@ -96,7 +96,7 @@ net::ProxyServer GetProxyServerFromDictionary(net::ProxyServer::Scheme scheme,
   } else {
     port = net::ProxyServer::GetDefaultPortForScheme(scheme);
   }
-  
+
   return net::ProxyServer(scheme, host, port);
 }
 
@@ -119,18 +119,18 @@ net::ProxyServer::Scheme GetProxyServerScheme(CFStringRef proxy_type) {
 // to a CFTypeRef.  This stashes either |error| or |proxies| in that location.
 void ResultCallback(void* client, CFArrayRef proxies, CFErrorRef error) {
   DCHECK((proxies != NULL) == (error == NULL));
-  
+
   CFTypeRef* result_ptr = (CFTypeRef*)client;
   DCHECK(result_ptr != NULL);
   DCHECK(*result_ptr == NULL);
-  
+
   if (error != NULL) {
     *result_ptr = CFRetain(error);
   } else {
     *result_ptr = CFRetain(proxies);
   }
   CFRunLoopStop(CFRunLoopGetCurrent());
-}  
+}
 
 }  // namespace
 
@@ -140,9 +140,9 @@ int ProxyConfigServiceMac::GetProxyConfig(ProxyConfig* config) {
   scoped_cftyperef<CFDictionaryRef> config_dict(
       SCDynamicStoreCopyProxies(NULL));
   DCHECK(config_dict);
-  
+
   // auto-detect
-  
+
   // There appears to be no UI for this configuration option, and we're not sure
   // if Apple's proxy code even takes it into account. But the constant is in
   // the header file so we'll use it.
@@ -150,9 +150,9 @@ int ProxyConfigServiceMac::GetProxyConfig(ProxyConfig* config) {
       GetBoolFromDictionary(config_dict.get(),
                             kSCPropNetProxiesProxyAutoDiscoveryEnable,
                             false);
-  
+
   // PAC file
-  
+
   if (GetBoolFromDictionary(config_dict.get(),
                             kSCPropNetProxiesProxyAutoConfigEnable,
                             false)) {
@@ -164,9 +164,9 @@ int ProxyConfigServiceMac::GetProxyConfig(ProxyConfig* config) {
     if (pac_url_ref)
       config->pac_url = GURL(base::SysCFStringRefToUTF8(pac_url_ref));
   }
-  
+
   // proxies (for now only ftp, http and https)
-  
+
   if (GetBoolFromDictionary(config_dict.get(),
                             kSCPropNetProxiesFTPEnable,
                             false)) {
@@ -210,9 +210,9 @@ int ProxyConfigServiceMac::GetProxyConfig(ProxyConfig* config) {
       config->proxy_rules += proxy_server.ToURI();
     }
   }
-  
+
   // proxy bypass list
-  
+
   CFArrayRef bypass_array_ref =
       (CFArrayRef)GetValueFromDictionary(config_dict.get(),
                                          kSCPropNetProxiesExceptionsList,
@@ -225,22 +225,22 @@ int ProxyConfigServiceMac::GetProxyConfig(ProxyConfig* config) {
       if (CFGetTypeID(bypass_item_ref) != CFStringGetTypeID()) {
         LOG(WARNING) << "Expected value for item " << i
                      << " in the kSCPropNetProxiesExceptionsList"
-                        " to be a CFStringRef but it was not";      
-        
+                        " to be a CFStringRef but it was not";
+
       } else {
         config->proxy_bypass.push_back(
             base::SysCFStringRefToUTF8(bypass_item_ref));
       }
     }
   }
-  
+
   // proxy bypass boolean
-  
+
   config->proxy_bypass_local_names =
       GetBoolFromDictionary(config_dict.get(),
                             kSCPropNetProxiesExcludeSimpleHostnames,
                             false);
-  
+
   return OK;
 }
 
@@ -261,21 +261,21 @@ int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
       CFURLCreateWithString(kCFAllocatorDefault,
                             pac_ref.get(),
                             NULL));
-  
+
   // Work around <rdar://problem/5530166>. This dummy call to
   // CFNetworkCopyProxiesForURL initializes some state within CFNetwork that is
   // required by CFNetworkExecuteProxyAutoConfigurationURL.
-  
+
   CFArrayRef dummy_result = CFNetworkCopyProxiesForURL(query_url_ref.get(),
                                                        NULL);
   if (dummy_result)
     CFRelease(dummy_result);
-  
+
   // We cheat here. We need to act as if we were synchronous, so we pump the
   // runloop ourselves. Our caller moved us to a new thread anyway, so this is
   // OK to do. (BTW, CFNetworkExecuteProxyAutoConfigurationURL returns a
   // runloop source we need to release despite its name.)
-  
+
   CFTypeRef result = NULL;
   CFStreamClientContext context = { 0, &result, NULL, NULL, NULL };
   scoped_cftyperef<CFRunLoopSourceRef> runloop_source(
@@ -285,17 +285,17 @@ int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
                                                 &context));
   if (!runloop_source)
     return ERR_FAILED;
-  
+
   const CFStringRef private_runloop_mode =
       CFSTR("org.chromium.ProxyResolverMac");
-  
+
   CFRunLoopAddSource(CFRunLoopGetCurrent(), runloop_source.get(),
                      private_runloop_mode);
   CFRunLoopRunInMode(private_runloop_mode, DBL_MAX, false);
   CFRunLoopRemoveSource(CFRunLoopGetCurrent(), runloop_source.get(),
                         private_runloop_mode);
   DCHECK(result != NULL);
-  
+
   if (CFGetTypeID(result) == CFErrorGetTypeID()) {
     // TODO(avi): do something better than this
     CFRelease(result);
@@ -303,19 +303,19 @@ int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
   }
   DCHECK(CFGetTypeID(result) == CFArrayGetTypeID());
   scoped_cftyperef<CFArrayRef> proxy_array_ref((CFArrayRef)result);
-  
+
   // This string will be an ordered list of <proxy-uri> entries, separated by
   // semi-colons. It is the format that ProxyInfo::UseNamedProxy() expects.
   //    proxy-uri = [<proxy-scheme>"://"]<proxy-host>":"<proxy-port>
   // (This also includes entries for direct connection, as "direct://").
   std::string proxy_uri_list;
-  
+
   CFIndex proxy_array_count = CFArrayGetCount(proxy_array_ref.get());
   for (CFIndex i = 0; i < proxy_array_count; ++i) {
     CFDictionaryRef proxy_dictionary =
         (CFDictionaryRef)CFArrayGetValueAtIndex(proxy_array_ref.get(), i);
     DCHECK(CFGetTypeID(proxy_dictionary) == CFDictionaryGetTypeID());
-    
+
     // The dictionary may have the following keys:
     // - kCFProxyTypeKey : The type of the proxy
     // - kCFProxyHostNameKey
@@ -329,7 +329,7 @@ int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
     //                         tease.
     // - kCFProxyAutoConfigurationURLKey : If the PAC file specifies another
     //                                     PAC file, I'm going home.
-    
+
     CFStringRef proxy_type =
         (CFStringRef)GetValueFromDictionary(proxy_dictionary,
                                             kCFProxyTypeKey,
@@ -346,11 +346,11 @@ int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
       proxy_uri_list += ";";
     proxy_uri_list += proxy_server.ToURI();
   }
-  
+
   if (!proxy_uri_list.empty())
     results->UseNamedProxy(proxy_uri_list);
   // Else do nothing (results is already guaranteed to be in the default state).
-  
+
   return OK;
 }
 
diff --git a/net/proxy/proxy_resolver_script.h b/net/proxy/proxy_resolver_script.h
index 5b19924..be592e4 100644
--- a/net/proxy/proxy_resolver_script.h
+++ b/net/proxy/proxy_resolver_script.h
@@ -50,7 +50,7 @@
 //       sed -e 's/"\s*[+]\s*$/"/g' |
 //       sed -e 's/"$/" \\/g' |
 //       sed -e 's/\/(ipaddr);/\/.exec(ipaddr);/g' |
-//       grep -v '^var pacUtils =' 
+//       grep -v '^var pacUtils ='
 #define PROXY_RESOLVER_SCRIPT \
   "function dnsDomainIs(host, domain) {\n" \
   "    return (host.length >= domain.length &&\n" \
diff --git a/net/proxy/proxy_resolver_v8.h b/net/proxy/proxy_resolver_v8.h
index a0275c8..219560c 100644
--- a/net/proxy/proxy_resolver_v8.h
+++ b/net/proxy/proxy_resolver_v8.h
@@ -82,8 +82,8 @@ class ProxyResolverV8::JSBindings {
   // Handler for "alert(message)"
   virtual void Alert(const std::string& message) = 0;
 
-  // Handler for "myIpAddress()". Returns empty string on failure. 
-  virtual std::string MyIpAddress() = 0;      
+  // Handler for "myIpAddress()". Returns empty string on failure.
+  virtual std::string MyIpAddress() = 0;
 
   // Handler for "dnsResolve(host)". Returns empty string on failure.
   virtual std::string DnsResolve(const std::string& host) = 0;
diff --git a/net/proxy/proxy_resolver_v8_unittest.cc b/net/proxy/proxy_resolver_v8_unittest.cc
index 5cbdfd4..dff8843 100644
--- a/net/proxy/proxy_resolver_v8_unittest.cc
+++ b/net/proxy/proxy_resolver_v8_unittest.cc
@@ -379,7 +379,7 @@ TEST(ProxyResolverV8DefaultBindingsTest, DnsResolve) {
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   net::ProxyResolverV8 resolver;
   net::ProxyResolverV8::JSBindings* bindings = resolver.js_bindings();
-  
+
   // Considered an error.
   EXPECT_EQ("", bindings->DnsResolve(""));
 
diff --git a/net/proxy/proxy_script_fetcher.cc b/net/proxy/proxy_script_fetcher.cc
index b48ee1a..22e559ee 100644
--- a/net/proxy/proxy_script_fetcher.cc
+++ b/net/proxy/proxy_script_fetcher.cc
@@ -12,7 +12,7 @@
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request.h"
 
-// TODO(eroman): 
+// TODO(eroman):
 //   - Support auth-prompts.
 
 namespace net {
@@ -197,7 +197,7 @@ void ProxyScriptFetcherImpl::OnResponseStarted(URLRequest* request) {
     // NOTE about mime types: We do not enforce mime types on PAC files.
     // This is for compatibility with {IE 7, Firefox 3, Opera 9.5}
 
-    // NOTE about status codes: We are like Firefox 3 in this respect. 
+    // NOTE about status codes: We are like Firefox 3 in this respect.
     // {IE 7, Safari 3, Opera 9.5} do not care about the status code.
     if (request->GetResponseCode() != 200) {
       result_code_ = ERR_PAC_STATUS_NOT_OK;
diff --git a/net/proxy/proxy_server.cc b/net/proxy/proxy_server.cc
index 3ff5432..c6aea17 100644
--- a/net/proxy/proxy_server.cc
+++ b/net/proxy/proxy_server.cc
@@ -182,7 +182,7 @@ int ProxyServer::GetDefaultPortForScheme(Scheme scheme) {
       return -1;
   }
 }
-  
+
 // static
 ProxyServer ProxyServer::FromSchemeHostAndPort(
     Scheme scheme,
diff --git a/net/proxy/proxy_server.h b/net/proxy/proxy_server.h
index 45db1fc..6c3354d 100644
--- a/net/proxy/proxy_server.h
+++ b/net/proxy/proxy_server.h
@@ -98,7 +98,7 @@ class ProxyServer {
 
   // Format as a PAC result entry. This does the reverse of FromPacString().
   std::string ToPacString() const;
-  
+
   // Returns the default port number for a proxy server with the specified
   // scheme. Returns -1 if unknown.
   static int GetDefaultPortForScheme(Scheme scheme);
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index 443a46b..ed6fa97 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -398,7 +398,7 @@ void ProxyService::ProcessPendingRequests(PacRequest* recent_req) {
     // For auto-detect we use the well known WPAD url.
     GURL pac_url = config_.auto_detect ?
         GURL("http://wpad/wpad.dat") : config_.pac_url;
-    
+
     in_progress_fetch_config_id_ = config_.id();
 
     proxy_script_fetcher_->Fetch(
diff --git a/net/proxy/proxy_service.h b/net/proxy/proxy_service.h
index cb1fc91..81859d8 100644
--- a/net/proxy/proxy_service.h
+++ b/net/proxy/proxy_service.h
@@ -134,7 +134,7 @@ class ProxyService {
 
   // Callback for when the PAC script has finished downloading.
   void OnScriptFetchCompletion(int result);
-  
+
   // Returns ERR_IO_PENDING if the request cannot be completed synchronously.
   // Otherwise it fills |result| with the proxy information for |url|.
   // Completing synchronously means we don't need to query ProxyResolver.
diff --git a/net/tools/crash_cache/crash_cache.cc b/net/tools/crash_cache/crash_cache.cc
index 9d6f3d6..00b0248 100644
--- a/net/tools/crash_cache/crash_cache.cc
+++ b/net/tools/crash_cache/crash_cache.cc
@@ -285,7 +285,7 @@ int SlaveCode(const std::wstring& path, RankCrashes action) {
 
 int main(int argc, const char* argv[]) {
   // Setup an AtExitManager so Singleton objects will be destructed.
-  base::AtExitManager at_exit_manager; 
+  base::AtExitManager at_exit_manager;
 
   if (argc < 2)
     return MasterCode();
diff --git a/net/tools/testserver/testserver.py b/net/tools/testserver/testserver.py
index acbfd67..d0e7927 100644
--- a/net/tools/testserver/testserver.py
+++ b/net/tools/testserver/testserver.py
@@ -27,7 +27,7 @@ import tlslite
 import tlslite.api
 import pyftpdlib.ftpserver
 
-SERVER_HTTP = 0 
+SERVER_HTTP = 0
 SERVER_FTP = 1
 
 debug_output = sys.stderr
@@ -410,11 +410,11 @@ class TestPageHandler(BaseHTTPServer.BaseHTTPRequestHandler):
   def WriteFile(self):
     """This is handler dumps the content of POST request to a disk file into
     the data_dir/dump. Sub-directories are not supported."""
-    
+
     prefix='/writefile/'
     if not self.path.startswith(prefix):
       return False
-    
+
     file_name = self.path[len(prefix):]
 
     # do not allow fancy chars in file name
@@ -426,13 +426,13 @@ class TestPageHandler(BaseHTTPServer.BaseHTTPRequestHandler):
       f = open(path, "wb")
       f.write(request);
       f.close()
-      
+
     self.send_response(200)
     self.send_header('Content-type', 'text/html')
     self.end_headers()
     self.wfile.write('<html>%s</html>' % file_name)
     return True
-    
+
   def EchoTitleHandler(self):
     """This handler is like Echo, but sets the page title to the request."""
 
@@ -1013,7 +1013,7 @@ def main(options, args):
 
     server.data_dir = MakeDataDir()
     MakeDumpDir(server.data_dir)
-    
+
   # means FTP Server
   else:
     my_data_dir = MakeDataDir()
@@ -1069,4 +1069,4 @@ if __name__ == '__main__':
   options, args = option_parser.parse_args()
 
   sys.exit(main(options, args))
-  
+
diff --git a/net/url_request/url_request_job.h b/net/url_request/url_request_job.h
index 38ab199..fae5a1b 100644
--- a/net/url_request/url_request_job.h
+++ b/net/url_request/url_request_job.h
@@ -285,7 +285,7 @@ class URLRequestJob : public base::RefCountedThreadSafe<URLRequestJob> {
 
   // The data stream filter which is enabled on demand.
   scoped_ptr<Filter> filter_;
-  
+
   // If the filter filled its output buffer, then there is a change that it
   // still has internal data to emit, and this flag is set.
   bool filter_needs_more_output_space_;
diff --git a/net/url_request/url_request_job_manager.cc b/net/url_request/url_request_job_manager.cc
index 3dd7929..a0198b8 100644
--- a/net/url_request/url_request_job_manager.cc
+++ b/net/url_request/url_request_job_manager.cc
@@ -27,7 +27,7 @@ struct SchemeToFactory {
   const char* scheme;
   URLRequest::ProtocolFactory* factory;
 };
-  
+
 }  // namespace
 
 static const SchemeToFactory kBuiltinFactories[] = {
diff --git a/net/url_request/url_request_job_tracker.h b/net/url_request/url_request_job_tracker.h
index ce276a8..7c506e7 100644
--- a/net/url_request/url_request_job_tracker.h
+++ b/net/url_request/url_request_job_tracker.h
@@ -46,7 +46,7 @@ class URLRequestJobTracker {
     // Called when a new chunk of bytes has been read for the given job. The
     // byte count is the number of bytes for that read event only.
     virtual void OnBytesRead(URLRequestJob* job, int byte_count) = 0;
-    
+
     virtual ~JobObserver() {}
   };