Reland: Refactor and shorten in-memory cache.

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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/memory/mem_backend_impl.h"
 #include "net/disk_cache/net_log_parameters.h"
 
 using base::Time;
 
+namespace disk_cache {
+
 namespace {
 
 const int kSparseData = 1;
 
 // Maximum size of a sparse entry is 2 to the power of this number.
 const int kMaxSparseEntryBits = 12;
 
 // Sparse entry has maximum size of 4KB.
 const int kMaxSparseEntrySize = 1 << kMaxSparseEntryBits;
 
 // Convert global offset to child index.
-inline int ToChildIndex(int64_t offset) {
+int ToChildIndex(int64_t offset) {
   return static_cast<int>(offset >> kMaxSparseEntryBits);
 }
 
 // Convert global offset to offset in child entry.
-inline int ToChildOffset(int64_t offset) {
+int ToChildOffset(int64_t offset) {
   return static_cast<int>(offset & (kMaxSparseEntrySize - 1));
 }
 
 // Returns a name for a child entry given the base_name of the parent and the
 // child_id.  This name is only used for logging purposes.
 // If the entry is called entry_name, child entries will be named something
 // like Range_entry_name:YYY where YYY is the number of the particular child.
 std::string GenerateChildName(const std::string& base_name, int child_id) {
   return base::StringPrintf("Range_%s:%i", base_name.c_str(), child_id);
 }
 
-// Returns NetLog parameters for the creation of a child MemEntryImpl.  Separate
-// function needed because child entries don't suppport GetKey().
-scoped_ptr<base::Value> NetLogChildEntryCreationCallback(
-    const disk_cache::MemEntryImpl* parent,
-    int child_id,
+// Returns NetLog parameters for the creation of a MemEntryImpl. A separate
+// function is needed because child entries don't store their key().
+scoped_ptr<base::Value> NetLogEntryCreationCallback(
+    const MemEntryImpl* entry,
     net::NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("key", GenerateChildName(parent->GetKey(), child_id));
+  std::string key;
+  switch (entry->type()) {
+    case MemEntryImpl::PARENT_ENTRY:
+      key = entry->key();
+      break;
+    case MemEntryImpl::CHILD_ENTRY:
+      key = GenerateChildName(entry->parent()->key(), entry->child_id());
+      break;
+  }
+  dict->SetString("key", key);
   dict->SetBoolean("created", true);
   return std::move(dict);
 }
 
 }  // namespace
 
-namespace disk_cache {
-
-MemEntryImpl::MemEntryImpl(MemBackendImpl* backend) {
-  doomed_ = false;
-  backend_ = backend;
-  ref_count_ = 0;
-  parent_ = NULL;
-  child_id_ = 0;
-  child_first_pos_ = 0;
-  next_ = NULL;
-  prev_ = NULL;
-  for (int i = 0; i < NUM_STREAMS; i++)
-    data_size_[i] = 0;
+MemEntryImpl::MemEntryImpl(MemBackendImpl* backend,
+                           const std::string& key,
+                           net::NetLog* net_log)
+    : MemEntryImpl(backend,
+                   key,
+                   0,        // child_id
+                   nullptr,  // parent
+                   net_log) {
+  Open();
+  backend_->ModifyStorageSize(GetStorageSize());
 }
 
-// ------------------------------------------------------------------------
-
-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);
-  // Must be called after |key_| is set, so GetKey() works.
-  net_log_.BeginEvent(
-      net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
-      CreateNetLogEntryCreationCallback(this, true));
-
-  Open();
-  backend_->ModifyStorageSize(0, static_cast<int32_t>(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) {
-          // 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_);
-    }
-    delete this;
-  }
+MemEntryImpl::MemEntryImpl(MemBackendImpl* backend,
+                           int child_id,
+                           MemEntryImpl* parent,
+                           net::NetLog* net_log)
+    : MemEntryImpl(backend,
+                   std::string(),  // key
+                   child_id,
+                   parent,
+                   net_log) {
+  (*parent_->children_)[child_id] = this;
 }
 
 void MemEntryImpl::Open() {
   // Only a parent entry can be opened.
-  // TODO(hclam): make sure it's correct to not apply the concept of ref
-  // counting to child entry.
-  DCHECK(type() == kParentEntry);
-  ref_count_++;
-  DCHECK_GE(ref_count_, 0);
+  DCHECK_EQ(PARENT_ENTRY, type());
+  ++ref_count_;
+  DCHECK_GE(ref_count_, 1);
   DCHECK(!doomed_);
 }
 
-bool MemEntryImpl::InUse() {
-  if (type() == kParentEntry) {
+bool MemEntryImpl::InUse() const {
+  if (type() == PARENT_ENTRY) {
     return ref_count_ > 0;
   } else {
-    // A child entry is always not in use. The consequence is that a child entry
-    // can always be evicted while the associated parent entry is currently in
-    // used (i.e. opened).
+    // TODO(gavinp): Can't this just be a DCHECK? How would ref_count_ not be
+    // zero?
+
+    // A child entry is never in use. Thus one can always be evicted, even while
+    // its parent entry is open and in use.
     return false;
   }
 }
 
-// ------------------------------------------------------------------------
+int MemEntryImpl::GetStorageSize() const {
+  int storage_size = static_cast<int32_t>(key_.size());
+  for (const auto& i : data_)
+    storage_size += i.size();
+  return storage_size;
+}
+
+void MemEntryImpl::UpdateStateOnUse(EntryModified modified_enum) {
+  if (!doomed_)
+    backend_->OnEntryUpdated(this);
+
+  last_used_ = Time::Now();
+  if (modified_enum == ENTRY_WAS_MODIFIED)
+    last_modified_ = last_used_;
+}
 
 void MemEntryImpl::Doom() {
-  if (doomed_)
-    return;
-  if (type() == kParentEntry) {
-    // Perform internal doom from the backend if this is a parent entry.
-    backend_->InternalDoomEntry(this);
-  } else {
-    // Manually detach from the backend and perform internal doom.
-    backend_->RemoveFromRankingList(this);
-    InternalDoom();
+  if (!doomed_) {
+    doomed_ = true;
+    backend_->OnEntryDoomed(this);
+    net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   }
+  if (!ref_count_)
+    delete this;
 }
 
 void MemEntryImpl::Close() {
-  // Only a parent entry can be closed.
-  DCHECK(type() == kParentEntry);
-  ref_count_--;
+  DCHECK_EQ(PARENT_ENTRY, type());
+  --ref_count_;
   DCHECK_GE(ref_count_, 0);
   if (!ref_count_ && doomed_)
-    InternalDoom();
+    delete this;
 }
 
 std::string MemEntryImpl::GetKey() const {
   // A child entry doesn't have key so this method should not be called.
-  DCHECK(type() == kParentEntry);
+  DCHECK_EQ(PARENT_ENTRY, type());
   return key_;
 }
 
 Time MemEntryImpl::GetLastUsed() const {
   return last_used_;
 }
 
 Time MemEntryImpl::GetLastModified() const {
   return last_modified_;
 }
 
 int32_t MemEntryImpl::GetDataSize(int index) const {
-  if (index < 0 || index >= NUM_STREAMS)
+  if (index < 0 || index >= kNumStreams)
     return 0;
-  return data_size_[index];
+  return data_[index].size();
 }
 
 int MemEntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
                            const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
   }
 
@@ skipping 57 matching lines @@
 
 int MemEntryImpl::GetAvailableRange(int64_t offset,
                                     int len,
                                     int64_t* start,
                                     const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
         CreateNetLogSparseOperationCallback(offset, len));
   }
-  int result = GetAvailableRange(offset, len, start);
+  int result = InternalGetAvailableRange(offset, len, start);
   if (net_log_.IsCapturing()) {
     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);
+  DCHECK_EQ(PARENT_ENTRY, type());
+  return (children_.get() != nullptr);
 }
 
 int MemEntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
   return net::OK;
 }
 
 // ------------------------------------------------------------------------
 
+MemEntryImpl::MemEntryImpl(MemBackendImpl* backend,
+                           const ::std::string& key,
+                           int child_id,
+                           MemEntryImpl* parent,
+                           net::NetLog* net_log)
+    : key_(key),
+      ref_count_(0),
+      child_id_(child_id),
+      child_first_pos_(0),
+      parent_(parent),
+      last_modified_(Time::Now()),
+      last_used_(last_modified_),
+      backend_(backend),
+      doomed_(false) {
+  backend_->OnEntryInserted(this);
+  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(&NetLogEntryCreationCallback, this));
+}
+
 MemEntryImpl::~MemEntryImpl() {
-  for (int i = 0; i < NUM_STREAMS; i++)
-    backend_->ModifyStorageSize(data_size_[i], 0);
-  backend_->ModifyStorageSize(static_cast<int32_t>(key_.size()), 0);
+  backend_->ModifyStorageSize(-GetStorageSize());
+
+  if (type() == PARENT_ENTRY) {
+    if (children_) {
+      EntryMap children;
+      children_->swap(children);
+
+      for (auto& it : children) {
+        // Since |this| is stored in the map, it should be guarded against
+        // double dooming, which will result in double destruction.
+        if (it.second != this)
+          it.second->Doom();

[mmenke, 2016/02/19 19:08:32]

So the problem was the child calling backend_->ModifyStorageSize(...) resulting
in evicting another child?  How does the check you added avoid that?  Populated
children don't report a 0 size...do they?

[gavinp, 2016/02/19 19:18:01]

No child should report a zero size. Nor is that very important; take a look at
the check again: it's checking if the modification of the size is shrinking or
enlarging the current backend, not on the current size of any particular entry.

The check I added prevents eviction from recursing; tons of double destructions
and double deletions came from that as the eviction list was modified mid
eviction.

[mmenke, 2016/02/19 19:20:43]

Oh!  For some reason I read it (twice) as "== 0", not "> 0"....which did seem
rather odd.

+      }
+    }
+  } else {
+    parent_->children_->erase(child_id_);
+  }
   net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL);
 }
 
 int MemEntryImpl::InternalReadData(int index, int offset, IOBuffer* buf,
                                    int buf_len) {
-  DCHECK(type() == kParentEntry || index == kSparseData);
+  DCHECK(type() == PARENT_ENTRY || index == kSparseData);
 
-  if (index < 0 || index >= NUM_STREAMS)
+  if (index < 0 || index >= kNumStreams || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
-  int entry_size = GetDataSize(index);
+  int entry_size = data_[index].size();
   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);
+  UpdateStateOnUse(ENTRY_WAS_NOT_MODIFIED);
+  std::copy(data_[index].begin() + offset,
+            data_[index].begin() + offset + buf_len, buf->data());
   return buf_len;
 }
 
 int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
                                     int buf_len, bool truncate) {
-  DCHECK(type() == kParentEntry || index == kSparseData);
+  DCHECK(type() == PARENT_ENTRY || index == kSparseData);
 
-  if (index < 0 || index >= NUM_STREAMS)
+  if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   int max_file_size = backend_->MaxFileSize();
 
   // offset of buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
     return net::ERR_FAILED;
   }
 
-  // Read the size at this point.
-  int entry_size = GetDataSize(index);
+  int old_data_size = data_[index].size();
+  if (truncate || old_data_size < offset + buf_len) {
+    data_[index].resize(offset + buf_len);
 
-  PrepareTarget(index, offset, buf_len);
+    // Zero fill any hole.
+    if (old_data_size < offset) {
+      std::fill(data_[index].begin() + old_data_size,
+                data_[index].begin() + offset, 0);
+    }
 
-  if (entry_size < offset + buf_len) {
-    backend_->ModifyStorageSize(entry_size, offset + buf_len);
-    data_size_[index] = offset + buf_len;
-  } else if (truncate) {
-    if (entry_size > offset + buf_len) {
-      backend_->ModifyStorageSize(entry_size, offset + buf_len);
-      data_size_[index] = offset + buf_len;
-    }
+    backend_->ModifyStorageSize(data_[index].size() - old_data_size);

[mmenke, 2016/02/19 19:36:53]

Hrm...Wait...So if we're a child entry, we are not in use.  We're relying on the
fact that we're no the stalest entry in the backend for this not to result in
our destruction?  But we haven't updated when we were last used yet.

And even if we had, there's nothing to prevent all other entries from being in
use, and this entry ending up being deleted by this call...Is there?

   }
 
-  UpdateRank(true);
+  UpdateStateOnUse(ENTRY_WAS_MODIFIED);
 
   if (!buf_len)
     return 0;
 
-  memcpy(&(data_[index])[offset], buf->data(), buf_len);
+  std::copy(buf->data(), buf->data() + buf_len, data_[index].begin() + offset);
   return buf_len;
 }
 
 int MemEntryImpl::InternalReadSparseData(int64_t offset,
                                          IOBuffer* buf,
                                          int buf_len) {
-  DCHECK(type() == kParentEntry);
+  DCHECK_EQ(PARENT_ENTRY, type());
 
   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.
   scoped_refptr<net::DrainableIOBuffer> io_buf(
       new net::DrainableIOBuffer(buf, buf_len));
 
   // Iterate until we have read enough.
   while (io_buf->BytesRemaining()) {
-    MemEntryImpl* child = OpenChild(offset + io_buf->BytesConsumed(), false);
+    MemEntryImpl* child = GetChild(offset + io_buf->BytesConsumed(), false);
 
     // No child present for that offset.
     if (!child)
       break;
 
     // We then need to prepare the child offset and len.
     int child_offset = ToChildOffset(offset + io_buf->BytesConsumed());
 
     // 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_.IsCapturing()) {
       net_log_.BeginEvent(
           net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
-          CreateNetLogSparseReadWriteCallback(child->net_log().source(),
+          CreateNetLogSparseReadWriteCallback(child->net_log_.source(),
                                               io_buf->BytesRemaining()));
     }
     int ret = child->ReadData(kSparseData, child_offset, io_buf.get(),
                               io_buf->BytesRemaining(), CompletionCallback());
     if (net_log_.IsCapturing()) {
       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);
-
+  UpdateStateOnUse(ENTRY_WAS_NOT_MODIFIED);
   return io_buf->BytesConsumed();
 }
 
 int MemEntryImpl::InternalWriteSparseData(int64_t offset,
                                           IOBuffer* buf,
                                           int buf_len) {
-  DCHECK(type() == kParentEntry);
+  DCHECK_EQ(PARENT_ENTRY, type());
 
   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);
+    MemEntryImpl* child = GetChild(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_.IsCapturing()) {
-      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);
     if (net_log_.IsCapturing()) {
       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
     // not aligned nor continuous. This is to enable witting to the middle
     // of an entry and still keep track of data off the aligned edge.
     if (data_size != child_offset)
       child->child_first_pos_ = child_offset;
 
     // Adjust the offset in the IO buffer.
     io_buf->DidConsume(ret);
   }
 
-  UpdateRank(true);
-
+  UpdateStateOnUse(ENTRY_WAS_MODIFIED);
   return io_buf->BytesConsumed();
 }
 
-int MemEntryImpl::GetAvailableRange(int64_t offset, int len, int64_t* start) {
-  DCHECK(type() == kParentEntry);
+int MemEntryImpl::InternalGetAvailableRange(int64_t offset,
+                                            int len,
+                                            int64_t* start) {
+  DCHECK_EQ(PARENT_ENTRY, type());
   DCHECK(start);
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || len < 0 || !start)
     return net::ERR_INVALID_ARGUMENT;
 
-  MemEntryImpl* current_child = NULL;
+  MemEntryImpl* current_child = nullptr;
 
   // Find the first child and record the number of empty bytes.
   int empty = FindNextChild(offset, len, &current_child);
   if (current_child && empty < len) {
     *start = offset + empty;
     len -= empty;
 
     // Counts the number of continuous bytes.
     int continuous = 0;
 
@@ skipping 13 matching lines @@
       // If the next child is discontinuous, break the loop.
       if (FindNextChild(*start + continuous, len, &current_child))
         break;
     }
     return continuous;
   }
   *start = offset;
   return 0;
 }
 
