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

net/socket/websocket_transport_client_socket_pool.cc

 // Copyright 2014 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/socket/websocket_transport_client_socket_pool.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "net/base/net_errors.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/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/websocket_endpoint_lock_manager.h"
 #include "net/socket/websocket_transport_connect_sub_job.h"
 
 namespace net {
 
 WebSocketTransportConnectJob::WebSocketTransportConnectJob(
     const std::string& group_name,
     RequestPriority priority,
     ClientSocketPool::RespectLimits respect_limits,
     const scoped_refptr<TransportSocketParams>& params,
     base::TimeDelta timeout_duration,
     const CompletionCallback& callback,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     ClientSocketHandle* handle,
     Delegate* delegate,
     NetLog* pool_net_log,
     const BoundNetLog& request_net_log)
     : ConnectJob(group_name,
                  timeout_duration,
                  priority,
                  respect_limits,
                  delegate,
-                 BoundNetLog::Make(pool_net_log, NetLog::SOURCE_CONNECT_JOB)),
+                 BoundNetLog::Make(pool_net_log,
+                                   NetLogSourceType::CONNECT_JOB)),
       params_(params),
       resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       next_state_(STATE_NONE),
       race_result_(TransportConnectJob::RACE_UNKNOWN),
       handle_(handle),
       callback_(callback),
       request_net_log_(request_net_log),
       had_ipv4_(false),
       had_ipv6_(false) {}
