Extracted NetLog class's inner enum types into their own enum classes and

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"
+#include "net/log/net_log_event_type.h"
+#include "net/log/net_log_source_type.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.
@@ skipping 94 matching lines @@
 
   last_used_ = Time::Now();
   if (modified_enum == ENTRY_WAS_MODIFIED)
     last_modified_ = last_used_;
 }
 
 void MemEntryImpl::Doom() {
   if (!doomed_) {
     doomed_ = true;
     backend_->OnEntryDoomed(this);
-    net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
+    net_log_.AddEvent(net::NetLogEventType::ENTRY_DOOM);
   }
   if (!ref_count_)
     delete this;
 }
 
 void MemEntryImpl::Close() {
   DCHECK_EQ(PARENT_ENTRY, type());
   --ref_count_;
   DCHECK_GE(ref_count_, 0);
   if (!ref_count_ && doomed_)
@@ skipping 17 matching lines @@
 int32_t MemEntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= kNumStreams)
     return 0;
   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,
+        net::NetLogEventType::ENTRY_READ_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
   }
 
   int result = InternalReadData(index, offset, buf, buf_len);
 
   if (net_log_.IsCapturing()) {
     net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_READ_DATA,
+        net::NetLogEventType::ENTRY_READ_DATA,
         CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
 int MemEntryImpl::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                             const CompletionCallback& callback, bool truncate) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
-        net::NetLog::TYPE_ENTRY_WRITE_DATA,
+        net::NetLogEventType::ENTRY_WRITE_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
   }
 
   int result = InternalWriteData(index, offset, buf, buf_len, truncate);
 
   if (net_log_.IsCapturing()) {
     net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_WRITE_DATA,
+        net::NetLogEventType::ENTRY_WRITE_DATA,
         CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
 int MemEntryImpl::ReadSparseData(int64_t offset,
                                  IOBuffer* buf,
                                  int buf_len,
                                  const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
-        net::NetLog::TYPE_SPARSE_READ,
+        net::NetLogEventType::SPARSE_READ,
         CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalReadSparseData(offset, buf, buf_len);
   if (net_log_.IsCapturing())
-    net_log_.EndEvent(net::NetLog::TYPE_SPARSE_READ);
+    net_log_.EndEvent(net::NetLogEventType::SPARSE_READ);
   return result;
 }
 
 int MemEntryImpl::WriteSparseData(int64_t offset,
                                   IOBuffer* buf,
                                   int buf_len,
                                   const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
-        net::NetLog::TYPE_SPARSE_WRITE,
+        net::NetLogEventType::SPARSE_WRITE,
         CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalWriteSparseData(offset, buf, buf_len);
   if (net_log_.IsCapturing())
-    net_log_.EndEvent(net::NetLog::TYPE_SPARSE_WRITE);
+    net_log_.EndEvent(net::NetLogEventType::SPARSE_WRITE);
   return result;
 }
 
 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,
+        net::NetLogEventType::SPARSE_GET_RANGE,
         CreateNetLogSparseOperationCallback(offset, len));
   }
   int result = InternalGetAvailableRange(offset, len, start);
   if (net_log_.IsCapturing()) {
     net_log_.EndEvent(
-        net::NetLog::TYPE_SPARSE_GET_RANGE,
+        net::NetLogEventType::SPARSE_GET_RANGE,
         CreateNetLogGetAvailableRangeResultCallback(*start, result));
   }
   return result;
 }
 
 bool MemEntryImpl::CouldBeSparse() const {
   DCHECK_EQ(PARENT_ENTRY, type());
   return (children_.get() != nullptr);
 }
 
@@ skipping 12 matching lines @@
       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,
+      net::BoundNetLog::Make(
+                         net_log, net::NetLogSourceType::MEMORY_CACHE_ENTRY);
+  net_log_.BeginEvent(net::NetLogEventType::DISK_CACHE_MEM_ENTRY_IMPL,
                       base::Bind(&NetLogEntryCreationCallback, this));
 }
 
 MemEntryImpl::~MemEntryImpl() {
   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();
       }
     }
   } else {
     parent_->children_->erase(child_id_);
   }
-  net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL);
+  net_log_.EndEvent(net::NetLogEventType::DISK_CACHE_MEM_ENTRY_IMPL);
 }
 
 int MemEntryImpl::InternalReadData(int index, int offset, IOBuffer* buf,
                                    int buf_len) {
   DCHECK(type() == PARENT_ENTRY || index == kSparseData);
 
   if (index < 0 || index >= kNumStreams || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = data_[index].size();
@@ skipping 74 matching lines @@
 
     // 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,
+          net::NetLogEventType::SPARSE_READ_CHILD_DATA,
           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);
+          net::NetLogEventType::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);
@@ skipping 27 matching lines @@
 
     // 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,
+      net_log_.BeginEvent(net::NetLogEventType::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);
+          net::NetLogEventType::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)
@@ skipping 107 matching lines @@
          scanned_len += first_pos - current_child_offset;
          break;
       }
     }
     scanned_len += kMaxSparseEntrySize - current_child_offset;
   }
   return scanned_len;
 }
 
 }  // namespace disk_cache