Clang format slam.

net/tools/dump_cache/cache_dumper.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/tools/dump_cache/cache_dumper.h"
 
 #include "base/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/tools/dump_cache/url_to_filename_encoder.h"
 
-CacheDumper::CacheDumper(disk_cache::Backend* cache)
-    : cache_(cache) {
+CacheDumper::CacheDumper(disk_cache::Backend* cache) : cache_(cache) {
 }
 
 int CacheDumper::CreateEntry(const std::string& key,
                              disk_cache::Entry** entry,
                              const net::CompletionCallback& callback) {
   return cache_->CreateEntry(key, entry, callback);
 }
 
-int CacheDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset,
-                            net::IOBuffer* buf, int buf_len,
+int CacheDumper::WriteEntry(disk_cache::Entry* entry,
+                            int index,
+                            int offset,
+                            net::IOBuffer* buf,
+                            int buf_len,
                             const net::CompletionCallback& callback) {
   return entry->WriteData(index, offset, buf, buf_len, callback, false);
 }
 
-void CacheDumper::CloseEntry(disk_cache::Entry* entry, base::Time last_used,
+void CacheDumper::CloseEntry(disk_cache::Entry* entry,
+                             base::Time last_used,
                              base::Time last_modified) {
   if (entry) {
-    static_cast<disk_cache::EntryImpl*>(entry)->SetTimes(last_used,
-                                                         last_modified);
+    static_cast<disk_cache::EntryImpl*>(entry)
+        ->SetTimes(last_used, last_modified);
     entry->Close();
   }
 }
 
 // A version of CreateDirectory which supports lengthy filenames.
 // Returns true on success, false on failure.
 bool SafeCreateDirectory(const base::FilePath& path) {
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   // Due to large paths on windows, it can't simply do a
   // CreateDirectory("a/b/c").  Instead, create each subdirectory manually.
@@ skipping 14 matching lines @@
     // we keep going even if directory creation failed.
     pos++;
   }
   // Now create the full path
   return CreateDirectoryW(path.value().c_str(), NULL) == TRUE;
 #else
   return base::CreateDirectory(path);
 #endif
 }
 
-DiskDumper::DiskDumper(const base::FilePath& path)
-    : path_(path), entry_(NULL) {
+DiskDumper::DiskDumper(const base::FilePath& path) : path_(path), entry_(NULL) {
   base::CreateDirectory(path);
 }
 
 int DiskDumper::CreateEntry(const std::string& key,
                             disk_cache::Entry** entry,
                             const net::CompletionCallback& callback) {
   // The URL may not start with a valid protocol; search for it.
   int urlpos = key.find("http");
   std::string url = urlpos > 0 ? key.substr(urlpos) : key;
   std::string base_path = path_.MaybeAsASCII();
@@ skipping 11 matching lines @@
   name.append(entry_path_.value());
   entry_path_ = base::FilePath(name);
 #endif
 
   entry_url_ = key;
 
   SafeCreateDirectory(entry_path_.DirName());
 
   base::FilePath::StringType file = entry_path_.value();
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
-  entry_ = CreateFileW(file.c_str(), GENERIC_WRITE|GENERIC_READ, 0, 0,
-                       CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+  entry_ = CreateFileW(file.c_str(),
+                       GENERIC_WRITE | GENERIC_READ,
+                       0,
+                       0,
+                       CREATE_ALWAYS,
+                       FILE_ATTRIBUTE_NORMAL,
+                       0);
   if (entry_ == INVALID_HANDLE_VALUE)
     wprintf(L"CreateFileW (%s) failed: %d\n", file.c_str(), GetLastError());
   return (entry_ != INVALID_HANDLE_VALUE) ? net::OK : net::ERR_FAILED;
 #else
   entry_ = base::OpenFile(entry_path_, "w+");
   return (entry_ != NULL) ? net::OK : net::ERR_FAILED;
 #endif
 }
 
 // Utility Function to create a normalized header string from a
@@ skipping 29 matching lines @@
     output->append(name);
     output->append(": ");
     output->append(value);
     output->append("\r\n");
   }
 
   // Mark the end of headers
   output->append("\r\n");
 }
 
-int DiskDumper::WriteEntry(disk_cache::Entry* entry, int index, int offset,
-                           net::IOBuffer* buf, int buf_len,
+int DiskDumper::WriteEntry(disk_cache::Entry* entry,
+                           int index,
+                           int offset,
+                           net::IOBuffer* buf,
+                           int buf_len,
                            const net::CompletionCallback& callback) {
   if (!entry_)
     return 0;
 
   std::string headers;
-  const char *data;
+  const char* data;
   size_t len;
   if (index == 0) {  // Stream 0 is the headers.
     net::HttpResponseInfo response_info;
     bool truncated;
-    if (!net::HttpCache::ParseResponseInfo(buf->data(), buf_len,
-                                           &response_info, &truncated))
+    if (!net::HttpCache::ParseResponseInfo(
+            buf->data(), buf_len, &response_info, &truncated))
       return 0;
 
     // Skip this entry if it was truncated (results in an empty file).
     if (truncated)
       return buf_len;
 
     // Remove the size headers.
     response_info.headers->RemoveHeader("transfer-encoding");
     response_info.headers->RemoveHeader("content-length");
     response_info.headers->RemoveHeader("x-original-url");
@@ skipping 26 matching lines @@
   DWORD bytes;
   if (!WriteFile(entry_, data, len, &bytes, 0))
     return 0;
 
   return bytes;
 #else
   return fwrite(data, 1, len, entry_);
 #endif
 }
 
-void DiskDumper::CloseEntry(disk_cache::Entry* entry, base::Time last_used,
-                          base::Time last_modified) {
+void DiskDumper::CloseEntry(disk_cache::Entry* entry,
+                            base::Time last_used,
+                            base::Time last_modified) {
 #ifdef WIN32_LARGE_FILENAME_SUPPORT
   CloseHandle(entry_);
 #else
   base::CloseFile(entry_);
 #endif
 }