Clang format slam.

net/tools/quic/quic_in_memory_cache.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/quic/quic_in_memory_cache.h"
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 14 matching lines @@
 
 namespace {
 
 // BalsaVisitor implementation (glue) which caches response bodies.
 class CachingBalsaVisitor : public NoOpBalsaVisitor {
  public:
   CachingBalsaVisitor() : done_framing_(false) {}
   virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {
     AppendToBody(input, size);
   }
-  virtual void MessageDone() OVERRIDE {
-    done_framing_ = true;
-  }
+  virtual void MessageDone() OVERRIDE { done_framing_ = true; }
   virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
   virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
   virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
   virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
-  void UnhandledError() {
-    LOG(DFATAL) << "Unhandled error framing HTTP.";
-  }
+  void UnhandledError() { LOG(DFATAL) << "Unhandled error framing HTTP."; }
   void AppendToBody(const char* input, size_t size) {
     body_.append(input, size);
   }
   bool done_framing() const { return done_framing_; }
   const string& body() const { return body_; }
 
  private:
   bool done_framing_;
   string body_;
 };
@@ skipping 14 matching lines @@
   return it->second;
 }
 
 void QuicInMemoryCache::AddSimpleResponse(StringPiece method,
                                           StringPiece path,
                                           StringPiece version,
                                           StringPiece response_code,
                                           StringPiece response_detail,
                                           StringPiece body) {
   BalsaHeaders request_headers, response_headers;
-  request_headers.SetRequestFirstlineFromStringPieces(method,
-                                                      path,
-                                                      version);
-  response_headers.SetRequestFirstlineFromStringPieces(version,
-                                                       response_code,
-                                                       response_detail);
+  request_headers.SetRequestFirstlineFromStringPieces(method, path, version);
+  response_headers.SetRequestFirstlineFromStringPieces(
+      version, response_code, response_detail);
   response_headers.AppendHeader("content-length",
                                 base::IntToString(body.length()));
 
   AddResponse(request_headers, response_headers, body);
 }
 
 void QuicInMemoryCache::AddResponse(const BalsaHeaders& request_headers,
                                     const BalsaHeaders& response_headers,
                                     StringPiece response_body) {
   VLOG(1) << "Adding response for: " << GetKey(request_headers);
   if (ContainsKey(responses_, GetKey(request_headers))) {
     LOG(DFATAL) << "Response for given request already exists!";
     return;
   }
   Response* new_response = new Response();
   new_response->set_headers(response_headers);
   new_response->set_body(response_body);
   responses_[GetKey(request_headers)] = new_response;
 }
 
 void QuicInMemoryCache::AddSpecialResponse(StringPiece method,
                                            StringPiece path,
                                            StringPiece version,
                                            SpecialResponseType response_type) {
   BalsaHeaders request_headers, response_headers;
-  request_headers.SetRequestFirstlineFromStringPieces(method,
-                                                      path,
-                                                      version);
+  request_headers.SetRequestFirstlineFromStringPieces(method, path, version);
   AddResponse(request_headers, response_headers, "");
   responses_[GetKey(request_headers)]->response_type_ = response_type;
 }
 
 QuicInMemoryCache::QuicInMemoryCache() {
   Initialize();
 }
 
 void QuicInMemoryCache::ResetForTests() {
   STLDeleteValues(&responses_);
   Initialize();
 }
 
 void QuicInMemoryCache::Initialize() {
   // If there's no defined cache dir, we have no initialization to do.
   if (FLAGS_quic_in_memory_cache_dir.empty()) {
     VLOG(1) << "No cache directory found. Skipping initialization.";
     return;
   }
   VLOG(1) << "Attempting to initialize QuicInMemoryCache from directory: "
           << FLAGS_quic_in_memory_cache_dir;
 
   FilePath directory(FLAGS_quic_in_memory_cache_dir);
-  base::FileEnumerator file_list(directory,
-                                 true,
-                                 base::FileEnumerator::FILES);
+  base::FileEnumerator file_list(directory, true, base::FileEnumerator::FILES);
 
   FilePath file = file_list.Next();
   while (!file.empty()) {
     // Need to skip files in .svn directories
     if (file.value().find("/.svn/") != std::string::npos) {
       file = file_list.Next();
       continue;
     }
 
     BalsaHeaders request_headers, response_headers;
@@ skipping 42 matching lines @@
       }
     }
     int path_start = base.find_first_of('/');
     DCHECK_LT(0, path_start);
     StringPiece host(base.substr(0, path_start));
     StringPiece path(base.substr(path_start));
     if (path[path.length() - 1] == ',') {
       path.remove_suffix(1);
     }
     // Set up request headers. Assume method is GET and protocol is HTTP/1.1.
-    request_headers.SetRequestFirstlineFromStringPieces("GET",
-                                                        path,
-                                                        "HTTP/1.1");
+    request_headers.SetRequestFirstlineFromStringPieces(
+        "GET", path, "HTTP/1.1");
     request_headers.ReplaceOrAppendHeader("host", host);
 
     VLOG(1) << "Inserting 'http://" << GetKey(request_headers)
             << "' into QuicInMemoryCache.";
 
     AddResponse(request_headers, response_headers, caching_visitor.body());
 
     file = file_list.Next();
   }
 }
@@ skipping 13 matching lines @@
   } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "https://")) {
     uri.remove_prefix(8);
   } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "http://")) {
     uri.remove_prefix(7);
   }
   return host.as_string() + uri.as_string();
 }
 
 }  // namespace tools
 }  // namespace net