Remove NetLog::GetCaptureMode() and NetLogCaptureMode::None()

net/disk_cache/blockfile/sparse_control_v3.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/blockfile/sparse_control.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 145 matching lines @@
       NOTREACHED();
       return net::NetLog::TYPE_CANCELLED;
   }
 }
 
 // Logs the end event for |operation| on a child entry.  Range operations log
 // no events for each child they search through.
 void LogChildOperationEnd(const net::BoundNetLog& net_log,
                           disk_cache::SparseControl::SparseOperation operation,
                           int result) {
-  if (net_log.GetCaptureMode().enabled()) {
+  if (net_log.HasObservers()) {
     net::NetLog::EventType event_type;
     switch (operation) {
       case disk_cache::SparseControl::kReadOperation:
         event_type = net::NetLog::TYPE_SPARSE_READ_CHILD_DATA;
         break;
       case disk_cache::SparseControl::kWriteOperation:
         event_type = net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA;
         break;
       case disk_cache::SparseControl::kGetRangeOperation:
         return;
@@ skipping 70 matching lines @@
   offset_ = offset;
   user_buf_ = buf ? new net::DrainableIOBuffer(buf, buf_len) : NULL;
   buf_len_ = buf_len;
   user_callback_ = callback;
 
   result_ = 0;
   pending_ = false;
   finished_ = false;
   abort_ = false;
 
-  if (entry_->net_log().GetCaptureMode().enabled()) {
+  if (entry_->net_log().HasObservers()) {
     entry_->net_log().BeginEvent(
         GetSparseEventType(operation_),
         CreateNetLogSparseOperationCallback(offset_, buf_len_));
   }
   DoChildrenIO();
 
   if (!pending_) {
     // Everything was done synchronously.
     operation_ = kNoOperation;
     user_buf_ = NULL;
@@ skipping 288 matching lines @@
   finished_ = false;
   CompletionCallback callback;
   if (!user_callback_.is_null()) {
     callback =
         base::Bind(&SparseControl::OnChildIOCompleted, base::Unretained(this));
   }
 
   int rv = 0;
   switch (operation_) {
     case kReadOperation:
-      if (entry_->net_log().GetCaptureMode().enabled()) {
+      if (entry_->net_log().HasObservers()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
       rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_.get(),
                                 child_len_, callback);
       break;
     case kWriteOperation:
-      if (entry_->net_log().GetCaptureMode().enabled()) {
+      if (entry_->net_log().HasObservers()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
       rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_.get(),
                                  child_len_, callback, false);
       break;
     case kGetRangeOperation:
       rv = DoGetAvailableRange();
@@ skipping 252 matching lines @@
 }
 
 void SparseControl::OnChildIOCompleted(int result) {
   DCHECK_NE(net::ERR_IO_PENDING, result);
   DoChildIOCompleted(result);
 
   if (abort_) {
     // We'll return the current result of the operation, which may be less than
     // the bytes to read or write, but the user cancelled the operation.
     abort_ = false;
-    if (entry_->net_log().GetCaptureMode().enabled()) {
+    if (entry_->net_log().HasObservers()) {
       entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED);
       entry_->net_log().EndEvent(GetSparseEventType(operation_));
     }
     // We have an indirect reference to this object for every callback so if
     // there is only one callback, we may delete this object before reaching
     // DoAbortCallbacks.
     bool has_abort_callbacks = !abort_callbacks_.empty();
     DoUserCallback();
     if (has_abort_callbacks)
       DoAbortCallbacks();
     return;
   }
 
   // We are running a callback from the message loop. It's time to restart what
   // we were doing before.
   DoChildrenIO();
 }
 
 }  // namespace disk_cache