Clang format slam.

net/http/http_cache_transaction.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 69 matching lines @@
 
   // A network request was required for a cache entry, it failed with an
   // offline error, and we could serve stale data if
   // LOAD_FROM_CACHE_IF_OFFLINE was set.
   OFFLINE_STATUS_DATA_AVAILABLE_OFFLINE,
 
   // A network request was required for a cache entry, it failed with
   // an offline error, and there was no servable data in cache (even
   // stale data).
   OFFLINE_STATUS_DATA_UNAVAILABLE_OFFLINE,
-
   OFFLINE_STATUS_MAX_ENTRIES
 };
 
 void RecordOfflineStatus(int load_flags, RequestOfflineStatus status) {
   // Restrict to main frame to keep statistics close to
   // "would have shown them something useful if offline mode was enabled".
   if (load_flags & net::LOAD_MAIN_FRAME) {
-    UMA_HISTOGRAM_ENUMERATION("HttpCache.OfflineStatus", status,
-                              OFFLINE_STATUS_MAX_ENTRIES);
+    UMA_HISTOGRAM_ENUMERATION(
+        "HttpCache.OfflineStatus", status, OFFLINE_STATUS_MAX_ENTRIES);
   }
 }
 
 // TODO(rvargas): Remove once we get the data.
 void RecordVaryHeaderHistogram(const net::HttpResponseInfo* response) {
-  enum VaryType {
-    VARY_NOT_PRESENT,
-    VARY_UA,
-    VARY_OTHER,
-    VARY_MAX
-  };
+  enum VaryType { VARY_NOT_PRESENT, VARY_UA, VARY_OTHER, VARY_MAX };
   VaryType vary = VARY_NOT_PRESENT;
   if (response->vary_data.is_valid()) {
     vary = VARY_OTHER;
     if (response->headers->HasHeaderValue("vary", "user-agent"))
       vary = VARY_UA;
   }
   UMA_HISTOGRAM_ENUMERATION("HttpCache.Vary", vary, VARY_MAX);
 }
 
 }  // namespace
 
 namespace net {
 
 struct HeaderNameAndValue {
   const char* name;
   const char* value;
 };
 
 // If the request includes one of these request headers, then avoid caching
 // to avoid getting confused.
 static const HeaderNameAndValue kPassThroughHeaders[] = {
-  { "if-unmodified-since", NULL },  // causes unexpected 412s
-  { "if-match", NULL },             // causes unexpected 412s
-  { "if-range", NULL },
-  { NULL, NULL }
-};
+    {"if-unmodified-since", NULL},  // causes unexpected 412s
+    {"if-match", NULL},             // causes unexpected 412s
+    {"if-range", NULL},
+    {NULL, NULL}};
 
 struct ValidationHeaderInfo {
   const char* request_header_name;
   const char* related_response_header_name;
 };
 
 static const ValidationHeaderInfo kValidationHeaders[] = {
-  { "if-modified-since", "last-modified" },
-  { "if-none-match", "etag" },
+    {"if-modified-since", "last-modified"},
+    {"if-none-match", "etag"},
 };
 
 // If the request includes one of these request headers, then avoid reusing
 // our cached copy if any.
 static const HeaderNameAndValue kForceFetchHeaders[] = {
-  { "cache-control", "no-cache" },
-  { "pragma", "no-cache" },
-  { NULL, NULL }
-};
+    {"cache-control", "no-cache"},
+    {"pragma", "no-cache"},
+    {NULL, NULL}};
 
 // If the request includes one of these request headers, then force our
 // cached copy (if any) to be revalidated before reusing it.
 static const HeaderNameAndValue kForceValidateHeaders[] = {
-  { "cache-control", "max-age=0" },
-  { NULL, NULL }
-};
+    {"cache-control", "max-age=0"},
+    {NULL, NULL}};
 
 static bool HeaderMatches(const HttpRequestHeaders& headers,
                           const HeaderNameAndValue* search) {
   for (; search->name; ++search) {
     std::string header_value;
     if (!headers.GetHeader(search->name, &header_value))
       continue;
 
     if (!search->value)
       return true;
 
     HttpUtil::ValuesIterator v(header_value.begin(), header_value.end(), ',');
     while (v.GetNext()) {
       if (LowerCaseEqualsASCII(v.value_begin(), v.value_end(), search->value))
         return true;
     }
   }
   return false;
 }
 
 //-----------------------------------------------------------------------------
 
