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

net/http/bidirectional_stream_unittest.cc

 // Copyright 2015 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/http/bidirectional_stream.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "base/timer/mock_timer.h"
 #include "net/base/net_errors.h"
 #include "net/http/bidirectional_stream_request_info.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_server_properties.h"
 #include "net/log/net_log.h"
+#include "net/log/net_log_event_type.h"
+#include "net/log/net_log_source_type.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_util.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 562 matching lines @@
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
 
   // Destroy the delegate will destroy the stream, so we can get an end event
   // for BIDIRECTIONAL_STREAM_ALIVE.
   delegate.reset();
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
 
   size_t index = ExpectLogContainsSomewhere(
-      entries, 0, NetLog::TYPE_BIDIRECTIONAL_STREAM_ALIVE, NetLog::PHASE_BEGIN);
+      entries, 0, NetLogEventType::BIDIRECTIONAL_STREAM_ALIVE,
+      NetLogEventPhase::BEGIN);
   // HTTP_STREAM_REQUEST is nested inside in BIDIRECTIONAL_STREAM_ALIVE.
-  index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_HTTP_STREAM_REQUEST, NetLog::PHASE_BEGIN);
-  index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_HTTP_STREAM_REQUEST, NetLog::PHASE_END);
+  index = ExpectLogContainsSomewhere(entries, index,
+                                     NetLogEventType::HTTP_STREAM_REQUEST,
+                                     NetLogEventPhase::BEGIN);
+  index = ExpectLogContainsSomewhere(entries, index,
+                                     NetLogEventType::HTTP_STREAM_REQUEST,
+                                     NetLogEventPhase::END);
   // Headers received should happen after HTTP_STREAM_REQUEST.
   index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_RECV_HEADERS,
-      NetLog::PHASE_NONE);
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_RECV_HEADERS,
+      NetLogEventPhase::NONE);
   // Trailers received should happen after headers received. It might happen
   // before the reads complete.
-  ExpectLogContainsSomewhere(entries, index,
-                             NetLog::TYPE_BIDIRECTIONAL_STREAM_RECV_TRAILERS,
-                             NetLog::PHASE_NONE);
+  ExpectLogContainsSomewhere(
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_RECV_TRAILERS,
+      NetLogEventPhase::NONE);
   index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_SEND_DATA,
-      NetLog::PHASE_NONE);
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_SEND_DATA,
+      NetLogEventPhase::NONE);
   index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_READ_DATA,
-      NetLog::PHASE_NONE);
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_READ_DATA,
+      NetLogEventPhase::NONE);
   TestNetLogEntry entry = entries[index];
   int read_result = 0;
   EXPECT_TRUE(entry.params->GetInteger("rv", &read_result));
   EXPECT_EQ(ERR_IO_PENDING, read_result);
 
   // Sent bytes. Sending data is always asynchronous.
   index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT,
-      NetLog::PHASE_NONE);
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT,
+      NetLogEventPhase::NONE);
   entry = entries[index];
-  EXPECT_EQ(NetLog::SOURCE_BIDIRECTIONAL_STREAM, entry.source.type);
+  EXPECT_EQ(NetLogSourceType::BIDIRECTIONAL_STREAM, entry.source.type);
   // Received bytes for asynchronous read.
   index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_RECEIVED,
-      NetLog::PHASE_NONE);
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_RECEIVED,
+      NetLogEventPhase::NONE);
   entry = entries[index];
-  EXPECT_EQ(NetLog::SOURCE_BIDIRECTIONAL_STREAM, entry.source.type);
+  EXPECT_EQ(NetLogSourceType::BIDIRECTIONAL_STREAM, entry.source.type);
   // Received bytes for synchronous read.
   index = ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_RECEIVED,
-      NetLog::PHASE_NONE);
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_RECEIVED,
+      NetLogEventPhase::NONE);
   entry = entries[index];
