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

net/url_request/url_request_throttler_manager.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_throttler_manager.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "net/base/url_util.h"
 #include "net/log/net_log.h"
+#include "net/log/net_log_event_type.h"
+#include "net/log/net_log_source_type.h"
 
 namespace net {
 
 const unsigned int URLRequestThrottlerManager::kMaximumNumberOfEntries = 1500;
 const unsigned int URLRequestThrottlerManager::kRequestsBetweenCollecting = 200;
 
 URLRequestThrottlerManager::URLRequestThrottlerManager()
     : requests_since_last_gc_(0),
       enable_thread_checks_(false),
       logged_for_localhost_disabled_(false),
@@ skipping 50 matching lines @@
   if (entry.get() == NULL) {
     entry = new URLRequestThrottlerEntry(this, url_id);
 
     // We only disable back-off throttling on an entry that we have
     // just constructed.  This is to allow unit tests to explicitly override
     // the entry for localhost URLs.
     std::string host = url.host();
     if (IsLocalhost(host)) {
       if (!logged_for_localhost_disabled_ && IsLocalhost(host)) {
         logged_for_localhost_disabled_ = true;
-        net_log_.AddEvent(NetLog::TYPE_THROTTLING_DISABLED_FOR_HOST,
+        net_log_.AddEvent(NetLogEventType::THROTTLING_DISABLED_FOR_HOST,
                           NetLog::StringCallback("host", &host));
       }
 
       // TODO(joi): Once sliding window is separate from back-off throttling,
       // we can simply return a dummy implementation of
       // URLRequestThrottlerEntryInterface here that never blocks anything.
       entry->DisableBackoffThrottling();
     }
   }
 
@@ skipping 21 matching lines @@
 void URLRequestThrottlerManager::set_enable_thread_checks(bool enable) {
   enable_thread_checks_ = enable;
 }
 
 bool URLRequestThrottlerManager::enable_thread_checks() const {
   return enable_thread_checks_;
 }
 
 void URLRequestThrottlerManager::set_net_log(NetLog* net_log) {
   DCHECK(net_log);
-  net_log_ = BoundNetLog::Make(net_log,
-                               NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING);
+  net_log_ = BoundNetLog::Make(
+      net_log, NetLogSourceType::EXPONENTIAL_BACKOFF_THROTTLING);
 }
 
 NetLog* URLRequestThrottlerManager::net_log() const {
   return net_log_.net_log();
 }
 
 void URLRequestThrottlerManager::OnIPAddressChanged() {
   OnNetworkChange();
 }
 
@@ skipping 38 matching lines @@
 void URLRequestThrottlerManager::OnNetworkChange() {
   // Remove all entries.  Any entries that in-flight requests have a reference
   // to will live until those requests end, and these entries may be
   // inconsistent with new entries for the same URLs, but since what we
   // want is a clean slate for the new connection type, this is OK.
   url_entries_.clear();
   requests_since_last_gc_ = 0;
 }
 
 }  // namespace net