-HttpCache::Transaction::Transaction(
-    RequestPriority priority,
-    HttpCache* cache)
+HttpCache::Transaction::Transaction(RequestPriority priority, HttpCache* cache)
     : next_state_(STATE_NONE),
       request_(NULL),
       priority_(priority),
       cache_(cache->AsWeakPtr()),
       entry_(NULL),
       new_entry_(NULL),
       new_response_(NULL),
       mode_(NONE),
       target_state_(STATE_NONE),
       reading_(false),
       invalid_range_(false),
       truncated_(false),
       is_sparse_(false),
       range_requested_(false),
       handling_206_(false),
       cache_pending_(false),
       done_reading_(false),
       vary_mismatch_(false),
       couldnt_conditionalize_request_(false),
       io_buf_len_(0),
       read_offset_(0),
       effective_load_flags_(0),
       write_len_(0),
       weak_factory_(this),
-      io_callback_(base::Bind(&Transaction::OnIOComplete,
-                              weak_factory_.GetWeakPtr())),
+      io_callback_(
+          base::Bind(&Transaction::OnIOComplete, weak_factory_.GetWeakPtr())),
       transaction_pattern_(PATTERN_UNDEFINED),
       total_received_bytes_(0),
       websocket_handshake_stream_base_create_helper_(NULL) {
   COMPILE_ASSERT(HttpCache::Transaction::kNumValidationHeaders ==
-                 arraysize(kValidationHeaders),
+                     arraysize(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_.Reset();
 
   if (cache_) {
     if (entry_) {
       bool cancel_request = reading_ && response_.headers;
       if (cancel_request) {
         if (partial_) {
           entry_->disk_entry->CancelSparseIO();
         } else {
           cancel_request &= (response_.headers->response_code() == 200);
         }
       }
 
       cache_->DoneWithEntry(entry_, this, cancel_request);
     } else if (cache_pending_) {
       cache_->RemovePendingTransaction(this);
     }
   }
 }
 
-int HttpCache::Transaction::WriteMetadata(IOBuffer* buf, int buf_len,
+int HttpCache::Transaction::WriteMetadata(IOBuffer* buf,
+                                          int buf_len,
                                           const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
   DCHECK(!callback.is_null());
   if (!cache_.get() || !entry_)
     return ERR_UNEXPECTED;
 
   // We don't need to track this operation for anything.
   // It could be possible to check if there is something already written and
   // avoid writing again (it should be the same, right?), but let's allow the
   // caller to "update" the contents with something new.
-  return entry_->disk_entry->WriteData(kMetadataIndex, 0, buf, buf_len,
-                                       callback, true);
+  return entry_->disk_entry->WriteData(
+      kMetadataIndex, 0, buf, buf_len, callback, true);
 }
 
 bool HttpCache::Transaction::AddTruncatedFlag() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
   // Don't set the flag for sparse entries.
   if (partial_.get() && !truncated_)
     return true;
 
   if (!CanResume(true))
@@ skipping 110 matching lines @@
 
   return rv;
 }
 
 bool HttpCache::Transaction::IsReadyToRestartForAuth() {
   if (!network_trans_.get())
     return false;
   return network_trans_->IsReadyToRestartForAuth();
 }
 
-int HttpCache::Transaction::Read(IOBuffer* buf, int buf_len,
+int HttpCache::Transaction::Read(IOBuffer* buf,
+                                 int buf_len,
                                  const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
   DCHECK(!callback.is_null());
 
   DCHECK(callback_.is_null());
 
   if (!cache_.get())
     return ERR_UNEXPECTED;
 
@@ skipping 108 matching lines @@
   return LOAD_STATE_IDLE;
 }
 
 UploadProgress HttpCache::Transaction::GetUploadProgress() const {
   if (network_trans_.get())
     return network_trans_->GetUploadProgress();
   return final_upload_progress_;
 }
 
 void HttpCache::Transaction::SetQuicServerInfo(
-    QuicServerInfo* quic_server_info) {}
+    QuicServerInfo* quic_server_info) {
+}
 
 bool HttpCache::Transaction::GetLoadTimingInfo(
     LoadTimingInfo* load_timing_info) const {
   if (network_trans_)
     return network_trans_->GetLoadTimingInfo(load_timing_info);
 
   if (old_network_trans_load_timing_) {
     *load_timing_info = *old_network_trans_load_timing_;
     return true;
   }
@@ skipping 344 matching lines @@
   return OK;
 }
 
 int HttpCache::Transaction::DoSendRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(!network_trans_.get());
 
   send_request_since_ = TimeTicks::Now();
 
   // Create a network transaction.
-  int rv = cache_->network_layer_->CreateTransaction(priority_,
-                                                     &network_trans_);
+  int rv =
+      cache_->network_layer_->CreateTransaction(priority_, &network_trans_);
   if (rv != OK)
     return rv;
   network_trans_->SetBeforeNetworkStartCallback(before_network_start_callback_);
 
   // Old load timing information, if any, is now obsolete.
   old_network_trans_load_timing_.reset();
 
   if (websocket_handshake_stream_base_create_helper_)
     network_trans_->SetWebSocketHandshakeStreamCreateHelper(
         websocket_handshake_stream_base_create_helper_);
@@ skipping 18 matching lines @@
         UpdateTransactionPattern(PATTERN_NOT_COVERED);
         response_.server_data_unavailable = true;
         return SetupEntryForRead();
       }
     } else {
       RecordOfflineStatus(effective_load_flags_,
                           OFFLINE_STATUS_DATA_UNAVAILABLE_OFFLINE);
     }
   } else {
     RecordOfflineStatus(effective_load_flags_,
-                        (result == OK ? OFFLINE_STATUS_NETWORK_SUCCEEDED :
-                                        OFFLINE_STATUS_NETWORK_FAILED));
+                        (result == OK ? OFFLINE_STATUS_NETWORK_SUCCEEDED
+                                      : OFFLINE_STATUS_NETWORK_FAILED));
   }
 
   // If we tried to conditionalize the request and failed, we know
   // we won't be reading from the cache after this point.
   if (couldnt_conditionalize_request_)
     mode_ = WRITE;
 
   if (result == OK) {
     next_state_ = STATE_SUCCESSFUL_SEND_REQUEST;
     return OK;
@@ skipping 419 matching lines @@
   if (handling_206_ && !CanResume(false)) {
     // There is no point in storing this resource because it will never be used.
     DoneWritingToEntry(false);
     if (partial_.get())
       partial_->FixResponseHeaders(response_.headers.get(), true);
     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
     return OK;
   }
 
   target_state_ = STATE_TRUNCATE_CACHED_DATA;
-  next_state_ = truncated_ ? STATE_CACHE_WRITE_TRUNCATED_RESPONSE :
-                             STATE_CACHE_WRITE_RESPONSE;
+  next_state_ = truncated_ ? STATE_CACHE_WRITE_TRUNCATED_RESPONSE
+                           : STATE_CACHE_WRITE_RESPONSE;
   return OK;
 }
 
 int HttpCache::Transaction::DoTruncateCachedData() {
   next_state_ = STATE_TRUNCATE_CACHED_DATA_COMPLETE;
   if (!entry_)
     return OK;
   if (net_log_.IsLogging())
     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_DATA);
   // Truncate the stream.
@@ skipping 58 matching lines @@
 }
 
 int HttpCache::Transaction::DoCacheReadResponse() {
   DCHECK(entry_);
   next_state_ = STATE_CACHE_READ_RESPONSE_COMPLETE;
 
   io_buf_len_ = entry_->disk_entry->GetDataSize(kResponseInfoIndex);
   read_buf_ = new IOBuffer(io_buf_len_);
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
-  return entry_->disk_entry->ReadData(kResponseInfoIndex, 0, read_buf_.get(),
-                                      io_buf_len_, io_callback_);
+  return entry_->disk_entry->ReadData(
+      kResponseInfoIndex, 0, read_buf_.get(), io_buf_len_, io_callback_);
 }
 
 int HttpCache::Transaction::DoCacheReadResponseComplete(int result) {
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
   if (result != io_buf_len_ ||
-      !HttpCache::ParseResponseInfo(read_buf_->data(), io_buf_len_,
-                                    &response_, &truncated_)) {
+      !HttpCache::ParseResponseInfo(
+          read_buf_->data(), io_buf_len_, &response_, &truncated_)) {
     return OnCacheReadError(result, true);
   }
 
   // Some resources may have slipped in as truncated when they're not.
   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
   if (response_.headers->GetContentLength() == current_size)
     truncated_ = false;
 
   // We now have access to the cache entry.
   //
@@ skipping 63 matching lines @@
 
 int HttpCache::Transaction::DoCacheReadMetadata() {
   DCHECK(entry_);
   DCHECK(!response_.metadata.get());
   next_state_ = STATE_CACHE_READ_METADATA_COMPLETE;
 
   response_.metadata =
       new IOBufferWithSize(entry_->disk_entry->GetDataSize(kMetadataIndex));
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
-  return entry_->disk_entry->ReadData(kMetadataIndex, 0,
+  return entry_->disk_entry->ReadData(kMetadataIndex,
+                                      0,
                                       response_.metadata.get(),
                                       response_.metadata->size(),
                                       io_callback_);
 }
 
 int HttpCache::Transaction::DoCacheReadMetadataComplete(int result) {
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
   if (result != response_.metadata->size())
     return OnCacheReadError(result, false);
   return OK;
@@ skipping 18 matching lines @@
   return ValidateEntryHeadersAndContinue();
 }
 
 int HttpCache::Transaction::DoCacheReadData() {
   DCHECK(entry_);
   next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
 
   if (net_log_.IsLogging())
     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_DATA);
   if (partial_.get()) {
-    return partial_->CacheRead(entry_->disk_entry, read_buf_.get(), io_buf_len_,
-                               io_callback_);
+    return partial_->CacheRead(
+        entry_->disk_entry, read_buf_.get(), io_buf_len_, io_callback_);
   }
 
-  return entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
-                                      read_buf_.get(), io_buf_len_,
+  return entry_->disk_entry->ReadData(kResponseContentIndex,
+                                      read_offset_,
+                                      read_buf_.get(),
+                                      io_buf_len_,
                                       io_callback_);
 }
 
 int HttpCache::Transaction::DoCacheReadDataComplete(int result) {
   if (net_log_.IsLogging()) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_DATA,
                                       result);
   }
 
   if (!cache_.get())
@@ skipping 105 matching lines @@
   //   LOAD_BYPASS_CACHE    : no cache read
   //   LOAD_VALIDATE_CACHE  : no cache read unless validation
   //
   // The former modes trump latter modes, so if we find a matching header we
   // can stop iterating kSpecialHeaders.
   //
   static const struct {
     const HeaderNameAndValue* search;
     int load_flag;
   } kSpecialHeaders[] = {
-    { kPassThroughHeaders, LOAD_DISABLE_CACHE },
-    { kForceFetchHeaders, LOAD_BYPASS_CACHE },
-    { kForceValidateHeaders, LOAD_VALIDATE_CACHE },
-  };
+        {kPassThroughHeaders, LOAD_DISABLE_CACHE},
+        {kForceFetchHeaders, LOAD_BYPASS_CACHE},
+        {kForceValidateHeaders, LOAD_VALIDATE_CACHE},
+    };
 
   bool range_found = false;
   bool external_validation_error = false;
 
   if (request_->extra_headers.HasHeader(HttpRequestHeaders::kRange))
     range_found = true;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSpecialHeaders); ++i) {
     if (HeaderMatches(request_->extra_headers, kSpecialHeaders[i].search)) {
       effective_load_flags_ |= kSpecialHeaders[i].load_flag;
       break;
     }
   }
 
   // Check for conditionalization headers which may correspond with a
   // cache validation request.
   for (size_t i = 0; i < arraysize(kValidationHeaders); ++i) {
     const ValidationHeaderInfo& info = kValidationHeaders[i];
     std::string validation_value;
-    if (request_->extra_headers.GetHeader(
-            info.request_header_name, &validation_value)) {
-      if (!external_validation_.values[i].empty() ||
-          validation_value.empty()) {
+    if (request_->extra_headers.GetHeader(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;
     }
   }
 
   // We don't support ranges and validation headers.
   if (range_found && external_validation_.initialized) {
     LOG(WARNING) << "Byte ranges AND validation headers found.";
@@ skipping 163 matching lines @@
   }
 
   next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
   return OK;
 }
 
 int HttpCache::Transaction::BeginExternallyConditionalizedRequest() {
   DCHECK_EQ(UPDATE, mode_);
   DCHECK(external_validation_.initialized);
 
-  for (size_t i = 0;  i < arraysize(kValidationHeaders); i++) {
+  for (size_t i = 0; i < arraysize(kValidationHeaders); i++) {
     if (external_validation_.values[i].empty())
       continue;
     // Retrieve either the cached response's "etag" or "last-modified" header.
     std::string validator;
     response_.headers->EnumerateHeader(
-        NULL,
-        kValidationHeaders[i].related_response_header_name,
-        &validator);
+        NULL, kValidationHeaders[i].related_response_header_name, &validator);
 
     if (response_.headers->response_code() != 200 || truncated_ ||
         validator.empty() || validator != external_validation_.values[i]) {
       // The externally conditionalized request is not a validation request
       // for our existing cache entry. Proceed with caching disabled.
       UpdateTransactionPattern(PATTERN_NOT_COVERED);
       DoneWritingToEntry(true);
     }
   }
 
@@ skipping 90 matching lines @@
 
   // Just use the first available ETag and/or Last-Modified header value.
   // TODO(darin): Or should we use the last?
 
   std::string etag_value;
   if (response_.headers->GetHttpVersion() >= HttpVersion(1, 1))
     response_.headers->EnumerateHeader(NULL, "etag", &etag_value);
 
   std::string last_modified_value;
   if (!vary_mismatch_) {
-    response_.headers->EnumerateHeader(NULL, "last-modified",
-                                       &last_modified_value);
+    response_.headers->EnumerateHeader(
+        NULL, "last-modified", &last_modified_value);
   }
 
   if (etag_value.empty() && last_modified_value.empty())
     return false;
 
   if (!partial_.get()) {
     // Need to customize the request, so this forces us to allocate :(
     custom_request_.reset(new HttpRequestInfo(*request_));
     request_ = custom_request_.get();
   }
   DCHECK(custom_request_.get());
 
-  bool use_if_range = partial_.get() && !partial_->IsCurrentRangeCached() &&
-                      !invalid_range_;
+  bool use_if_range =
+      partial_.get() && !partial_->IsCurrentRangeCached() && !invalid_range_;
 
   if (!etag_value.empty()) {
     if (use_if_range) {
       // We don't want to switch to WRITE mode if we don't have this block of a
       // byte-range request because we may have other parts cached.
-      custom_request_->extra_headers.SetHeader(
-          HttpRequestHeaders::kIfRange, etag_value);
+      custom_request_->extra_headers.SetHeader(HttpRequestHeaders::kIfRange,
+                                               etag_value);
     } else {
-      custom_request_->extra_headers.SetHeader(
-          HttpRequestHeaders::kIfNoneMatch, etag_value);
+      custom_request_->extra_headers.SetHeader(HttpRequestHeaders::kIfNoneMatch,
+                                               etag_value);
     }
     // For byte-range requests, make sure that we use only one way to validate
     // the request.
     if (partial_.get() && !partial_->IsCurrentRangeCached())
       return true;
   }
 
   if (!last_modified_value.empty()) {
     if (use_if_range) {
-      custom_request_->extra_headers.SetHeader(
-          HttpRequestHeaders::kIfRange, last_modified_value);
+      custom_request_->extra_headers.SetHeader(HttpRequestHeaders::kIfRange,
+                                               last_modified_value);
     } else {
       custom_request_->extra_headers.SetHeader(
           HttpRequestHeaders::kIfModifiedSince, last_modified_value);
     }
   }
 
   return true;
 }
 
 // We just received some headers from the server. We may have asked for a range,
@@ skipping 142 matching lines @@
     }
   }
   cache_->ConvertWriterToReader(entry_);
   mode_ = READ;
 
   if (entry_->disk_entry->GetDataSize(kMetadataIndex))
     next_state_ = STATE_CACHE_READ_METADATA;
   return OK;
 }
 
-
 int HttpCache::Transaction::ReadFromNetwork(IOBuffer* data, int data_len) {
   read_buf_ = data;
   io_buf_len_ = data_len;
   next_state_ = STATE_NETWORK_READ;
   return DoLoop(OK);
 }
 
 int HttpCache::Transaction::ReadFromEntry(IOBuffer* data, int data_len) {
   read_buf_ = data;
   io_buf_len_ = data_len;
   next_state_ = STATE_CACHE_READ_DATA;
   return DoLoop(OK);
 }
 
-int HttpCache::Transaction::WriteToEntry(int index, int offset,
-                                         IOBuffer* data, int data_len,
+int HttpCache::Transaction::WriteToEntry(int index,
+                                         int offset,
+                                         IOBuffer* data,
+                                         int data_len,
                                          const CompletionCallback& callback) {
   if (!entry_)
     return data_len;
 
   int rv = 0;
   if (!partial_.get() || !data_len) {
-    rv = entry_->disk_entry->WriteData(index, offset, data, data_len, callback,
-                                       true);
+    rv = entry_->disk_entry->WriteData(
+        index, offset, data, data_len, callback, true);
   } else {
     rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, callback);
   }
   return rv;
 }
 
 int HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) {
   next_state_ = STATE_CACHE_WRITE_RESPONSE_COMPLETE;
   if (!entry_)
     return OK;
@@ skipping 21 matching lines @@
   bool skip_transient_headers = (cache_->mode() != RECORD);
 
   if (truncated)
     DCHECK_EQ(200, response_.headers->response_code());
 
   scoped_refptr<PickledIOBuffer> data(new PickledIOBuffer());
   response_.Persist(data->pickle(), skip_transient_headers, truncated);
   data->Done();
 
   io_buf_len_ = data->pickle()->size();
-  return entry_->disk_entry->WriteData(kResponseInfoIndex, 0, data.get(),
-                                       io_buf_len_, io_callback_, true);
+  return entry_->disk_entry->WriteData(
+      kResponseInfoIndex, 0, data.get(), io_buf_len_, io_callback_, true);
 }
 
 int HttpCache::Transaction::AppendResponseDataToEntry(
-    IOBuffer* data, int data_len, const CompletionCallback& callback) {
+    IOBuffer* data,
+    int data_len,
+    const CompletionCallback& callback) {
   if (!entry_ || !data_len)
     return data_len;
 
   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
-  return WriteToEntry(kResponseContentIndex, current_size, data, data_len,
-                      callback);
+  return WriteToEntry(
+      kResponseContentIndex, current_size, data, data_len, callback);
 }
 
 void HttpCache::Transaction::DoneWritingToEntry(bool success) {
   if (!entry_)
     return;
 
   RecordHistograms();
 
   cache_->DoneWritingToEntry(entry_, success);
   entry_ = NULL;
@@ skipping 136 matching lines @@
   if (transaction_pattern_ == PATTERN_NOT_COVERED)
     return;
   DCHECK(!range_requested_);
   DCHECK(!first_cache_access_since_.is_null());
 
   TimeDelta total_time = base::TimeTicks::Now() - first_cache_access_since_;
 
   UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone", total_time);
 
   bool did_send_request = !send_request_since_.is_null();
-  DCHECK(
-      (did_send_request &&
-       (transaction_pattern_ == PATTERN_ENTRY_NOT_CACHED ||
-        transaction_pattern_ == PATTERN_ENTRY_VALIDATED ||
-        transaction_pattern_ == PATTERN_ENTRY_UPDATED ||
-        transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE)) ||
-      (!did_send_request && transaction_pattern_ == PATTERN_ENTRY_USED));
+  DCHECK((did_send_request &&
+          (transaction_pattern_ == PATTERN_ENTRY_NOT_CACHED ||
+           transaction_pattern_ == PATTERN_ENTRY_VALIDATED ||
+           transaction_pattern_ == PATTERN_ENTRY_UPDATED ||
+           transaction_pattern_ == PATTERN_ENTRY_CANT_CONDITIONALIZE)) ||
+         (!did_send_request && transaction_pattern_ == PATTERN_ENTRY_USED));
 
   if (!did_send_request) {
     DCHECK(transaction_pattern_ == PATTERN_ENTRY_USED);
     UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.Used", total_time);
     return;
   }
 
   TimeDelta before_send_time = send_request_since_ - first_cache_access_since_;
-  int before_send_percent =
-      total_time.ToInternalValue() == 0 ? 0
-                                        : before_send_time * 100 / total_time;
+  int before_send_percent = total_time.ToInternalValue() == 0
+                                ? 0
+                                : before_send_time * 100 / total_time;
   DCHECK_LE(0, before_send_percent);
   DCHECK_GE(100, before_send_percent);
 
   UMA_HISTOGRAM_TIMES("HttpCache.AccessToDone.SentRequest", total_time);
   UMA_HISTOGRAM_TIMES("HttpCache.BeforeSend", before_send_time);
   UMA_HISTOGRAM_PERCENTAGE("HttpCache.PercentBeforeSend", before_send_percent);
 
   // TODO(gavinp): Remove or minimize these histograms, particularly the ones
   // below this comment after we have received initial data.
   switch (transaction_pattern_) {
@@ skipping 25 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net