Clang format slam.

net/disk_cache/memory/mem_entry_impl.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/disk_cache/memory/mem_entry_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 62 matching lines @@
 }
 
 // ------------------------------------------------------------------------
 
 bool MemEntryImpl::CreateEntry(const std::string& key, net::NetLog* net_log) {
   key_ = key;
   Time current = Time::Now();
   last_modified_ = current;
   last_used_ = current;
 
-  net_log_ = net::BoundNetLog::Make(net_log,
-                                    net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
+  net_log_ =
+      net::BoundNetLog::Make(net_log, net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
   // Must be called after |key_| is set, so GetKey() works.
-  net_log_.BeginEvent(
-      net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
-      CreateNetLogEntryCreationCallback(this, true));
+  net_log_.BeginEvent(net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
+                      CreateNetLogEntryCreationCallback(this, true));
 
   Open();
   backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
   return true;
 }
 
 void MemEntryImpl::InternalDoom() {
   net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   doomed_ = true;
   if (!ref_count_) {
     if (type() == kParentEntry) {
       // If this is a parent entry, we need to doom all the child entries.
       if (children_.get()) {
         EntryMap children;
         children.swap(*children_);
-        for (EntryMap::iterator i = children.begin();
-             i != children.end(); ++i) {
+        for (EntryMap::iterator i = children.begin(); i != children.end();
+             ++i) {
           // Since a pointer to this object is also saved in the map, avoid
           // dooming it.
           if (i->second != this)
             i->second->Doom();
         }
         DCHECK(children_->empty());
       }
     } else {
       // If this is a child entry, detach it from the parent.
       parent_->DetachChild(child_id_);
@@ skipping 60 matching lines @@
 Time MemEntryImpl::GetLastModified() const {
   return last_modified_;
 }
 
 int32 MemEntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= NUM_STREAMS)
     return 0;
   return data_size_[index];
 }
 
-int MemEntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
+int MemEntryImpl::ReadData(int index,
+                           int offset,
+                           IOBuffer* buf,
+                           int buf_len,
                            const CompletionCallback& callback) {
   if (net_log_.IsLogging()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
   }
 
   int result = InternalReadData(index, offset, buf, buf_len);
 
   if (net_log_.IsLogging()) {
-    net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_READ_DATA,
-        CreateNetLogReadWriteCompleteCallback(result));
+    net_log_.EndEvent(net::NetLog::TYPE_ENTRY_READ_DATA,
+                      CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
-int MemEntryImpl::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
-                            const CompletionCallback& callback, bool truncate) {
+int MemEntryImpl::WriteData(int index,
+                            int offset,
+                            IOBuffer* buf,
+                            int buf_len,
+                            const CompletionCallback& callback,
+                            bool truncate) {
   if (net_log_.IsLogging()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
   }
 
   int result = InternalWriteData(index, offset, buf, buf_len, truncate);
 
   if (net_log_.IsLogging()) {
-    net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        CreateNetLogReadWriteCompleteCallback(result));
+    net_log_.EndEvent(net::NetLog::TYPE_ENTRY_WRITE_DATA,
+                      CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
-int MemEntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int MemEntryImpl::ReadSparseData(int64 offset,
+                                 IOBuffer* buf,
+                                 int buf_len,
                                  const CompletionCallback& callback) {
   if (net_log_.IsLogging()) {
-    net_log_.BeginEvent(
-        net::NetLog::TYPE_SPARSE_READ,
-        CreateNetLogSparseOperationCallback(offset, buf_len));
+    net_log_.BeginEvent(net::NetLog::TYPE_SPARSE_READ,
+                        CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalReadSparseData(offset, buf, buf_len);
   if (net_log_.IsLogging())
     net_log_.EndEvent(net::NetLog::TYPE_SPARSE_READ);
   return result;
 }
 
-int MemEntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int MemEntryImpl::WriteSparseData(int64 offset,
+                                  IOBuffer* buf,
+                                  int buf_len,
                                   const CompletionCallback& callback) {
   if (net_log_.IsLogging()) {
-    net_log_.BeginEvent(
-        net::NetLog::TYPE_SPARSE_WRITE,
-        CreateNetLogSparseOperationCallback(offset, buf_len));
+    net_log_.BeginEvent(net::NetLog::TYPE_SPARSE_WRITE,
+                        CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalWriteSparseData(offset, buf, buf_len);
   if (net_log_.IsLogging())
     net_log_.EndEvent(net::NetLog::TYPE_SPARSE_WRITE);
   return result;
 }
 
-int MemEntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
+int MemEntryImpl::GetAvailableRange(int64 offset,
+                                    int len,
+                                    int64* start,
                                     const CompletionCallback& callback) {
   if (net_log_.IsLogging()) {
-    net_log_.BeginEvent(
-        net::NetLog::TYPE_SPARSE_GET_RANGE,
-        CreateNetLogSparseOperationCallback(offset, len));
+    net_log_.BeginEvent(net::NetLog::TYPE_SPARSE_GET_RANGE,
+                        CreateNetLogSparseOperationCallback(offset, len));
   }
   int result = GetAvailableRange(offset, len, start);
   if (net_log_.IsLogging()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
         CreateNetLogGetAvailableRangeResultCallback(*start, result));
   }
   return result;
 }
 
 bool MemEntryImpl::CouldBeSparse() const {
   DCHECK_EQ(kParentEntry, type());
   return (children_.get() != NULL);
 }
 
 int MemEntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
   return net::OK;
 }
 
 // ------------------------------------------------------------------------
 
 MemEntryImpl::~MemEntryImpl() {
   for (int i = 0; i < NUM_STREAMS; i++)
     backend_->ModifyStorageSize(data_size_[i], 0);
   backend_->ModifyStorageSize(static_cast<int32>(key_.size()), 0);
   net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL);
 }
 
-int MemEntryImpl::InternalReadData(int index, int offset, IOBuffer* buf,
+int MemEntryImpl::InternalReadData(int index,
+                                   int offset,
+                                   IOBuffer* buf,
                                    int buf_len) {
   DCHECK(type() == kParentEntry || index == kSparseData);
 
   if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = GetDataSize(index);
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset + buf_len > entry_size)
     buf_len = entry_size - offset;
 
   UpdateRank(false);
 
   memcpy(buf->data(), &(data_[index])[offset], buf_len);
   return buf_len;
 }
 
-int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
-                                    int buf_len, bool truncate) {
+int MemEntryImpl::InternalWriteData(int index,
+                                    int offset,
+                                    IOBuffer* buf,
+                                    int buf_len,
+                                    bool truncate) {
   DCHECK(type() == kParentEntry || index == kSparseData);
 
   if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   int max_file_size = backend_->MaxFileSize();
 
@@ skipping 20 matching lines @@
 
   UpdateRank(true);
 
   if (!buf_len)
     return 0;
 
   memcpy(&(data_[index])[offset], buf->data(), buf_len);
   return buf_len;
 }
 
-int MemEntryImpl::InternalReadSparseData(int64 offset, IOBuffer* buf,
+int MemEntryImpl::InternalReadSparseData(int64 offset,
+                                         IOBuffer* buf,
                                          int buf_len) {
   DCHECK(type() == kParentEntry);
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   // We will keep using this buffer and adjust the offset in this buffer.
@@ skipping 14 matching lines @@
     // If we are trying to read from a position that the child entry has no data
     // we should stop.
     if (child_offset < child->child_first_pos_)
       break;
     if (net_log_.IsLogging()) {
       net_log_.BeginEvent(
           net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
           CreateNetLogSparseReadWriteCallback(child->net_log().source(),
                                               io_buf->BytesRemaining()));
     }
-    int ret = child->ReadData(kSparseData, child_offset, io_buf.get(),
-                              io_buf->BytesRemaining(), CompletionCallback());
+    int ret = child->ReadData(kSparseData,
+                              child_offset,
+                              io_buf.get(),
+                              io_buf->BytesRemaining(),
+                              CompletionCallback());
     if (net_log_.IsLogging()) {
       net_log_.EndEventWithNetErrorCode(
           net::NetLog::TYPE_SPARSE_READ_CHILD_DATA, ret);
     }
 
     // If we encounter an error in one entry, return immediately.
     if (ret < 0)
       return ret;
     else if (ret == 0)
       break;
 
     // Increment the counter by number of bytes read in the child entry.
     io_buf->DidConsume(ret);
   }
 
   UpdateRank(false);
 
   return io_buf->BytesConsumed();
 }
 
-int MemEntryImpl::InternalWriteSparseData(int64 offset, IOBuffer* buf,
+int MemEntryImpl::InternalWriteSparseData(int64 offset,
+                                          IOBuffer* buf,
                                           int buf_len) {
   DCHECK(type() == kParentEntry);
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   scoped_refptr<net::DrainableIOBuffer> io_buf(
       new net::DrainableIOBuffer(buf, buf_len));
 
   // This loop walks through child entries continuously starting from |offset|
   // and writes blocks of data (of maximum size kMaxSparseEntrySize) into each
   // child entry until all |buf_len| bytes are written. The write operation can
   // start in the middle of an entry.
   while (io_buf->BytesRemaining()) {
     MemEntryImpl* child = OpenChild(offset + io_buf->BytesConsumed(), true);
     int child_offset = ToChildOffset(offset + io_buf->BytesConsumed());
 
     // Find the right amount to write, this evaluates the remaining bytes to
     // write and remaining capacity of this child entry.
     int write_len = std::min(static_cast<int>(io_buf->BytesRemaining()),
                              kMaxSparseEntrySize - child_offset);
 
     // Keep a record of the last byte position (exclusive) in the child.
     int data_size = child->GetDataSize(kSparseData);
 
     if (net_log_.IsLogging()) {
-      net_log_.BeginEvent(
-          net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
-          CreateNetLogSparseReadWriteCallback(child->net_log().source(),
-                                              write_len));
+      net_log_.BeginEvent(net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
+                          CreateNetLogSparseReadWriteCallback(
+                              child->net_log().source(), write_len));
     }
 
     // Always writes to the child entry. This operation may overwrite data
     // previously written.
     // TODO(hclam): if there is data in the entry and this write is not
     // continuous we may want to discard this write.
-    int ret = child->WriteData(kSparseData, child_offset, io_buf.get(),
-                               write_len, CompletionCallback(), true);
+    int ret = child->WriteData(kSparseData,
+                               child_offset,
+                               io_buf.get(),
+                               write_len,
+                               CompletionCallback(),
+                               true);
     if (net_log_.IsLogging()) {
       net_log_.EndEventWithNetErrorCode(
           net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA, ret);
     }
     if (ret < 0)
       return ret;
     else if (ret == 0)
       break;
 
     // Keep a record of the first byte position in the child if the write was
@@ skipping 93 matching lines @@
       return false;
     children_.reset(new EntryMap());
 
     // The parent entry stores data for the first block, so save this object to
     // index 0.
     (*children_)[0] = this;
   }
   return true;
 }
 
-bool MemEntryImpl::InitChildEntry(MemEntryImpl* parent, int child_id,
+bool MemEntryImpl::InitChildEntry(MemEntryImpl* parent,
+                                  int child_id,
                                   net::NetLog* net_log) {
   DCHECK(!parent_);
   DCHECK(!child_id_);
 
-  net_log_ = net::BoundNetLog::Make(net_log,
-                                    net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
+  net_log_ =
+      net::BoundNetLog::Make(net_log, net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
   net_log_.BeginEvent(
       net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
       base::Bind(&NetLogChildEntryCreationCallback, parent, child_id_));
 
   parent_ = parent;
   child_id_ = child_id;
   Time current = Time::Now();
   last_modified_ = current;
   last_used_ = current;
   // Insert this to the backend's ranking list.
@@ skipping 24 matching lines @@
   // This loop tries to find the first existing child.
   while (scanned_len < len) {
     // This points to the current offset in the child.
     int current_child_offset = ToChildOffset(offset + scanned_len);
     MemEntryImpl* current_child = OpenChild(offset + scanned_len, false);
     if (current_child) {
       int child_first_pos = current_child->child_first_pos_;
 
       // This points to the first byte that we should be reading from, we need
       // to take care of the filled region and the current offset in the child.
-      int first_pos =  std::max(current_child_offset, child_first_pos);
+      int first_pos = std::max(current_child_offset, child_first_pos);
 
       // If the first byte position we should read from doesn't exceed the
       // filled region, we have found the first child.
       if (first_pos < current_child->GetDataSize(kSparseData)) {
-         *child = current_child;
+        *child = current_child;
 
-         // We need to advance the scanned length.
-         scanned_len += first_pos - current_child_offset;
-         break;
+        // We need to advance the scanned length.
+        scanned_len += first_pos - current_child_offset;
+        break;
       }
     }
     scanned_len += kMaxSparseEntrySize - current_child_offset;
   }
   return scanned_len;
 }
 
 void MemEntryImpl::DetachChild(int child_id) {
   children_->erase(child_id);
 }
 
 }  // namespace disk_cache