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

net/proxy/proxy_script_decider.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/proxy/proxy_script_decider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
+#include "net/log/net_log_event_type.h"
+#include "net/log/net_log_source_type.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/dhcp_proxy_script_fetcher_factory.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
 
 namespace {
 
 bool LooksLikePacScript(const base::string16& script) {
@@ skipping 50 matching lines @@
 
 ProxyScriptDecider::ProxyScriptDecider(
     ProxyScriptFetcher* proxy_script_fetcher,
     DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
     NetLog* net_log)
     : proxy_script_fetcher_(proxy_script_fetcher),
       dhcp_proxy_script_fetcher_(dhcp_proxy_script_fetcher),
       current_pac_source_index_(0u),
       pac_mandatory_(false),
       next_state_(STATE_NONE),
-      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_PROXY_SCRIPT_DECIDER)),
+      net_log_(BoundNetLog::Make(net_log,
+                                 NetLogSourceType::PROXY_SCRIPT_DECIDER)),
       fetch_pac_bytes_(false),
       quick_check_enabled_(true),
       host_resolver_(nullptr) {
   if (proxy_script_fetcher &&
       proxy_script_fetcher->GetRequestContext() &&
       proxy_script_fetcher->GetRequestContext()->host_resolver()) {
     host_resolver_ = proxy_script_fetcher->GetRequestContext()->host_resolver();
   }
 }
 
 ProxyScriptDecider::~ProxyScriptDecider() {
   if (next_state_ != STATE_NONE)
     Cancel();
 }
 
 int ProxyScriptDecider::Start(
     const ProxyConfig& config, const base::TimeDelta wait_delay,
     bool fetch_pac_bytes, const CompletionCallback& callback) {
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(!callback.is_null());
   DCHECK(config.HasAutomaticSettings());
 
-  net_log_.BeginEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER);
+  net_log_.BeginEvent(NetLogEventType::PROXY_SCRIPT_DECIDER);
 
   fetch_pac_bytes_ = fetch_pac_bytes;
 
   // Save the |wait_delay| as a non-negative value.
   wait_delay_ = wait_delay;
   if (wait_delay_ < base::TimeDelta())
     wait_delay_ = base::TimeDelta();
 
   pac_mandatory_ = config.pac_mandatory();
   have_custom_pac_url_ = config.has_pac_url();
@@ skipping 102 matching lines @@
 int ProxyScriptDecider::DoWait() {
   next_state_ = STATE_WAIT_COMPLETE;
 
   // If no waiting is required, continue on to the next state.
   if (wait_delay_.ToInternalValue() == 0)
     return OK;
 
   // Otherwise wait the specified amount of time.
   wait_timer_.Start(FROM_HERE, wait_delay_, this,
                     &ProxyScriptDecider::OnWaitTimerFired);
-  net_log_.BeginEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_WAIT);
+  net_log_.BeginEvent(NetLogEventType::PROXY_SCRIPT_DECIDER_WAIT);
   return ERR_IO_PENDING;
 }
 
 int ProxyScriptDecider::DoWaitComplete(int result) {
   DCHECK_EQ(OK, result);
   if (wait_delay_.ToInternalValue() != 0) {
-    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_PROXY_SCRIPT_DECIDER_WAIT,
-                                      result);
+    net_log_.EndEventWithNetErrorCode(
+                                  NetLogEventType::PROXY_SCRIPT_DECIDER_WAIT,
+                                  result);
   }
   if (quick_check_enabled_ && current_pac_source().type == PacSource::WPAD_DNS)
     next_state_ = STATE_QUICK_CHECK;
   else
     next_state_ = GetStartState();
   return OK;
 }
 
 int ProxyScriptDecider::DoQuickCheck() {
   DCHECK(quick_check_enabled_);
@@ skipping 40 matching lines @@
 int ProxyScriptDecider::DoFetchPacScript() {
   DCHECK(fetch_pac_bytes_);
 
   next_state_ = STATE_FETCH_PAC_SCRIPT_COMPLETE;
 
   const PacSource& pac_source = current_pac_source();
 
   GURL effective_pac_url;
   DetermineURL(pac_source, &effective_pac_url);
 
-  net_log_.BeginEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT,
+  net_log_.BeginEvent(NetLogEventType::PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT,
                       base::Bind(&PacSource::NetLogCallback,
                                  base::Unretained(&pac_source),
                                  &effective_pac_url));
 
   if (pac_source.type == PacSource::WPAD_DHCP) {
     if (!dhcp_proxy_script_fetcher_) {
-      net_log_.AddEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER);
+      net_log_.AddEvent(NetLogEventType::PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER);
       return ERR_UNEXPECTED;
     }
 
     return dhcp_proxy_script_fetcher_->Fetch(
         &pac_script_, base::Bind(&ProxyScriptDecider::OnIOCompletion,
                                  base::Unretained(this)));
   }
 
   if (!proxy_script_fetcher_) {
-    net_log_.AddEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER);
+    net_log_.AddEvent(NetLogEventType::PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER);
     return ERR_UNEXPECTED;
   }
 
   return proxy_script_fetcher_->Fetch(
       effective_pac_url, &pac_script_,
       base::Bind(&ProxyScriptDecider::OnIOCompletion, base::Unretained(this)));
 }
 
 int ProxyScriptDecider::DoFetchPacScriptComplete(int result) {
   DCHECK(fetch_pac_bytes_);
 
   net_log_.EndEventWithNetErrorCode(
-      NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT, result);
+      NetLogEventType::PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT, result);
   if (result != OK)
     return TryToFallbackPacSource(result);
 
   next_state_ = STATE_VERIFY_PAC_SCRIPT;
   return result;
 }
 
 int ProxyScriptDecider::DoVerifyPacScript() {
   next_state_ = STATE_VERIFY_PAC_SCRIPT_COMPLETE;
 
@@ skipping 60 matching lines @@
 
   if (current_pac_source_index_ + 1 >= pac_sources_.size()) {
     // Nothing left to fall back to.
     return error;
   }
 
   // Advance to next URL in our list.
   ++current_pac_source_index_;
 
   net_log_.AddEvent(
-      NetLog::TYPE_PROXY_SCRIPT_DECIDER_FALLING_BACK_TO_NEXT_PAC_SOURCE);
+      NetLogEventType::PROXY_SCRIPT_DECIDER_FALLING_BACK_TO_NEXT_PAC_SOURCE);
   if (quick_check_enabled_ && current_pac_source().type == PacSource::WPAD_DNS)
     next_state_ = STATE_QUICK_CHECK;
   else
     next_state_ = GetStartState();
 
   return OK;
 }
 
 ProxyScriptDecider::State ProxyScriptDecider::GetStartState() const {
   return fetch_pac_bytes_ ?  STATE_FETCH_PAC_SCRIPT : STATE_VERIFY_PAC_SCRIPT;
@@ skipping 19 matching lines @@
     ProxyScriptDecider::current_pac_source() const {
   DCHECK_LT(current_pac_source_index_, pac_sources_.size());
   return pac_sources_[current_pac_source_index_];
 }
 
 void ProxyScriptDecider::OnWaitTimerFired() {
   OnIOCompletion(OK);
 }
 
 void ProxyScriptDecider::DidComplete() {
-  net_log_.EndEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER);
+  net_log_.EndEvent(NetLogEventType::PROXY_SCRIPT_DECIDER);
 }
 
 void ProxyScriptDecider::Cancel() {
   DCHECK_NE(STATE_NONE, next_state_);
 
-  net_log_.AddEvent(NetLog::TYPE_CANCELLED);
+  net_log_.AddEvent(NetLogEventType::CANCELLED);
 
   switch (next_state_) {
     case STATE_WAIT_COMPLETE:
       wait_timer_.Stop();
       break;
     case STATE_FETCH_PAC_SCRIPT_COMPLETE:
       proxy_script_fetcher_->Cancel();
       break;
     default:
       break;
   }
 
   // This is safe to call in any state.
   if (dhcp_proxy_script_fetcher_)
     dhcp_proxy_script_fetcher_->Cancel();
 
   DidComplete();
 }
 
 }  // namespace net