-  EXPECT_EQ(NetLog::SOURCE_BIDIRECTIONAL_STREAM, entry.source.type);
+  EXPECT_EQ(NetLogSourceType::BIDIRECTIONAL_STREAM, entry.source.type);
   ExpectLogContainsSomewhere(entries, index,
-                             NetLog::TYPE_BIDIRECTIONAL_STREAM_ALIVE,
-                             NetLog::PHASE_END);
+                             NetLogEventType::BIDIRECTIONAL_STREAM_ALIVE,
+                             NetLogEventPhase::END);
 }
 
 TEST_F(BidirectionalStreamTest, TestInterleaveReadDataAndSendData) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
   SpdySerializedFrame data_frame1(spdy_util_.ConstructSpdyDataFrame(
       1, kBodyData, kBodyDataSize, /*fin=*/false));
   SpdySerializedFrame data_frame2(spdy_util_.ConstructSpdyDataFrame(
       1, kBodyData, kBodyDataSize, /*fin=*/false));
   SpdySerializedFrame data_frame3(spdy_util_.ConstructSpdyDataFrame(
@@ skipping 147 matching lines @@
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
 
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
   size_t index = ExpectLogContainsSomewhere(
-      entries, 0, NetLog::TYPE_BIDIRECTIONAL_STREAM_SENDV_DATA,
-      NetLog::PHASE_NONE);
+      entries, 0, NetLogEventType::BIDIRECTIONAL_STREAM_SENDV_DATA,
+      NetLogEventPhase::NONE);
   TestNetLogEntry entry = entries[index];
   int num_buffers = 0;
   EXPECT_TRUE(entry.params->GetInteger("num_buffers", &num_buffers));
   EXPECT_EQ(2, num_buffers);
 
   index = ExpectLogContainsSomewhereAfter(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
-      NetLog::PHASE_BEGIN);
+      entries, index,
+      NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
+      NetLogEventPhase::BEGIN);
   entry = entries[index];
   int num_buffers_coalesced = 0;
   EXPECT_TRUE(entry.params->GetInteger("num_buffers_coalesced",
                                        &num_buffers_coalesced));
   EXPECT_EQ(2, num_buffers_coalesced);
 
   index = ExpectLogContainsSomewhereAfter(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT,
-      NetLog::PHASE_NONE);
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT,
+      NetLogEventPhase::NONE);
   entry = entries[index];
   int byte_count = 0;
   EXPECT_TRUE(entry.params->GetInteger("byte_count", &byte_count));
   EXPECT_EQ(buf->size(), byte_count);
 
   index = ExpectLogContainsSomewhereAfter(
-      entries, index + 1, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT,
-      NetLog::PHASE_NONE);
+      entries, index + 1, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT,
+      NetLogEventPhase::NONE);
   entry = entries[index];
   byte_count = 0;
   EXPECT_TRUE(entry.params->GetInteger("byte_count", &byte_count));
   EXPECT_EQ(buf2->size(), byte_count);
 
   ExpectLogContainsSomewhere(
-      entries, index, NetLog::TYPE_BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
-      NetLog::PHASE_END);
+      entries, index,
+      NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
+      NetLogEventPhase::END);
 }
 
 // Tests that BidirectionalStreamSpdyImpl::OnClose will complete any remaining
 // read even if the read queue is empty.
 TEST_F(BidirectionalStreamTest, TestCompleteAsyncRead) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
   // Empty DATA frame with an END_STREAM flag.
   SpdySerializedFrame end_stream(
       spdy_util_.ConstructSpdyDataFrame(1, nullptr, 0, true));
 
@@ skipping 374 matching lines @@
   // BidirectionalStreamSpdyStreamJob does not count the bytes sent for |rst|
   // because it is sent after SpdyStream::Delegate::OnClose is called.
   EXPECT_EQ(CountWriteBytes(writes, 1), delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
 
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
 
   size_t index = ExpectLogContainsSomewhere(
-      entries, 0, NetLog::TYPE_BIDIRECTIONAL_STREAM_READY, NetLog::PHASE_NONE);
+      entries, 0, NetLogEventType::BIDIRECTIONAL_STREAM_READY,
+      NetLogEventPhase::NONE);
   TestNetLogEntry entry = entries[index];
   bool request_headers_sent = false;
   EXPECT_TRUE(
       entry.params->GetBoolean("request_headers_sent", &request_headers_sent));
   EXPECT_TRUE(request_headers_sent);
 
-  index = ExpectLogContainsSomewhere(entries, index,
-                                     NetLog::TYPE_BIDIRECTIONAL_STREAM_FAILED,
-                                     NetLog::PHASE_NONE);
+  index = ExpectLogContainsSomewhere(
+      entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_FAILED,
+      NetLogEventPhase::NONE);
   entry = entries[index];
   int net_error = OK;
   EXPECT_TRUE(entry.params->GetInteger("net_error", &net_error));
   EXPECT_THAT(net_error, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnHeadersReceived) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
 
   SpdySerializedFrame rst(
@@ skipping 261 matching lines @@
       http_session_->http_server_properties()->GetAlternativeServices(
           url::SchemeHostPort(default_url_));
   ASSERT_EQ(1u, alternative_service_vector.size());
   EXPECT_EQ(AlternateProtocolFromNextProto(kProtoQUIC1SPDY3),
             alternative_service_vector[0].protocol);
   EXPECT_EQ("www.example.org", alternative_service_vector[0].host);
   EXPECT_EQ(443, alternative_service_vector[0].port);
 }
 
 }  // namespace net