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

net/quic/chromium/quic_http_stream.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/quic/chromium/quic_http_stream.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
+#include "net/log/net_log_event_type.h"
 #include "net/quic/core/quic_client_promised_info.h"
 #include "net/quic/core/quic_http_utils.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/ssl/ssl_info.h"
 
 namespace net {
@@ skipping 80 matching lines @@
   if (stream) {
     stream_ = static_cast<QuicChromiumClientStream*>(stream);
     stream_->SetDelegate(this);
   }
   // callback_ should be non-null in the case of asynchronous
   // rendezvous; i.e. |Try()| returned QUIC_PENDING.
   if (!callback_.is_null()) {
     if (stream) {
       next_state_ = STATE_OPEN;
       stream_net_log_.AddEvent(
-          NetLog::TYPE_QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
+          NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
           base::Bind(&NetLogQuicPushStreamCallback, stream_->id(),
                      &request_info_->url));
       session_->net_log().AddEvent(
-          NetLog::TYPE_QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
+          NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
           base::Bind(&NetLogQuicPushStreamCallback, stream_->id(),
                      &request_info_->url));
       DoCallback(OK);
       return;
     }
     // rendezvous has failed so proceed as with a non-push request.
     next_state_ = STATE_REQUEST_STREAM;
     OnIOComplete(OK);
   }
 }
 
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   DCHECK(!stream_);
   if (!session_)
     return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED
                                     : ERR_QUIC_HANDSHAKE_FAILED;
 
   stream_net_log.AddEvent(
-      NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_QUIC_SESSION,
+      NetLogEventType::HTTP_STREAM_REQUEST_BOUND_TO_QUIC_SESSION,
       session_->net_log().source().ToEventParametersCallback());
 
   stream_net_log_ = stream_net_log;
   request_info_ = request_info;
   request_time_ = base::Time::Now();
   priority_ = priority;
 
   bool success = session_->GetSSLInfo(&ssl_info_);
   DCHECK(success);
   DCHECK(ssl_info_.cert.get());
 
   std::string url(request_info->url.spec());
   QuicClientPromisedInfo* promised =
       session_->push_promise_index()->GetPromised(url);
   if (promised) {
     found_promise_ = true;
     stream_net_log_.AddEvent(
-        NetLog::TYPE_QUIC_HTTP_STREAM_PUSH_PROMISE_RENDEZVOUS,
+        NetLogEventType::QUIC_HTTP_STREAM_PUSH_PROMISE_RENDEZVOUS,
         base::Bind(&NetLogQuicPushStreamCallback, promised->id(),
                    &request_info_->url));
     session_->net_log().AddEvent(
-        NetLog::TYPE_QUIC_HTTP_STREAM_PUSH_PROMISE_RENDEZVOUS,
+        NetLogEventType::QUIC_HTTP_STREAM_PUSH_PROMISE_RENDEZVOUS,
         base::Bind(&NetLogQuicPushStreamCallback, promised->id(),
                    &request_info_->url));
     return OK;
   }
 
   next_state_ = STATE_REQUEST_STREAM;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
@@ skipping 39 matching lines @@
 
   switch (push_status) {
     case QUIC_FAILURE:
       // Push rendezvous failed.
       next_state_ = STATE_REQUEST_STREAM;
       break;
     case QUIC_SUCCESS:
       next_state_ = STATE_OPEN;
       if (!CancelPromiseIfHasBody()) {
         stream_net_log_.AddEvent(
-            NetLog::TYPE_QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
+            NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
             base::Bind(&NetLogQuicPushStreamCallback, stream_->id(),
                        &request_info_->url));
         session_->net_log().AddEvent(
-            NetLog::TYPE_QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
+            NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
             base::Bind(&NetLogQuicPushStreamCallback, stream_->id(),
                        &request_info_->url));
         // Avoid the call to |DoLoop()| below, which would reset
         // next_state_ to STATE_NONE.
         return OK;
       }
 
       break;
     case QUIC_PENDING:
       if (!CancelPromiseIfHasBody()) {
@@ skipping 441 matching lines @@
   next_state_ = STATE_SEND_HEADERS;
   return OK;
 }
 
 int QuicHttpStream::DoSendHeaders() {
   if (!stream_)
     return ERR_UNEXPECTED;
 
   // Log the actual request with the URL Request's net log.
   stream_net_log_.AddEvent(
-      NetLog::TYPE_HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS,
+      NetLogEventType::HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS,
       base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
                  priority_));
   bool has_upload_data = request_body_stream_ != nullptr;
 
   next_state_ = STATE_SEND_HEADERS_COMPLETE;
   size_t frame_len = stream_->WriteHeaders(std::move(request_headers_),
                                            !has_upload_data, nullptr);
   headers_bytes_sent_ += frame_len;
 
   request_headers_ = SpdyHeaderBlock();
@@ skipping 131 matching lines @@
   closed_stream_sent_bytes_ = stream_->stream_bytes_written();
   stream_ = nullptr;
 
   // If |request_body_stream_| is non-NULL, Reset it, to abort any in progress
   // read.
   if (request_body_stream_)
     request_body_stream_->Reset();
 }
 
 }  // namespace net