Clang format slam.

net/http/http_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/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 48 matching lines @@
                                           const base::FilePath& path,
                                           int max_bytes,
                                           base::MessageLoopProxy* thread)
     : type_(type),
       backend_type_(backend_type),
       path_(path),
       max_bytes_(max_bytes),
       thread_(thread) {
 }
 
-HttpCache::DefaultBackend::~DefaultBackend() {}
+HttpCache::DefaultBackend::~DefaultBackend() {
+}
 
 // static
 HttpCache::BackendFactory* HttpCache::DefaultBackend::InMemory(int max_bytes) {
-  return new DefaultBackend(MEMORY_CACHE, net::CACHE_BACKEND_DEFAULT,
-                            base::FilePath(), max_bytes, NULL);
+  return new DefaultBackend(MEMORY_CACHE,
+                            net::CACHE_BACKEND_DEFAULT,
+                            base::FilePath(),
+                            max_bytes,
+                            NULL);
 }
 
 int HttpCache::DefaultBackend::CreateBackend(
-    NetLog* net_log, scoped_ptr<disk_cache::Backend>* backend,
+    NetLog* net_log,
+    scoped_ptr<disk_cache::Backend>* backend,
     const CompletionCallback& callback) {
   DCHECK_GE(max_bytes_, 0);
   return disk_cache::CreateCacheBackend(type_,
                                         backend_type_,
                                         path_,
                                         max_bytes_,
                                         true,
                                         thread_.get(),
                                         net_log,
                                         backend,
@@ skipping 39 matching lines @@
   WI_OPEN_ENTRY,
   WI_CREATE_ENTRY,
   WI_DOOM_ENTRY
 };
 
 // A work item encapsulates a single request to the backend with all the
 // information needed to complete that request.
 class HttpCache::WorkItem {
  public:
   WorkItem(WorkItemOperation operation, Transaction* trans, ActiveEntry** entry)
-      : operation_(operation),
-        trans_(trans),
-        entry_(entry),
-        backend_(NULL) {}
-  WorkItem(WorkItemOperation operation, Transaction* trans,
-           const net::CompletionCallback& cb, disk_cache::Backend** backend)
+      : operation_(operation), trans_(trans), entry_(entry), backend_(NULL) {}
+  WorkItem(WorkItemOperation operation,
+           Transaction* trans,
+           const net::CompletionCallback& cb,
+           disk_cache::Backend** backend)
       : operation_(operation),
         trans_(trans),
         entry_(NULL),
         callback_(cb),
         backend_(backend) {}
   ~WorkItem() {}
 
   // Calls back the transaction with the result of the operation.
   void NotifyTransaction(int result, ActiveEntry* entry) {
     DCHECK(!entry || entry->disk_entry);
@@ skipping 30 matching lines @@
   disk_cache::Backend** backend_;
 };
 
 //-----------------------------------------------------------------------------
 
 // This class encapsulates a transaction whose only purpose is to write metadata
 // to a given entry.
 class HttpCache::MetadataWriter {
  public:
   explicit MetadataWriter(HttpCache::Transaction* trans)
-      : transaction_(trans),
-        verified_(false),
-        buf_len_(0) {
-  }
+      : transaction_(trans), verified_(false), buf_len_(0) {}
 
   ~MetadataWriter() {}
 
   // Implements the bulk of HttpCache::WriteMetadata.
-  void Write(const GURL& url, base::Time expected_response_time, IOBuffer* buf,
+  void Write(const GURL& url,
+             base::Time expected_response_time,
+             IOBuffer* buf,
              int buf_len);
 
  private:
   void VerifyResponse(int result);
   void SelfDestroy();
   void OnIOComplete(int result);
 
   scoped_ptr<HttpCache::Transaction> transaction_;
   bool verified_;
   scoped_refptr<IOBuffer> buf_;
   int buf_len_;
   base::Time expected_response_time_;
   HttpRequestInfo request_info_;
   DISALLOW_COPY_AND_ASSIGN(MetadataWriter);
 };
 
 void HttpCache::MetadataWriter::Write(const GURL& url,
                                       base::Time expected_response_time,
-                                      IOBuffer* buf, int buf_len) {
+                                      IOBuffer* buf,
+                                      int buf_len) {
   DCHECK_GT(buf_len, 0);
   DCHECK(buf);
   DCHECK(buf->data());
   request_info_.url = url;
   request_info_.method = "GET";
   request_info_.load_flags = LOAD_ONLY_FROM_CACHE;
 
   expected_response_time_ = expected_response_time;
   buf_ = buf;
   buf_len_ = buf_len;
@@ skipping 33 matching lines @@
   if (!verified_)
     return VerifyResponse(result);
   SelfDestroy();
 }
 
 //-----------------------------------------------------------------------------
 
 class HttpCache::QuicServerInfoFactoryAdaptor : public QuicServerInfoFactory {
  public:
   QuicServerInfoFactoryAdaptor(HttpCache* http_cache)
-      : http_cache_(http_cache) {
-  }
+      : http_cache_(http_cache) {}
 
-  virtual QuicServerInfo* GetForServer(
-      const QuicServerId& server_id) OVERRIDE {
+  virtual QuicServerInfo* GetForServer(const QuicServerId& server_id) OVERRIDE {
     return new DiskCacheBasedQuicServerInfo(server_id, http_cache_);
   }
 
  private:
   HttpCache* const http_cache_;
 };
 
 //-----------------------------------------------------------------------------
 HttpCache::HttpCache(const net::HttpNetworkSession::Params& params,
                      BackendFactory* backend_factory)
     : net_log_(params.net_log),
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
-      quic_server_info_factory_(params.enable_quic_persist_server_info ?
-          new QuicServerInfoFactoryAdaptor(this) : NULL),
+      quic_server_info_factory_(params.enable_quic_persist_server_info
+                                    ? new QuicServerInfoFactoryAdaptor(this)
+                                    : NULL),
       network_layer_(new HttpNetworkLayer(new HttpNetworkSession(params))) {
   HttpNetworkSession* session = network_layer_->GetSession();
   session->quic_stream_factory()->set_quic_server_info_factory(
       quic_server_info_factory_.get());
 }
 
-
 // This call doesn't change the shared |session|'s QuicServerInfoFactory because
 // |session| is shared.
 HttpCache::HttpCache(HttpNetworkSession* session,
                      BackendFactory* backend_factory)
     : net_log_(session->net_log()),
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       network_layer_(new HttpNetworkLayer(session)) {
 }
@@ skipping 62 matching lines @@
   }
 
   return CreateBackend(backend, callback);
 }
 
 disk_cache::Backend* HttpCache::GetCurrentBackend() const {
   return disk_cache_.get();
 }
 
 // static
-bool HttpCache::ParseResponseInfo(const char* data, int len,
+bool HttpCache::ParseResponseInfo(const char* data,
+                                  int len,
                                   HttpResponseInfo* response_info,
                                   bool* response_truncated) {
   Pickle pickle(data, len);
   return response_info->InitFromPickle(pickle, response_truncated);
 }
 
 void HttpCache::WriteMetadata(const GURL& url,
                               RequestPriority priority,
                               base::Time expected_response_time,
                               IOBuffer* buf,
                               int buf_len) {
   if (!buf_len)
     return;
 
   // Do lazy initialization of disk cache if needed.
   if (!disk_cache_.get()) {
     // We don't care about the result.
     CreateBackend(NULL, net::CompletionCallback());
   }
 
-  HttpCache::Transaction* trans =
-      new HttpCache::Transaction(priority, this);
+  HttpCache::Transaction* trans = new HttpCache::Transaction(priority, this);
   MetadataWriter* writer = new MetadataWriter(trans);
 
   // The writer will self destruct when done.
   writer->Write(url, expected_response_time, buf, buf_len);
 }
 
 void HttpCache::CloseAllConnections() {
   net::HttpNetworkLayer* network =
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
@@ skipping 59 matching lines @@
 
 //-----------------------------------------------------------------------------
 
 int HttpCache::CreateBackend(disk_cache::Backend** backend,
                              const net::CompletionCallback& callback) {
   if (!backend_factory_.get())
     return ERR_FAILED;
 
   building_backend_ = true;
 
-  scoped_ptr<WorkItem> item(new WorkItem(WI_CREATE_BACKEND, NULL, callback,
-                                         backend));
+  scoped_ptr<WorkItem> item(
+      new WorkItem(WI_CREATE_BACKEND, NULL, callback, backend));
 
   // This is the only operation that we can do that is not related to any given
   // entry, so we use an empty key for it.
   PendingOp* pending_op = GetPendingOp(std::string());
   if (pending_op->writer) {
     if (!callback.is_null())
       pending_op->pending_queue.push_back(item.release());
     return ERR_IO_PENDING;
   }
 
   DCHECK(pending_op->pending_queue.empty());
 
   pending_op->writer = item.release();
-  pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
-                                    AsWeakPtr(), pending_op);
+  pending_op->callback =
+      base::Bind(&HttpCache::OnPendingOpComplete, AsWeakPtr(), pending_op);
 
-  int rv = backend_factory_->CreateBackend(net_log_, &pending_op->backend,
-                                           pending_op->callback);
+  int rv = backend_factory_->CreateBackend(
+      net_log_, &pending_op->backend, pending_op->callback);
   if (rv != ERR_IO_PENDING) {
     pending_op->writer->ClearCallback();
     pending_op->callback.Run(rv);
   }
 
   return rv;
 }
 
 int HttpCache::GetBackendForTransaction(Transaction* trans) {
   if (disk_cache_.get())
     return OK;
 
   if (!building_backend_)
     return ERR_FAILED;
 
-  WorkItem* item = new WorkItem(
-      WI_CREATE_BACKEND, trans, net::CompletionCallback(), NULL);
+  WorkItem* item =
+      new WorkItem(WI_CREATE_BACKEND, trans, net::CompletionCallback(), NULL);
   PendingOp* pending_op = GetPendingOp(std::string());
   DCHECK(pending_op->writer);
   pending_op->pending_queue.push_back(item);
   return ERR_IO_PENDING;
 }
 
 // Generate a key that can be used inside the cache.
 std::string HttpCache::GenerateCacheKey(const HttpRequestInfo* request) {
   // Strip out the reference, username, and password sections of the URL.
   std::string url = HttpUtil::SpecForRequest(request->url);
 
   DCHECK(mode_ != DISABLE);
   if (mode_ == NORMAL) {
     // No valid URL can begin with numerals, so we should not have to worry
     // about collisions with normal URLs.
     if (request->upload_data_stream &&
         request->upload_data_stream->identifier()) {
-      url.insert(0, base::StringPrintf(
-          "%" PRId64 "/", request->upload_data_stream->identifier()));
+      url.insert(0,
+                 base::StringPrintf("%" PRId64 "/",
+                                    request->upload_data_stream->identifier()));
     }
     return url;
   }
 
   // In playback and record mode, we cache everything.
 
   // Lazily initialize.
   if (playback_cache_map_ == NULL)
     playback_cache_map_.reset(new PlaybackCacheMap());
 
@@ skipping 54 matching lines @@
   WorkItem* item = new WorkItem(WI_DOOM_ENTRY, trans, NULL);
   PendingOp* pending_op = GetPendingOp(key);
   if (pending_op->writer) {
     pending_op->pending_queue.push_back(item);
     return ERR_IO_PENDING;
   }
 
   DCHECK(pending_op->pending_queue.empty());
 
   pending_op->writer = item;
-  pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
-                                    AsWeakPtr(), pending_op);
+  pending_op->callback =
+      base::Bind(&HttpCache::OnPendingOpComplete, AsWeakPtr(), pending_op);
 
   int rv = disk_cache_->DoomEntry(key, pending_op->callback);
   if (rv != ERR_IO_PENDING) {
     item->ClearTransaction();
     pending_op->callback.Run(rv);
   }
 
   return rv;
 }
 
@@ skipping 56 matching lines @@
   DCHECK(it != active_entries_.end());
   DCHECK(it->second == entry);
 
   active_entries_.erase(it);
   delete entry;
 }
 
 // We don't know this entry's key so we have to find it without it.
 void HttpCache::SlowDeactivateEntry(ActiveEntry* entry) {
   for (ActiveEntriesMap::iterator it = active_entries_.begin();
-       it != active_entries_.end(); ++it) {
+       it != active_entries_.end();
+       ++it) {
     if (it->second == entry) {
       active_entries_.erase(it);
       delete entry;
       break;
     }
   }
 }
 
 HttpCache::PendingOp* HttpCache::GetPendingOp(const std::string& key) {
   DCHECK(!FindActiveEntry(key));
@@ skipping 11 matching lines @@
   std::string key;
   if (pending_op->disk_entry)
     key = pending_op->disk_entry->GetKey();
 
   if (!key.empty()) {
     PendingOpsMap::iterator it = pending_ops_.find(key);
     DCHECK(it != pending_ops_.end());
     pending_ops_.erase(it);
   } else {
     for (PendingOpsMap::iterator it = pending_ops_.begin();
-         it != pending_ops_.end(); ++it) {
+         it != pending_ops_.end();
+         ++it) {
       if (it->second == pending_op) {
         pending_ops_.erase(it);
         break;
       }
     }
   }
   DCHECK(pending_op->pending_queue.empty());
 
   delete pending_op;
 }
 
-int HttpCache::OpenEntry(const std::string& key, ActiveEntry** entry,
+int HttpCache::OpenEntry(const std::string& key,
+                         ActiveEntry** entry,
                          Transaction* trans) {
   ActiveEntry* active_entry = FindActiveEntry(key);
   if (active_entry) {
     *entry = active_entry;
     return OK;
   }
 
   WorkItem* item = new WorkItem(WI_OPEN_ENTRY, trans, entry);
   PendingOp* pending_op = GetPendingOp(key);
   if (pending_op->writer) {
     pending_op->pending_queue.push_back(item);
     return ERR_IO_PENDING;
   }
 
   DCHECK(pending_op->pending_queue.empty());
 
   pending_op->writer = item;
-  pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
-                                    AsWeakPtr(), pending_op);
+  pending_op->callback =
+      base::Bind(&HttpCache::OnPendingOpComplete, AsWeakPtr(), pending_op);
 
-  int rv = disk_cache_->OpenEntry(key, &(pending_op->disk_entry),
-                                  pending_op->callback);
+  int rv = disk_cache_->OpenEntry(
+      key, &(pending_op->disk_entry), pending_op->callback);
   if (rv != ERR_IO_PENDING) {
     item->ClearTransaction();
     pending_op->callback.Run(rv);
   }
 
   return rv;
 }
 
-int HttpCache::CreateEntry(const std::string& key, ActiveEntry** entry,
+int HttpCache::CreateEntry(const std::string& key,
+                           ActiveEntry** entry,
                            Transaction* trans) {
   if (FindActiveEntry(key)) {
     return ERR_CACHE_RACE;
   }
 
   WorkItem* item = new WorkItem(WI_CREATE_ENTRY, trans, entry);
   PendingOp* pending_op = GetPendingOp(key);
   if (pending_op->writer) {
     pending_op->pending_queue.push_back(item);
     return ERR_IO_PENDING;
   }
 
   DCHECK(pending_op->pending_queue.empty());
 
   pending_op->writer = item;
-  pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
-                                    AsWeakPtr(), pending_op);
+  pending_op->callback =
+      base::Bind(&HttpCache::OnPendingOpComplete, AsWeakPtr(), pending_op);
 
-  int rv = disk_cache_->CreateEntry(key, &(pending_op->disk_entry),
-                                    pending_op->callback);
+  int rv = disk_cache_->CreateEntry(
+      key, &(pending_op->disk_entry), pending_op->callback);
   if (rv != ERR_IO_PENDING) {
     item->ClearTransaction();
     pending_op->callback.Run(rv);
   }
 
   return rv;
 }
 
 void HttpCache::DestroyEntry(ActiveEntry* entry) {
   if (entry->doomed) {
@@ skipping 35 matching lines @@
 
   // We do this before calling EntryAvailable to force any further calls to
   // AddTransactionToEntry to add their transaction to the pending queue, which
   // ensures FIFO ordering.
   if (!entry->writer && !entry->pending_queue.empty())
     ProcessPendingQueue(entry);
 
   return OK;
 }
 
-void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans,
+void HttpCache::DoneWithEntry(ActiveEntry* entry,
+                              Transaction* trans,
                               bool cancel) {
   // If we already posted a task to move on to the next transaction and this was
   // the writer, there is nothing to cancel.
   if (entry->will_process_pending_queue && entry->readers.empty())
     return;
 
   if (entry->writer) {
     DCHECK(trans == entry->writer);
 
     // Assume there was a failure.
@@ skipping 59 matching lines @@
 
   Transaction* trans = entry->writer;
 
   entry->writer = NULL;
   entry->readers.push_back(trans);
 
   ProcessPendingQueue(entry);
 }
 
 LoadState HttpCache::GetLoadStateForPendingTransaction(
-      const Transaction* trans) {
+    const Transaction* trans) {
   ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key());
   if (i == active_entries_.end()) {
     // If this is really a pending transaction, and it is not part of
     // active_entries_, we should be creating the backend or the entry.
     return LOAD_STATE_WAITING_FOR_CACHE;
   }
 
   Transaction* writer = i->second->writer;
   return writer ? writer->GetWriterLoadState() : LOAD_STATE_WAITING_FOR_CACHE;
 }
@@ skipping 236 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net