Fixed first pass at adding http/backend cache events to the NetLog. ...

net/disk_cache/backend_impl.cc

 // Copyright (c) 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.
 
 #include "net/disk_cache/backend_impl.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
@@ skipping 176 matching lines @@
   return trial2->group() == group2a;
 }
 
 // ------------------------------------------------------------------------
 
 // This class takes care of building an instance of the backend.
 class CacheCreator {
  public:
   CacheCreator(const FilePath& path, bool force, int max_bytes,
                net::CacheType type, uint32 flags,
-               base::MessageLoopProxy* thread, disk_cache::Backend** backend,
+               base::MessageLoopProxy* thread, net::NetLog* net_log,
+               disk_cache::Backend** backend,
                net::CompletionCallback* callback)
       : path_(path), force_(force), retry_(false), max_bytes_(max_bytes),
         type_(type), flags_(flags), thread_(thread), backend_(backend),
-        callback_(callback), cache_(NULL),
+        callback_(callback), cache_(NULL), net_log_(net_log),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             my_callback_(this, &CacheCreator::OnIOComplete)) {
   }
   ~CacheCreator() {}
 
   // Creates the backend.
   int Run();
 
   // Callback implementation.
   void OnIOComplete(int result);
 
  private:
   void DoCallback(int result);
 
   const FilePath& path_;
   bool force_;
   bool retry_;
   int max_bytes_;
   net::CacheType type_;
   uint32 flags_;
   scoped_refptr<base::MessageLoopProxy> thread_;
   disk_cache::Backend** backend_;
   net::CompletionCallback* callback_;
   disk_cache::BackendImpl* cache_;
+  net::NetLog* net_log_;
   net::CompletionCallbackImpl<CacheCreator> my_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheCreator);
 };
 
 int CacheCreator::Run() {
-  cache_ = new disk_cache::BackendImpl(path_, thread_);
+  cache_ = new disk_cache::BackendImpl(path_, thread_, net_log_);
   cache_->SetMaxSize(max_bytes_);
   cache_->SetType(type_);
   cache_->SetFlags(flags_);
   int rv = cache_->Init(&my_callback_);
   DCHECK_EQ(net::ERR_IO_PENDING, rv);
   return rv;
 }
 
 void CacheCreator::OnIOComplete(int result) {
   if (result == net::OK || !force_ || retry_)
@@ skipping 45 matching lines @@
 }
 
 }  // namespace
 
 // ------------------------------------------------------------------------
 
 namespace disk_cache {
 
 int CreateCacheBackend(net::CacheType type, const FilePath& path, int max_bytes,
                        bool force, base::MessageLoopProxy* thread,
-                       Backend** backend, CompletionCallback* callback) {
+                       net::NetLog* net_log, Backend** backend,
+                       CompletionCallback* callback) {
   DCHECK(callback);
   if (type == net::MEMORY_CACHE) {
     *backend = MemBackendImpl::CreateBackend(max_bytes);
     return *backend ? net::OK : net::ERR_FAILED;
   }
   DCHECK(thread);
 
   return BackendImpl::CreateBackend(path, force, max_bytes, type, kNone, thread,
-                                    backend, callback);
+                                    net_log, backend, callback);
 }
 
 // Returns the preferred maximum number of bytes for the cache given the
 // number of available bytes.
 int PreferedCacheSize(int64 available) {
   // Return 80% of the available space if there is not enough space to use
   // kDefaultCacheSize.
   if (available < kDefaultCacheSize * 10 / 8)
     return static_cast<int32>(available * 8 / 10);
 
@@ skipping 26 matching lines @@
 // number, (located on the same parent folder), and spawn a worker thread to
 // delete all the files on all the stale cache folders. The whole process can
 // still fail if we are not able to rename the cache folder (for instance due to
 // a sharing violation), and in that case a cache for this profile (on the
 // desired path) cannot be created.
 //
 // Static.
 int BackendImpl::CreateBackend(const FilePath& full_path, bool force,
                                int max_bytes, net::CacheType type,
                                uint32 flags, base::MessageLoopProxy* thread,
-                               Backend** backend,
+                               net::NetLog* net_log, Backend** backend,
                                CompletionCallback* callback) {
   DCHECK(callback);
   CacheCreator* creator = new CacheCreator(full_path, force, max_bytes, type,
-                                           flags, thread, backend, callback);
+                                           flags, thread, net_log, backend,
+                                           callback);
   // This object will self-destroy when finished.
   return creator->Run();
 }
 
 int BackendImpl::Init(CompletionCallback* callback) {
   background_queue_.Init(callback);
   return net::ERR_IO_PENDING;
 }
 
 BackendImpl::BackendImpl(const FilePath& path,
-                         base::MessageLoopProxy* cache_thread)
+                         base::MessageLoopProxy* cache_thread,
+                         net::NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(background_queue_(this, cache_thread)),
       path_(path),
       block_files_(path),
       mask_(0),
       max_size_(0),
       io_delay_(0),
       cache_type_(net::DISK_CACHE),
       uma_report_(0),
       user_flags_(0),
       init_(false),
       restarted_(false),
       unit_test_(false),
       read_only_(false),
       new_eviction_(false),
       first_timer_(true),
       throttle_requests_(false),
