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

net/url_request/url_request_job.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/url_request/url_request_job.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/auth.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate.h"
 #include "net/filter/filter.h"
 #include "net/http/http_response_headers.h"
+#include "net/log/net_log_event_type.h"
 #include "net/nqe/network_quality_estimator.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
 
 namespace {
 
 // Callback for TYPE_URL_REQUEST_FILTERS_SET net-internals event.
 std::unique_ptr<base::Value> FiltersSetCallback(
     Filter* filter,
@@ skipping 454 matching lines @@
   if (request_->status().is_success())
     filter_ = SetupFilter();
 
   if (!filter_.get()) {
     std::string content_length;
     request_->GetResponseHeaderByName("content-length", &content_length);
     if (!content_length.empty())
       base::StringToInt64(content_length, &expected_content_size_);
   } else {
     request_->net_log().AddEvent(
-        NetLog::TYPE_URL_REQUEST_FILTERS_SET,
+        NetLogEventType::URL_REQUEST_FILTERS_SET,
         base::Bind(&FiltersSetCallback, base::Unretained(filter_.get())));
   }
 
   request_->NotifyResponseStarted(URLRequestStatus());
 
   // |this| may be destroyed at this point.
 }
 
 void URLRequestJob::ConvertResultToError(int result, Error* error, int* count) {
   if (result >= 0) {
@@ skipping 89 matching lines @@
 
   request_->set_is_pending(false);
   // With async IO, it's quite possible to have a few outstanding
   // requests.  We could receive a request to Cancel, followed shortly
   // by a successful IO.  For tracking the status(), once there is
   // an error, we do not change the status back to success.  To
   // enforce this, only set the status if the job is so far
   // successful.
   if (request_->status().is_success()) {
     if (status.status() == URLRequestStatus::FAILED)
-      request_->net_log().AddEventWithNetErrorCode(NetLog::TYPE_FAILED,
+      request_->net_log().AddEventWithNetErrorCode(NetLogEventType::FAILED,
                                                    status.error());
     request_->set_status(status);
   }
 
   // If the request succeeded (And wasn't cancelled) and the response code was
   // 4xx or 5xx, record whether or not the main frame was blank.  This is
   // intended to be a short-lived histogram, used to figure out how important
   // fixing http://crbug.com/331745 is.
   if (request_->status().is_success()) {
     int response_code = GetResponseCode();
@@ skipping 158 matching lines @@
           filter_needs_more_output_space_ = false;
           error = ERR_FAILED;
           break;
         }
       }
 
       // If logging all bytes is enabled, log the filtered bytes read.
       if (error == OK && filtered_data_len > 0 &&
           request()->net_log().IsCapturing()) {
         request()->net_log().AddByteTransferEvent(
-            NetLog::TYPE_URL_REQUEST_JOB_FILTERED_BYTES_READ, filtered_data_len,
-            filtered_read_buffer_->data());
+            NetLogEventType::URL_REQUEST_JOB_FILTERED_BYTES_READ,
+            filtered_data_len, filtered_read_buffer_->data());
       }
     } else {
       // we are done, or there is no data left.
       error = OK;
     }
     break;
   }
 
   if (error == OK) {
     // When we successfully finished a read, we no longer need to save the
@@ skipping 64 matching lines @@
   DCHECK_NE(ERR_IO_PENDING, error);
 
   if (error != OK) {
     raw_read_buffer_ = nullptr;
     return;
   }
   // If |filter_| is non-NULL, bytes will be logged after it is applied
   // instead.
   if (!filter_.get() && bytes_read > 0 && request()->net_log().IsCapturing()) {
     request()->net_log().AddByteTransferEvent(
-        NetLog::TYPE_URL_REQUEST_JOB_BYTES_READ, bytes_read,
+        NetLogEventType::URL_REQUEST_JOB_BYTES_READ, bytes_read,
         raw_read_buffer_->data());
   }
 
   if (bytes_read > 0) {
     RecordBytesRead(bytes_read);
   }
   raw_read_buffer_ = nullptr;
 }
 
 void URLRequestJob::RecordBytesRead(int bytes_read) {
@@ skipping 112 matching lines @@
   int64_t total_sent_bytes = GetTotalSentBytes();
   DCHECK_GE(total_sent_bytes, last_notified_total_sent_bytes_);
   if (total_sent_bytes > last_notified_total_sent_bytes_) {
     network_delegate_->NotifyNetworkBytesSent(
         request_, total_sent_bytes - last_notified_total_sent_bytes_);
   }
   last_notified_total_sent_bytes_ = total_sent_bytes;
 }
 
 }  // namespace net