@@ skipping 266 matching lines @@
     const BoundNetLog& request_net_log) {
   DCHECK(params);
   const scoped_refptr<TransportSocketParams>& casted_params =
       *static_cast<const scoped_refptr<TransportSocketParams>*>(params);
 
   NetLogTcpClientSocketPoolRequestedSocket(request_net_log, &casted_params);
 
   CHECK(!callback.is_null());
   CHECK(handle);
 
-  request_net_log.BeginEvent(NetLog::TYPE_SOCKET_POOL);
+  request_net_log.BeginEvent(NetLogEventType::SOCKET_POOL);
 
   if (ReachedMaxSocketsLimit() &&
       respect_limits == ClientSocketPool::RespectLimits::ENABLED) {
-    request_net_log.AddEvent(NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS);
+    request_net_log.AddEvent(NetLogEventType::SOCKET_POOL_STALLED_MAX_SOCKETS);
     // TODO(ricea): Use emplace_back when C++11 becomes allowed.
     StalledRequest request(
         casted_params, priority, handle, callback, request_net_log);
     stalled_request_queue_.push_back(request);
     StalledRequestQueue::iterator iterator = stalled_request_queue_.end();
     --iterator;
     DCHECK_EQ(handle, iterator->handle);
     // Because StalledRequestQueue is a std::list, its iterators are guaranteed
     // to remain valid as long as the elements are not removed. As long as
     // stalled_request_queue_ and stalled_request_map_ are updated in sync, it
     // is safe to dereference an iterator in stalled_request_map_ to find the
     // corresponding list element.
     stalled_request_map_.insert(
         StalledRequestMap::value_type(handle, iterator));
     return ERR_IO_PENDING;
   }
 
   std::unique_ptr<WebSocketTransportConnectJob> connect_job(
       new WebSocketTransportConnectJob(
           group_name, priority, respect_limits, casted_params,
           ConnectionTimeout(), callback, client_socket_factory_, host_resolver_,
           handle, &connect_job_delegate_, pool_net_log_, request_net_log));
 
   int rv = connect_job->Connect();
   // Regardless of the outcome of |connect_job|, it will always be bound to
   // |handle|, since this pool uses early-binding. So the binding is logged
   // here, without waiting for the result.
   request_net_log.AddEvent(
-      NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
+      NetLogEventType::SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       connect_job->net_log().source().ToEventParametersCallback());
   if (rv == OK) {
     HandOutSocket(connect_job->PassSocket(),
                   connect_job->connect_timing(),
                   handle,
                   request_net_log);
-    request_net_log.EndEvent(NetLog::TYPE_SOCKET_POOL);
+    request_net_log.EndEvent(NetLogEventType::SOCKET_POOL);
   } else if (rv == ERR_IO_PENDING) {
     // TODO(ricea): Implement backup job timer?
     AddJob(handle, std::move(connect_job));
   } else {
     std::unique_ptr<StreamSocket> error_socket;
     connect_job->GetAdditionalErrorState(handle);
     error_socket = connect_job->PassSocket();
     if (error_socket) {
       HandOutSocket(std::move(error_socket), connect_job->connect_timing(),
                     handle, request_net_log);
     }
   }
 
   if (rv != ERR_IO_PENDING) {
-    request_net_log.EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL, rv);
+    request_net_log.EndEventWithNetErrorCode(NetLogEventType::SOCKET_POOL, rv);
   }
 
   return rv;
 }
 
 void WebSocketTransportClientSocketPool::RequestSockets(
     const std::string& group_name,
     const void* params,
     int num_sockets,
     const BoundNetLog& net_log) {
@@ skipping 120 matching lines @@
   CompletionCallback callback = job->callback();
   LoadTimingInfo::ConnectTiming connect_timing = job->connect_timing();
 
   ClientSocketHandle* const handle = job->handle();
   bool handed_out_socket = false;
 
   if (result == OK) {
     DCHECK(socket.get());
     handed_out_socket = true;
     HandOutSocket(std::move(socket), connect_timing, handle, request_net_log);
-    request_net_log.EndEvent(NetLog::TYPE_SOCKET_POOL);
+    request_net_log.EndEvent(NetLogEventType::SOCKET_POOL);
   } else {
     // If we got a socket, it must contain error information so pass that
     // up so that the caller can retrieve it.
     job->GetAdditionalErrorState(handle);
     if (socket.get()) {
       handed_out_socket = true;
       HandOutSocket(std::move(socket), connect_timing, handle, request_net_log);
     }
-    request_net_log.EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL, result);
+    request_net_log.EndEventWithNetErrorCode(NetLogEventType::SOCKET_POOL,
+                                             result);
   }
   bool delete_succeeded = DeleteJob(handle);
   DCHECK(delete_succeeded);
   if (!handed_out_socket && !stalled_request_queue_.empty() &&
       !ReachedMaxSocketsLimit())
     ActivateStalledRequest();
   InvokeUserCallbackLater(handle, callback, result);
 }
 
 void WebSocketTransportClientSocketPool::InvokeUserCallbackLater(
@@ skipping 28 matching lines @@
     ClientSocketHandle* handle,
     const BoundNetLog& net_log) {
   DCHECK(socket);
   handle->SetSocket(std::move(socket));
   DCHECK_EQ(ClientSocketHandle::UNUSED, handle->reuse_type());
   DCHECK_EQ(0, handle->idle_time().InMicroseconds());
   handle->set_pool_id(0);
   handle->set_connect_timing(connect_timing);
 
   net_log.AddEvent(
-      NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
+      NetLogEventType::SOCKET_POOL_BOUND_TO_SOCKET,
       handle->socket()->NetLog().source().ToEventParametersCallback());
 
   ++handed_out_socket_count_;
 }
 
 void WebSocketTransportClientSocketPool::AddJob(
     ClientSocketHandle* handle,
     std::unique_ptr<WebSocketTransportConnectJob> connect_job) {
   bool inserted =
       pending_connects_.insert(PendingConnectsMap::value_type(
@@ skipping 81 matching lines @@
       handle(handle),
       callback(callback),
       net_log(net_log) {}
 
 WebSocketTransportClientSocketPool::StalledRequest::StalledRequest(
     const StalledRequest& other) = default;
 
 WebSocketTransportClientSocketPool::StalledRequest::~StalledRequest() {}
 
 }  // namespace net