Auto-format style pass over files.

net/http/http_cache_transaction.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_transaction.h"
 
 #include "base/compiler_specific.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 96 matching lines @@
       truncated_(false),
       server_responded_206_(false),
       cache_pending_(false),
       read_offset_(0),
       effective_load_flags_(0),
       final_upload_progress_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &Transaction::OnIOComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           cache_callback_(new CancelableCompletionCallback<Transaction>(
-                this, &Transaction::OnIOComplete))),
+              this, &Transaction::OnIOComplete))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           write_headers_callback_(new CancelableCompletionCallback<Transaction>(
-                this, &Transaction::OnIOComplete))) {
+              this, &Transaction::OnIOComplete))) {
   COMPILE_ASSERT(HttpCache::Transaction::kNumValidationHeaders ==
-                     ARRAYSIZE_UNSAFE(kValidationHeaders),
+                 ARRAYSIZE_UNSAFE(kValidationHeaders),
                  Invalid_number_of_validation_headers);
 }
 
 HttpCache::Transaction::~Transaction() {
   // We may have to issue another IO, but we should never invoke the callback_
   // after this point.
   callback_ = NULL;
 
   if (cache_) {
     if (entry_) {
@@ skipping 762 matching lines @@
     return OK;
   }
 
   // We change the value of Content-Length for partial content.
   if (server_responded_206_ && partial_.get())
     partial_->FixContentLength(new_response_->headers);
 
   response_ = *new_response_;
   target_state_ = STATE_TRUNCATE_CACHED_DATA;
   next_state_ = truncated_ ? STATE_CACHE_WRITE_TRUNCATED_RESPONSE :
-                             STATE_CACHE_WRITE_RESPONSE;
+                STATE_CACHE_WRITE_RESPONSE;
   return OK;
 }
 
 int HttpCache::Transaction::DoTruncateCachedData() {
   next_state_ = STATE_TRUNCATE_CACHED_DATA_COMPLETE;
   if (!entry_)
     return OK;
 
   // Truncate the stream.
   int rv = WriteToEntry(kResponseContentIndex, 0, NULL, 0, NULL);
@@ skipping 199 matching lines @@
   cache_callback_->Release();
   if (!cache_)
     return ERR_UNEXPECTED;
 
   if (result < 0)
     return result;
 
   if (partial_.get()) {
     // This may be the last request.
     if (!(result == 0 && !truncated_ &&
-         (partial_->IsLastRange() || mode_ == WRITE)))
+          (partial_->IsLastRange() || mode_ == WRITE)))
       return DoPartialNetworkReadCompleted(result);
   }
 
   if (result == 0)  // End of file.
     DoneWritingToEntry(true);
 
   return result;
 }
 
 //-----------------------------------------------------------------------------
@@ skipping 58 matching lines @@
       break;
     }
   }
 
   // Check for conditionalization headers which may correspond with a
   // cache validation request.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kValidationHeaders); ++i) {
     const ValidationHeaderInfo& info = kValidationHeaders[i];
     std::string validation_value;
     if (request_->extra_headers.GetHeader(
-        info.request_header_name, &validation_value)) {
+            info.request_header_name, &validation_value)) {
       if (!external_validation_.values[i].empty() ||
           validation_value.empty())
         external_validation_error = true;
       external_validation_.values[i] = validation_value;
       external_validation_.initialized = true;
       break;
     }
   }
 
   // We don't support ranges and validation headers.
@@ skipping 230 matching lines @@
 
   if (response_.headers->response_code() == 206 && !enable_range_support_)
     return true;
 
   if (response_.headers->RequiresValidation(
           response_.request_time, response_.response_time, Time::Now()))
     return true;
 
   // Since Vary header computation is fairly expensive, we save it for last.
   if (response_.vary_data.is_valid() &&
-          !response_.vary_data.MatchesRequest(*request_, *response_.headers))
+      !response_.vary_data.MatchesRequest(*request_, *response_.headers))
     return true;
 
   return false;
 }
 
 bool HttpCache::Transaction::ConditionalizeRequest() {
   DCHECK(response_.headers);
 
   if (!enable_range_support_ && response_.headers->response_code() != 200) {
     // This only makes sense for cached 200 responses.
@@ skipping 209 matching lines @@
   // Do not cache no-store content (unless we are record mode).  Do not cache
   // content with cert errors either.  This is to prevent not reporting net
   // errors when loading a resource from the cache.  When we load a page over
   // HTTPS with a cert error we show an SSL blocking page.  If the user clicks
   // proceed we reload the resource ignoring the errors.  The loaded resource
   // is then cached.  If that resource is subsequently loaded from the cache,
   // no net error is reported (even though the cert status contains the actual
   // errors) and no SSL blocking page is shown.  An alternative would be to
   // reverse-map the cert status to a net error and replay the net error.
   if ((cache_->mode() != RECORD &&
-      response_.headers->HasHeaderValue("cache-control", "no-store")) ||
+       response_.headers->HasHeaderValue("cache-control", "no-store")) ||
       net::IsCertStatusError(response_.ssl_info.cert_status)) {
     DoneWritingToEntry(false);
     return OK;
   }
 
   // When writing headers, we normally only write the non-transient
   // headers; when in record mode, record everything.
   bool skip_transient_headers = (cache_->mode() != RECORD);
 
   if (truncated) {
@@ skipping 104 matching lines @@
   // |value| goes from 0 to 63. Actually, the max value should be 47 (0x2f)
   // but we'll see.
   UMA_HISTOGRAM_ENUMERATION("HttpCache.ResponseHeaders", value, 65);
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net