Disk Cache: Function re-ordering. No code change.

net/disk_cache/mem_entry_impl.cc

 // Copyright (c) 2006-2009 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/mem_entry_impl.h"
 
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/mem_backend_impl.h"
@@ skipping 36 matching lines @@
   for (int i = 0; i < NUM_STREAMS; i++)
     data_size_[i] = 0;
 }
 
 MemEntryImpl::~MemEntryImpl() {
   for (int i = 0; i < NUM_STREAMS; i++)
     backend_->ModifyStorageSize(data_size_[i], 0);
   backend_->ModifyStorageSize(static_cast<int32>(key_.size()), 0);
 }
 
-bool MemEntryImpl::CreateEntry(const std::string& key) {
-  key_ = key;
-  last_modified_ = Time::Now();
-  last_used_ = Time::Now();
-  Open();
-  backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
-  return true;
-}
-
-void MemEntryImpl::Close() {
-  // Only a parent entry can be closed.
-  DCHECK(type() == kParentEntry);
-  ref_count_--;
-  DCHECK(ref_count_ >= 0);
-  if (!ref_count_ && doomed_)
-    InternalDoom();
-}
-
-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(ref_count_ >= 0);
-  DCHECK(!doomed_);
-}
-
-bool MemEntryImpl::InUse() {
-  if (type() == kParentEntry) {
-    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).
-    return false;
-  }
-}
-
 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();
   }
 }
 
-void MemEntryImpl::InternalDoom() {
-  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_->size() == 0);
-      }
-    } else {
-      // If this is a child entry, detach it from the parent.
-      parent_->DetachChild(child_id_);
-    }
-    delete this;
-  }
+void MemEntryImpl::Close() {
+  // Only a parent entry can be closed.
+  DCHECK(type() == kParentEntry);
+  ref_count_--;
+  DCHECK(ref_count_ >= 0);
+  if (!ref_count_ && doomed_)
+    InternalDoom();
 }
 
 std::string MemEntryImpl::GetKey() const {
   // A child entry doesn't have key so this method should not be called.
   DCHECK(type() == kParentEntry);
   return key_;
 }
 
 Time MemEntryImpl::GetLastUsed() const {
   return last_used_;
@@ skipping 225 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;
 }
 
+// ------------------------------------------------------------------------
+
+bool MemEntryImpl::CreateEntry(const std::string& key) {
+  key_ = key;
+  last_modified_ = Time::Now();
+  last_used_ = Time::Now();
+  Open();
+  backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
+  return true;
+}
+
+void MemEntryImpl::InternalDoom() {
+  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_->size() == 0);
+      }
+    } else {
+      // If this is a child entry, detach it from the parent.
+      parent_->DetachChild(child_id_);
+    }
+    delete 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(ref_count_ >= 0);
+  DCHECK(!doomed_);
+}
+
+bool MemEntryImpl::InUse() {
+  if (type() == kParentEntry) {
+    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).
+    return false;
+  }
+}
+
+// ------------------------------------------------------------------------
+
 void MemEntryImpl::PrepareTarget(int index, int offset, int buf_len) {
   int entry_size = GetDataSize(index);
 
   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)
@@ skipping 89 matching lines @@
     scanned_len += kMaxSparseEntrySize - current_child_offset;
   }
   return scanned_len;
 }
 
 void MemEntryImpl::DetachChild(int child_id) {
   children_->erase(child_id);
 }
 
 }  // namespace disk_cache