Auto-format style pass over files.

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
@@ skipping 282 matching lines @@
   };
 
   ~MockDiskEntry() {}
 
   // Unlike the callbacks for MockHttpTransaction, we want this one to run even
   // if the consumer called Close on the MockDiskEntry.  We achieve that by
   // leveraging the fact that this class is reference counted.
   void CallbackLater(net::CompletionCallback* callback, int result) {
     if (ignore_callbacks_)
       return StoreAndDeliverCallbacks(true, this, callback, result);
-    MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &MockDiskEntry::RunCallback, callback, result));
+    MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
+        this, &MockDiskEntry::RunCallback, callback, result));
   }
   void RunCallback(net::CompletionCallback* callback, int result) {
     if (busy_) {
       // This is kind of hacky, but controlling the behavior of just this entry
       // from a test is sort of complicated.  What we really want to do is
       // delay the delivery of a sparse IO operation a little more so that the
       // request start operation (async) will finish without seeing the end of
       // this operation (already posted to the message loop)... and without
       // just delaying for n mS (which may cause trouble with slow bots).  So
       // we re-post this operation (all async sparse IO operations will take two
@@ skipping 209 matching lines @@
 
   class CallbackRunner : public Task {
    public:
     CallbackRunner(net::CompletionCallback* callback, int result)
         : callback_(callback), result_(result) {}
     virtual void Run() {
       callback_->Run(result_);
     }
 
    private:
-     net::CompletionCallback* callback_;
+    net::CompletionCallback* callback_;
     int result_;
     DISALLOW_COPY_AND_ASSIGN(CallbackRunner);
   };
 
   void CallbackLater(net::CompletionCallback* callback, int result) {
     MessageLoop::current()->PostTask(FROM_HERE,
                                      new CallbackRunner(callback, result));
   }
 
   EntryMap entries_;
@@ skipping 199 matching lines @@
   EXPECT_TRUE(request->extra_headers.HasHeader(kExtraHeaderKey));
 
   if (not_modified_) {
     response_status->assign("HTTP/1.1 304 Not Modified");
     return;
   }
 
   std::vector<net::HttpByteRange> ranges;
   std::string range_header;
   if (!request->extra_headers.GetHeader(
-      net::HttpRequestHeaders::kRange, &range_header) ||
+          net::HttpRequestHeaders::kRange, &range_header) ||
       !net::HttpUtil::ParseRangeHeader(range_header, &ranges) ||
       ranges.size() != 1)
     return;
   // We can handle this range request.
   net::HttpByteRange byte_range = ranges[0];
   if (byte_range.first_byte_position() > 79) {
     response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
     return;
   }
 
@@ skipping 1373 matching lines @@
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"Foo2\"\n"
     "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
     "body2"
   };
 
   const char* kExtraRequestHeaders =
-    "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n"
-    "If-None-Match: \"Foo1\"\r\n";
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n"
+      "If-None-Match: \"Foo1\"\r\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse2, kExtraRequestHeaders);
 }
 
 // Test that doing an externally conditionalized request with both if-none-match
 // and if-modified-since does not update the cache with only one match.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache9) {
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
     "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
     "Etag: \"Foo1\"\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     "body1"
   };
 
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"Foo2\"\n"
     "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
     "body2"
   };
 
   // The etag doesn't match what we have stored.
   const char* kExtraRequestHeaders =
-    "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n"
-    "If-None-Match: \"Foo2\"\n";
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n"
+      "If-None-Match: \"Foo2\"\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
 }
 
 // Test that doing an externally conditionalized request with both if-none-match
 // and if-modified-since does not update the cache with only one match.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache10) {
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
     "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
     "Etag: \"Foo1\"\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     "body1"
   };
 
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"Foo2\"\n"
     "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
     "body2"
   };
 
   // The modification date doesn't match what we have stored.
   const char* kExtraRequestHeaders =
-    "If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\n"
-    "If-None-Match: \"Foo1\"\n";
+      "If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\n"
+      "If-None-Match: \"Foo1\"\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
 }
 
 // Test that doing an externally conditionalized request with two conflicting
 // headers does not update the cache.
 TEST(HttpCache, ConditionalizedRequestUpdatesCache11) {
   static const Response kNetResponse1 = {
     "HTTP/1.1 200 OK",
     "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
     "Etag: \"Foo1\"\n"
     "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
     "body1"
   };
 
   // Second network response for |kUrl|.
   static const Response kNetResponse2 = {
     "HTTP/1.1 200 OK",
     "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
     "Etag: \"Foo2\"\n"
     "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
     "body2"
   };
 
   // Two dates, the second matches what we have stored.
   const char* kExtraRequestHeaders =
-    "If-Modified-Since: Mon, 04 Feb 2008 22:38:21 GMT\n"
-    "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n";
+      "If-Modified-Since: Mon, 04 Feb 2008 22:38:21 GMT\n"
+      "If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\n";
 
   ConditionalizedRequestUpdatesCacheHelper(
       kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
 }
 
 TEST(HttpCache, UrlContainingHash) {
   MockHttpCache cache;
 
   // Do a typical GET request -- should write an entry into our cache.
   MockTransaction trans(kTypicalGET_Transaction);
@@ skipping 1631 matching lines @@
 
   // This test ensures that a read that completes synchronously does not cause
   // any problems.
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.test_mode |= (TEST_MODE_SYNC_CACHE_START |
                             TEST_MODE_SYNC_CACHE_READ |
                             TEST_MODE_SYNC_CACHE_WRITE);
 
   MockHttpRequest r1(transaction),
-                  r2(transaction),
-                  r3(transaction);
+      r2(transaction),
+      r3(transaction);
 
   TestTransactionConsumer c1(cache.http_cache()),
-                          c2(cache.http_cache()),
-                          c3(cache.http_cache());
+      c2(cache.http_cache()),
+      c3(cache.http_cache());
 
   c1.Start(&r1, net::BoundNetLog());
 
   r2.load_flags |= net::LOAD_ONLY_FROM_CACHE;
   c2.Start(&r2, net::BoundNetLog());
 
   r3.load_flags |= net::LOAD_ONLY_FROM_CACHE;
   c3.Start(&r3, net::BoundNetLog());
 
   MessageLoop::current()->Run();
@@ skipping 431 matching lines @@
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = net::LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }