Clang format slam.

net/http/partial_data.h

 // Copyright (c) 2011 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.
 
 #ifndef NET_HTTP_PARTIAL_DATA_H_
 #define NET_HTTP_PARTIAL_DATA_H_
 
 #include "base/basictypes.h"
 #include "net/base/completion_callback.h"
 #include "net/http/http_byte_range.h"
@@ skipping 54 matching lines @@
   bool IsCurrentRangeCached() const;
 
   // Returns true if the current range is the last one needed to fulfill the
   // user's request.
   bool IsLastRange() const;
 
   // Extracts info from headers already stored in the cache. Returns false if
   // there is any problem with the headers. |truncated| should be true if we
   // have an incomplete 200 entry.
   bool UpdateFromStoredHeaders(const HttpResponseHeaders* headers,
-                               disk_cache::Entry* entry, bool truncated);
+                               disk_cache::Entry* entry,
+                               bool truncated);
 
   // Sets the byte current range to start again at zero (for a truncated entry).
   void SetRangeToStartDownload();
 
   // Returns true if the requested range is valid given the stored data.
   bool IsRequestedRangeOK();
 
   // Returns true if the response headers match what we expect, false otherwise.
   bool ResponseHeadersOK(const HttpResponseHeaders* headers);
 
   // Fixes the response headers to include the right content length and range.
   // |success| is the result of the whole request so if it's false, we'll change
   // the result code to be 416.
   void FixResponseHeaders(HttpResponseHeaders* headers, bool success);
 
   // Fixes the content length that we want to store in the cache.
   void FixContentLength(HttpResponseHeaders* headers);
 
   // Reads up to |data_len| bytes from the cache and stores them in the provided
   // buffer (|data|). Basically, this is just a wrapper around the API of the
   // cache that provides the right arguments for the current range. When the IO
   // operation completes, OnCacheReadCompleted() must be called with the result
   // of the operation.
-  int CacheRead(disk_cache::Entry* entry, IOBuffer* data, int data_len,
+  int CacheRead(disk_cache::Entry* entry,
+                IOBuffer* data,
+                int data_len,
                 const net::CompletionCallback& callback);
 
   // Writes |data_len| bytes to cache. This is basically a wrapper around the
   // API of the cache that provides the right arguments for the current range.
-  int CacheWrite(disk_cache::Entry* entry, IOBuffer* data, int data_len,
+  int CacheWrite(disk_cache::Entry* entry,
+                 IOBuffer* data,
+                 int data_len,
                  const net::CompletionCallback& callback);
 
   // This method should be called when CacheRead() finishes the read, to update
   // the internal state about the current range.
   void OnCacheReadCompleted(int result);
 
   // This method should be called after receiving data from the network, to
   // update the internal state about the current range.
   void OnNetworkReadCompleted(int result);
 
@@ skipping 10 matching lines @@
   int64 current_range_start_;
   int64 cached_start_;
   int64 resource_size_;
   int cached_min_len_;
   HttpByteRange byte_range_;  // The range requested by the user.
   // The clean set of extra headers (no ranges).
   HttpRequestHeaders extra_headers_;
   bool range_present_;  // True if next range entry is already stored.
   bool final_range_;
   bool sparse_entry_;
-  bool truncated_;  // We have an incomplete 200 stored.
+  bool truncated_;           // We have an incomplete 200 stored.
   bool initial_validation_;  // Only used for truncated entries.
   Core* core_;
   CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PartialData);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_PARTIAL_DATA_H_