Adds memory cache logging, and updates disk cache logging

net/disk_cache/mem_entry_impl.h

 // Copyright (c) 2006-2010 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.
 
 #ifndef NET_DISK_CACHE_MEM_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_MEM_ENTRY_IMPL_H_
 #pragma once
 
 #include "base/hash_tables.h"
 #include "base/scoped_ptr.h"
+#include "net/base/net_log.h"
 #include "net/disk_cache/disk_cache.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 namespace disk_cache {
 
 class MemBackendImpl;
 
 // This class implements the Entry interface for the memory-only cache. An
 // object of this class represents a single entry on the cache. We use two
 // types of entries, parent and child to support sparse caching.
@@ skipping 26 matching lines @@
  public:
   enum EntryType {
     kParentEntry,
     kChildEntry,
   };
 
   explicit MemEntryImpl(MemBackendImpl* backend);
 
   // Performs the initialization of a EntryImpl that will be added to the
   // cache.
-  bool CreateEntry(const std::string& key);
+  bool CreateEntry(const std::string& key, net::NetLog* net_log);
 
   // Permanently destroys this entry.
   void InternalDoom();
 
   void Open();
   bool InUse();
 
   MemEntryImpl* next() const {
     return next_;
   }
 
   MemEntryImpl* prev() const {
     return prev_;
   }
 
   void set_next(MemEntryImpl* next) {
     next_ = next;
   }
 
   void set_prev(MemEntryImpl* prev) {
     prev_ = prev;
   }
 
   EntryType type() const {
     return parent_ ? kChildEntry : kParentEntry;
   }
 
+  std::string& key() {
+    return key_;
+  }
+
+  net::BoundNetLog& net_log() {
+    return net_log_;
+  }
+
   // Entry interface.
   virtual void Doom();
   virtual void Close();
   virtual std::string GetKey() const;
   virtual base::Time GetLastUsed() const;
   virtual base::Time GetLastModified() const;
   virtual int32 GetDataSize(int index) const;
   virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
                        net::CompletionCallback* completion_callback);
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
@@ skipping 11 matching lines @@
 
  private:
   typedef base::hash_map<int, MemEntryImpl*> EntryMap;
 
   enum {
     NUM_STREAMS = 3
   };
 
   ~MemEntryImpl();
 
+  // Do all the work for corresponding public functions.  Implemented as
+  // separate functions to make logging of results simpler.
+  int InternalReadData(int index, int offset, net::IOBuffer* buf, int buf_len);
+  int InternalWriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
+                        bool truncate);
+  int InternalReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len);
+  int InternalWriteSparseData(int64 offset, net::IOBuffer* buf, int buf_len);
+
   // Old Entry interface.
   int GetAvailableRange(int64 offset, int len, int64* start);
 
   // Grows and cleans up the data buffer.
   void PrepareTarget(int index, int offset, int buf_len);
 
   // Updates ranking information.
   void UpdateRank(bool modified);
 
   // Initializes the children map and sparse info. This method is only called
   // on a parent entry.
   bool InitSparseInfo();
 
   // Performs the initialization of a MemEntryImpl as a child entry.
   // |parent| is the pointer to the parent entry. |child_id| is the ID of
   // the new child.
-  bool InitChildEntry(MemEntryImpl* parent, int child_id);
+  bool InitChildEntry(MemEntryImpl* parent, int child_id, net::NetLog* net_log);
 
   // Returns an entry responsible for |offset|. The returned entry can be a
   // child entry or this entry itself if |offset| points to the first range.
   // If such entry does not exist and |create| is true, a new child entry is
   // created.
   MemEntryImpl* OpenChild(int64 offset, bool create);
 
   // Finds the first child located within the range [|offset|, |offset + len|).
   // Returns the number of bytes ahead of |offset| to reach the first available
   // bytes in the entry. The first child found is output to |child|.
@@ skipping 13 matching lines @@
   MemEntryImpl* next_;        // Pointers for the LRU list.
   MemEntryImpl* prev_;
   MemEntryImpl* parent_;      // Pointer to the parent entry.
   scoped_ptr<EntryMap> children_;
 
   base::Time last_modified_;  // LRU information.
   base::Time last_used_;
   MemBackendImpl* backend_;   // Back pointer to the cache.
   bool doomed_;               // True if this entry was removed from the cache.
 
+  net::BoundNetLog net_log_;
+
   DISALLOW_COPY_AND_ASSIGN(MemEntryImpl);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_MEM_ENTRY_IMPL_H_