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

extensions/browser/extension_throttle_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 "extensions/browser/extension_throttle_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "extensions/browser/extension_request_limiting_throttle.h"
 #include "extensions/common/constants.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"
 #include "net/url_request/url_request.h"
 
 namespace extensions {
 
 const unsigned int ExtensionThrottleManager::kMaximumNumberOfEntries = 1500;
 const unsigned int ExtensionThrottleManager::kRequestsBetweenCollecting = 200;
 
 ExtensionThrottleManager::ExtensionThrottleManager()
     : requests_since_last_gc_(0),
       enable_thread_checks_(false),
@@ skipping 69 matching lines @@
           this, url_id, ignore_user_gesture_load_flag_for_tests_);
     }
 
     // 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 (net::IsLocalhost(host)) {
       if (!logged_for_localhost_disabled_ && net::IsLocalhost(host)) {
         logged_for_localhost_disabled_ = true;
-        net_log_.AddEvent(net::NetLog::TYPE_THROTTLING_DISABLED_FOR_HOST,
+        net_log_.AddEvent(net::NetLogEventType::THROTTLING_DISABLED_FOR_HOST,
                           net::NetLog::StringCallback("host", &host));
       }
 
       // TODO(joi): Once sliding window is separate from back-off throttling,
       // we can simply return a dummy implementation of
       // ExtensionThrottleEntryInterface here that never blocks anything.
       entry->DisableBackoffThrottling();
     }
   }
 
@@ skipping 32 matching lines @@
   enable_thread_checks_ = enable;
 }
 
 bool ExtensionThrottleManager::enable_thread_checks() const {
   return enable_thread_checks_;
 }
 
 void ExtensionThrottleManager::set_net_log(net::NetLog* net_log) {
   DCHECK(net_log);
   net_log_ = net::BoundNetLog::Make(
-      net_log, net::NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING);
+      net_log, net::NetLogSourceType::EXPONENTIAL_BACKOFF_THROTTLING);
 }
 
 net::NetLog* ExtensionThrottleManager::net_log() const {
   return net_log_.net_log();
 }
 
 void ExtensionThrottleManager::OnIPAddressChanged() {
   OnNetworkChange();
 }
 
@@ skipping 38 matching lines @@
 void ExtensionThrottleManager::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 extensions