-void MemEntryImpl::PrepareTarget(int index, int offset, int buf_len) {
-  int entry_size = GetDataSize(index);
+bool MemEntryImpl::InitSparseInfo() {
+  DCHECK_EQ(PARENT_ENTRY, type());
 
-  if (entry_size >= offset + buf_len)
-    return;  // Not growing the stored data.
-
-  if (static_cast<int>(data_[index].size()) < offset + buf_len)
-    data_[index].resize(offset + buf_len);
-
-  if (offset <= entry_size)
-    return;  // There is no "hole" on the stored data.
-
-  // Cleanup the hole not written by the user. The point is to avoid returning
-  // random stuff later on.
-  memset(&(data_[index])[entry_size], 0, offset - entry_size);
-}
-
-void MemEntryImpl::UpdateRank(bool modified) {
-  Time current = Time::Now();
-  last_used_ = current;
-
-  if (modified)
-    last_modified_ = current;
-
-  if (!doomed_)
-    backend_->UpdateRank(this);
-}
-
-bool MemEntryImpl::InitSparseInfo() {
-  DCHECK(type() == kParentEntry);
-
-  if (!children_.get()) {
+  if (!children_) {
     // If we already have some data in sparse stream but we are being
     // initialized as a sparse entry, we should fail.
     if (GetDataSize(kSparseData))
       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,
-                                  net::NetLog* net_log) {
-  DCHECK(!parent_);
-  DCHECK(!child_id_);
-
-  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.
-  backend_->InsertIntoRankingList(this);
-  return true;
-}
-
-MemEntryImpl* MemEntryImpl::OpenChild(int64_t offset, bool create) {
-  DCHECK(type() == kParentEntry);
+MemEntryImpl* MemEntryImpl::GetChild(int64_t offset, bool create) {
+  DCHECK_EQ(PARENT_ENTRY, type());
   int index = ToChildIndex(offset);
   EntryMap::iterator i = children_->find(index);
-  if (i != children_->end()) {
+  if (i != children_->end())
     return i->second;
-  } else if (create) {
-    MemEntryImpl* child = new MemEntryImpl(backend_);
-    child->InitChildEntry(this, index, net_log_.net_log());
-    (*children_)[index] = child;
-    return child;
-  }
-  return NULL;
+  if (create)
+    return new MemEntryImpl(backend_, index, this, net_log_.net_log());
+  return nullptr;
 }
 
 int MemEntryImpl::FindNextChild(int64_t offset, int len, MemEntryImpl** child) {
   DCHECK(child);
-  *child = NULL;
+  *child = nullptr;
   int scanned_len = 0;
 
   // 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);
+    MemEntryImpl* current_child = GetChild(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);
 
       // 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;
 
          // 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