Avoid cross thread malloc / free pair of IOBuffer on the simple cache

net/disk_cache/simple/simple_entry_impl.cc

 // Copyright (c) 2013 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/simple/simple_entry_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 #include <utility>
@@ skipping 955 matching lines @@
   // |last_modified_| yet, we make this approximation.
   last_used_ = last_modified_ = base::Time::Now();
 
   have_written_[stream_index] = true;
   // Writing on stream 1 affects the placement of stream 0 in the file, the EOF
   // record will have to be rewritten.
   if (stream_index == 1)
     have_written_[0] = true;
 
   std::unique_ptr<int> result(new int());
+
+  // Retain a reference to |buf| in |reply| instead of |task|, so that we can
+  // reduce cross thread malloc/free pairs. The cross thread malloc/free pair
+  // increases the apparent memory usage due to the thread cached free list.
   Closure task = base::Bind(
       &SimpleSynchronousEntry::WriteData, base::Unretained(synchronous_entry_),
       SimpleSynchronousEntry::EntryOperationData(stream_index, offset, buf_len,
                                                  truncate, doomed_),
-      base::RetainedRef(buf), entry_stat.get(), result.get());
-  Closure reply = base::Bind(&SimpleEntryImpl::WriteOperationComplete,
-                             this,
-                             stream_index,
-                             callback,
-                             base::Passed(&entry_stat),
-                             base::Passed(&result));
+      base::Unretained(buf), entry_stat.get(), result.get());
+  Closure reply = base::Bind(&SimpleEntryImpl::WriteOperationComplete, this,
+                             stream_index, callback, base::Passed(&entry_stat),
+                             base::Passed(&result), base::RetainedRef(buf));
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
 
 void SimpleEntryImpl::ReadSparseDataInternal(
     int64_t sparse_offset,
     net::IOBuffer* buf,
     int buf_len,
     const CompletionCallback& callback) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   ScopedOperationRunner operation_runner(this);
@@ skipping 267 matching lines @@
                       CreateNetLogReadWriteCompleteCallback(*result));
   }
 
   EntryOperationComplete(completion_callback, *entry_stat, std::move(result));
 }
 
 void SimpleEntryImpl::WriteOperationComplete(
     int stream_index,
     const CompletionCallback& completion_callback,
     std::unique_ptr<SimpleEntryStat> entry_stat,
-    std::unique_ptr<int> result) {
+    std::unique_ptr<int> result,
+    net::IOBuffer* buf) {
   if (*result >= 0)
     RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
   else
     RecordWriteResult(cache_type_, WRITE_RESULT_SYNC_WRITE_FAILURE);
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY_WRITE_END,
                       CreateNetLogReadWriteCompleteCallback(*result));
   }
 
   if (*result < 0) {
@@ skipping 277 matching lines @@
     }
     crc32s_end_offset_[stream_index] = offset + length;
   } else if (offset < crc32s_end_offset_[stream_index]) {
     // If a range for which the crc32 was already computed is rewritten, the
     // computation of the crc32 need to start from 0 again.
     crc32s_end_offset_[stream_index] = 0;
   }
 }
 
 }  // namespace disk_cache