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

net/disk_cache/blockfile/sparse_control.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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/disk_cache/blockfile/file.h"
 #include "net/disk_cache/net_log_parameters.h"
+#include "net/log/net_log_event_type.h"
 
 using base::Time;
 
 namespace {
 
 // Stream of the sparse data index.
 const int kSparseIndex = 2;
 
 // Stream of the sparse data.
 const int kSparseData = 1;
@@ skipping 105 matching lines @@
   std::string child_name = GenerateChildName(name_, signature_, child_id);
   backend_->SyncDoomEntry(child_name);
   children_map_.Set(child_id, false);
 
   // Post a task to delete the next child.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ChildrenDeleter::DeleteChildren, this));
 }
 
 // Returns the NetLog event type corresponding to a SparseOperation.
-net::NetLog::EventType GetSparseEventType(
+net::NetLogEventType GetSparseEventType(
     disk_cache::SparseControl::SparseOperation operation) {
   switch (operation) {
     case disk_cache::SparseControl::kReadOperation:
-      return net::NetLog::TYPE_SPARSE_READ;
+      return net::NetLogEventType::SPARSE_READ;
     case disk_cache::SparseControl::kWriteOperation:
-      return net::NetLog::TYPE_SPARSE_WRITE;
+      return net::NetLogEventType::SPARSE_WRITE;
     case disk_cache::SparseControl::kGetRangeOperation:
-      return net::NetLog::TYPE_SPARSE_GET_RANGE;
+      return net::NetLogEventType::SPARSE_GET_RANGE;
     default:
       NOTREACHED();
-      return net::NetLog::TYPE_CANCELLED;
+      return net::NetLogEventType::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.IsCapturing()) {
-    net::NetLog::EventType event_type;
+    net::NetLogEventType event_type;
     switch (operation) {
       case disk_cache::SparseControl::kReadOperation:
-        event_type = net::NetLog::TYPE_SPARSE_READ_CHILD_DATA;
+        event_type = net::NetLogEventType::SPARSE_READ_CHILD_DATA;
         break;
       case disk_cache::SparseControl::kWriteOperation:
-        event_type = net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA;
+        event_type = net::NetLogEventType::SPARSE_WRITE_CHILD_DATA;
         break;
       case disk_cache::SparseControl::kGetRangeOperation:
         return;
       default:
         NOTREACHED();
         return;
     }
     net_log.EndEventWithNetErrorCode(event_type, result);
   }
 }
@@ skipping 164 matching lines @@
   int map_len = data_len - sizeof(SparseHeader);
   if (map_len > kMaxMapSize || map_len % 4)
     return;
 
   char* buffer;
   Addr address;
   entry->GetData(kSparseIndex, &buffer, &address);
   if (!buffer && !address.is_initialized())
     return;
 
-  entry->net_log().AddEvent(net::NetLog::TYPE_SPARSE_DELETE_CHILDREN);
+  entry->net_log().AddEvent(net::NetLogEventType::SPARSE_DELETE_CHILDREN);
 
   DCHECK(entry->backend_.get());
   ChildrenDeleter* deleter = new ChildrenDeleter(entry->backend_.get(),
                                                  entry->GetKey());
   // The object will self destruct when finished.
   deleter->AddRef();
 
   if (buffer) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
@@ skipping 309 matching lines @@
   SetChildBit(true);
 }
 
 void SparseControl::DoChildrenIO() {
   while (DoChildIO()) continue;
 
   // Range operations are finished synchronously, often without setting
   // |finished_| to true.
   if (kGetRangeOperation == operation_ && entry_->net_log().IsCapturing()) {
     entry_->net_log().EndEvent(
-        net::NetLog::TYPE_SPARSE_GET_RANGE,
+        net::NetLogEventType::SPARSE_GET_RANGE,
         CreateNetLogGetAvailableRangeResultCallback(offset_, result_));
   }
   if (finished_) {
     if (kGetRangeOperation != operation_ && entry_->net_log().IsCapturing()) {
       entry_->net_log().EndEvent(GetSparseEventType(operation_));
     }
     if (pending_)
       DoUserCallback();  // Don't touch this object after this point.
   }
 }
@@ skipping 15 matching lines @@
   if (!user_callback_.is_null()) {
     callback =
         base::Bind(&SparseControl::OnChildIOCompleted, base::Unretained(this));
   }
 
   int rv = 0;
   switch (operation_) {
     case kReadOperation:
       if (entry_->net_log().IsCapturing()) {
         entry_->net_log().BeginEvent(
-            net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
+            net::NetLogEventType::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().IsCapturing()) {
         entry_->net_log().BeginEvent(
-            net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
+            net::NetLogEventType::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();
       break;
     default:
@@ skipping 108 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().IsCapturing()) {
-      entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED);
+      entry_->net_log().AddEvent(net::NetLogEventType::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;
@@ skipping 23 matching lines @@
     CompletionCallback cb = abort_callbacks_[i];
     if (i == abort_callbacks_.size() - 1)
       abort_callbacks_.clear();
 
     entry_->Release();  // Don't touch object after this line.
     cb.Run(net::OK);
   }
 }
 
 }  // namespace disk_cache