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

This CL removes a cross thread malloc/free pair from simple disk cache backend.

After a PostTaskAndReply change in http://crrev.com/e5de8d551e80115b, it
destroys |task| part of the given tasks on the target thread, and that
introduced a number of cross thread malloc/free pairs around net::IOBuffer.
The cross thread malloc/free pair increased the apparent size of memory
usage on some Android perf bots by 2~3%, that is likely due to thread
specific free list caches.

BUG=708644

Review-Url: https://codereview.chromium.org/2815563002
Cr-Commit-Position: refs/heads/master@{#464338}

net/disk_cache/simple/simple_entry_impl.cc

@@ -973,17 +973,18 @@ void SimpleEntryImpl::WriteDataInternal(int stream_index,
     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);
 }
 
@@ -1271,7 +1272,8 @@ 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

net/disk_cache/simple/simple_entry_impl.h

@@ -253,10 +253,14 @@ class NET_EXPORT_PRIVATE SimpleEntryImpl : public Entry,
                              std::unique_ptr<int> result);
 
   // Called after an asynchronous write completes.
+  // |buf| parameter brings back a reference to net::IOBuffer to the original
+  // thread, so that we can reduce cross thread malloc/free pair.
+  // See http://crbug.com/708644 for details.
   void 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);
 
   void ReadSparseOperationComplete(
       const CompletionCallback& completion_callback,