Refactor NetLog::LogLevel --> NetLogCaptureMode.

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 30 matching lines @@
 // 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().
 base::Value* NetLogChildEntryCreationCallback(
     const disk_cache::MemEntryImpl* parent,
     int child_id,
-    net::NetLog::LogLevel /* log_level */) {
+    net::NetLogCaptureMode /* capture_mode */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("key", GenerateChildName(parent->GetKey(), child_id));
   dict->SetBoolean("created", true);
   return dict;
 }
 
 }  // namespace
 
 namespace disk_cache {
 
@@ skipping 116 matching lines @@
 }
 
 int32 MemEntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= NUM_STREAMS)
     return 0;
   return data_size_[index];
 }
 
 int MemEntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
                            const CompletionCallback& callback) {
-  if (net_log_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
   }
 
   int result = InternalReadData(index, offset, buf, buf_len);
 
-  if (net_log_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_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_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
   }
 
   int result = InternalWriteData(index, offset, buf, buf_len, truncate);
 
-  if (net_log_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
         CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
 int MemEntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
                                  const CompletionCallback& callback) {
-  if (net_log_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_READ,
         CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalReadSparseData(offset, buf, buf_len);
-  if (net_log_.IsLogging())
+  if (net_log_.GetCaptureMode().enabled())
     net_log_.EndEvent(net::NetLog::TYPE_SPARSE_READ);
   return result;
 }
 
 int MemEntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
                                   const CompletionCallback& callback) {
-  if (net_log_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_WRITE,
         CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalWriteSparseData(offset, buf, buf_len);
-  if (net_log_.IsLogging())
+  if (net_log_.GetCaptureMode().enabled())
     net_log_.EndEvent(net::NetLog::TYPE_SPARSE_WRITE);
   return result;
 }
 
 int MemEntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
                                     const CompletionCallback& callback) {
-  if (net_log_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
         CreateNetLogSparseOperationCallback(offset, len));
   }
   int result = GetAvailableRange(offset, len, start);
-  if (net_log_.IsLogging()) {
+  if (net_log_.GetCaptureMode().enabled()) {
     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);
@@ skipping 99 matching lines @@
     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_.IsLogging()) {
+    if (net_log_.GetCaptureMode().enabled()) {
       net_log_.BeginEvent(
           net::NetLog::TYPE_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_.IsLogging()) {
+    if (net_log_.GetCaptureMode().enabled()) {
       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;
 
@@ skipping 28 matching lines @@
     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_.IsLogging()) {
+    if (net_log_.GetCaptureMode().enabled()) {
       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_.IsLogging()) {
+    if (net_log_.GetCaptureMode().enabled()) {
       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
@@ skipping 165 matching lines @@
     scanned_len += kMaxSparseEntrySize - current_child_offset;
   }
   return scanned_len;
 }
 
 void MemEntryImpl::DetachChild(int child_id) {
   children_->erase(child_id);
 }
 
 }  // namespace disk_cache