+      net_log_(net_log),
       done_(true, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
 }
 
 BackendImpl::BackendImpl(const FilePath& path,
                          uint32 mask,
-                         base::MessageLoopProxy* cache_thread)
+                         base::MessageLoopProxy* cache_thread,
+                         net::NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(background_queue_(this, cache_thread)),
       path_(path),
       block_files_(path),
       mask_(mask),
       max_size_(0),
       io_delay_(0),
       cache_type_(net::DISK_CACHE),
       uma_report_(0),
       user_flags_(kMask),
       init_(false),
       restarted_(false),
       unit_test_(false),
       read_only_(false),
       new_eviction_(false),
       first_timer_(true),
       throttle_requests_(false),
+      net_log_(net_log),
       done_(true, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
 }
 
 BackendImpl::~BackendImpl() {
   background_queue_.WaitForPendingIO();
 
   if (background_queue_.BackgroundIsCurrentThread()) {
     // Unit tests may use the same thread for everything.
@@ skipping 421 matching lines @@
   IncreaseNumRefs();
 
   if (!cache_entry->CreateEntry(node_address, key, hash)) {
     block_files_.DeleteBlock(entry_address, false);
     block_files_.DeleteBlock(node_address, false);
     LOG(ERROR) << "Create entry failed " << key.c_str();
     stats_.OnEvent(Stats::CREATE_ERROR);
     return NULL;
   }
 
+  cache_entry->BeginLogging(net_log_, true);
+
   // We are not failing the operation; let's add this to the map.
   open_entries_[entry_address.value()] = cache_entry;
 
   if (parent.get())
     parent->SetNextAddress(entry_address);
 
   block_files_.GetFile(entry_address)->Store(cache_entry->entry());
   block_files_.GetFile(node_address)->Store(cache_entry->rankings());
 
   IncreaseNumEntries();
@@ skipping 669 matching lines @@
     return ERR_INVALID_LINKS;
 
   if (*dirty) {
     Trace("Dirty entry 0x%p 0x%x", reinterpret_cast<void*>(cache_entry.get()),
           address.value());
   } else {
     // We only add clean entries to the map.
     open_entries_[address.value()] = cache_entry;
   }
 
+  cache_entry->BeginLogging(net_log_, false);
   cache_entry.swap(entry);
   return 0;
 }
 
 EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
                                    bool find_parent) {
   Addr address(data_->table[hash & mask_]);
   scoped_refptr<EntryImpl> cache_entry, parent_entry;
   EntryImpl* tmp = NULL;
   bool found = false;
@@ skipping 534 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache