net/dns/host_resolver_impl.cc - Issue 2315613002: Extracted NetLog class's inner enum types into their own enum classes and

Unified Diff: net/dns/host_resolver_impl.cc

Issue 2315613002: Extracted NetLog class's inner enum types into their own enum classes and (Closed)

Patch Set: Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« chrome/browser/renderer_host/safe_browsing_resource_throttle.cc ('K') | « net/dns/dns_transaction.cc ('k') | net/dns/host_resolver_impl_unittest.cc » ('j') | net/http/http_cache_unittest.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: net/dns/host_resolver_impl.cc

diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc

index 8be7731dee183efba47aacfd2b403b4cded7defb..aa37bab222ad73acea9977978113f62ea79a8d01 100644

--- a/net/dns/host_resolver_impl.cc

+++ b/net/dns/host_resolver_impl.cc

@@ -55,6 +55,8 @@

#include "net/dns/dns_util.h"

#include "net/dns/host_resolver_proc.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_factory.h"

#include "net/udp/datagram_client_socket.h"

#include "url/url_canon_ip.h"

@@ -427,7 +429,7 @@ std::unique_ptr<base::Value> NetLogIPv6AvailableCallback(

void LogStartRequest(const BoundNetLog& source_net_log,

const HostResolver::RequestInfo& info) {

source_net_log.BeginEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,

+ NetLogEventType::HOST_RESOLVER_IMPL_REQUEST,

base::Bind(&NetLogRequestInfoCallback, &info));

}

@@ -436,14 +438,14 @@ void LogFinishRequest(const BoundNetLog& source_net_log,

const HostResolver::RequestInfo& info,

int net_error) {

source_net_log.EndEventWithNetErrorCode(

- NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST, net_error);

+ NetLogEventType::HOST_RESOLVER_IMPL_REQUEST, net_error);

}

// Logs when a request has been cancelled.

void LogCancelRequest(const BoundNetLog& source_net_log,

const HostResolverImpl::RequestInfo& info) {

- source_net_log.AddEvent(NetLog::TYPE_CANCELLED);

- source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST);

+ source_net_log.AddEvent(NetLogEventType::CANCELLED);

+ source_net_log.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_REQUEST);

}

//-----------------------------------------------------------------------------

@@ -649,7 +651,7 @@ class HostResolverImpl::ProcTask

void Start() {

DCHECK(network_task_runner_->BelongsToCurrentThread());

- net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);

+ net_log_.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_PROC_TASK);

StartLookupAttempt();

}

@@ -663,7 +665,7 @@ class HostResolverImpl::ProcTask

return;

callback_.Reset();

- net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK);

+ net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_PROC_TASK);

}

void set_had_non_speculative_request() {

@@ -705,7 +707,7 @@ class HostResolverImpl::ProcTask

return;

}

- net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_ATTEMPT_STARTED,

+ net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_ATTEMPT_STARTED,

NetLog::IntCallback("attempt_number", attempt_number_));

// If the results aren't received within a given time, RetryIfNotComplete

@@ -801,7 +803,7 @@ class HostResolverImpl::ProcTask

} else {

net_log_callback = NetLog::IntCallback("attempt_number", attempt_number);

}

- net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_ATTEMPT_FINISHED,

+ net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_ATTEMPT_FINISHED,

net_log_callback);

if (was_completed())

@@ -824,7 +826,7 @@ class HostResolverImpl::ProcTask

} else {

net_log_callback = results_.CreateNetLogCallback();

}

- net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK,

+ net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_PROC_TASK,

net_log_callback);

callback_.Run(error, results_);

@@ -1087,7 +1089,7 @@ class HostResolverImpl::DnsTask : public base::SupportsWeakPtr<DnsTask> {

void StartFirstTransaction() {

DCHECK_EQ(0u, num_completed_transactions_);

- net_log_.BeginEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK);

+ net_log_.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_DNS_TASK);

if (key_.address_family == ADDRESS_FAMILY_IPV6) {

StartAAAA();

} else {

@@ -1232,14 +1234,14 @@ class HostResolverImpl::DnsTask : public base::SupportsWeakPtr<DnsTask> {

void OnFailure(int net_error, DnsResponse::Result result) {

DCHECK_NE(OK, net_error);

net_log_.EndEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,

+ NetLogEventType::HOST_RESOLVER_IMPL_DNS_TASK,

base::Bind(&NetLogDnsTaskFailedCallback, net_error, result));

delegate_->OnDnsTaskComplete(task_start_time_, net_error, AddressList(),

base::TimeDelta());

}

void OnSuccess(const AddressList& addr_list) {

- net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_DNS_TASK,

+ net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_DNS_TASK,

addr_list.CreateNetLogCallback());

delegate_->OnDnsTaskComplete(task_start_time_, OK, addr_list, ttl_);

}

@@ -1290,11 +1292,11 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,

creation_time_(base::TimeTicks::Now()),

priority_change_time_(creation_time_),

net_log_(BoundNetLog::Make(source_net_log.net_log(),

- NetLog::SOURCE_HOST_RESOLVER_IMPL_JOB)) {

- source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CREATE_JOB);

+ NetLogSourceType::HOST_RESOLVER_IMPL_JOB)) {

+ source_net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_CREATE_JOB);

net_log_.BeginEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,

+ NetLogEventType::HOST_RESOLVER_IMPL_JOB,

base::Bind(&NetLogJobCreationCallback,

source_net_log.source(),

&key_.hostname));

@@ -1310,13 +1312,13 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,

}

// Clean up now for nice NetLog.

KillDnsTask();

- net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,

+ net_log_.EndEventWithNetErrorCode(NetLogEventType::HOST_RESOLVER_IMPL_JOB,

ERR_ABORTED);

} else if (is_queued()) {

// |resolver_| was destroyed without running this Job.

// TODO(szym): is there any benefit in having this distinction?

- net_log_.AddEvent(NetLog::TYPE_CANCELLED);

- net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB);

+ net_log_.AddEvent(NetLogEventType::CANCELLED);

+ net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB);

}

// else CompleteRequests logged EndEvent.

if (!requests_.empty()) {

@@ -1355,11 +1357,11 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,

priority_tracker_.Add(request->priority());

request->source_net_log().AddEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH,

+ NetLogEventType::HOST_RESOLVER_IMPL_JOB_ATTACH,

net_log_.source().ToEventParametersCallback());

net_log_.AddEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_ATTACH,

+ NetLogEventType::HOST_RESOLVER_IMPL_JOB_REQUEST_ATTACH,

base::Bind(&NetLogJobAttachCallback, request->source_net_log().source(),

priority()));

@@ -1394,7 +1396,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,

priority_tracker_.Remove(request->priority());

net_log_.AddEvent(

- NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,

+ NetLogEventType::HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,

base::Bind(&NetLogJobAttachCallback, request->source_net_log().source(),

priority()));

@@ -1439,7 +1441,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,

DCHECK(is_queued());

handle_.Reset();

- net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_EVICTED);

+ net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB_EVICTED);

// This signals to CompleteRequests that this job never ran.

CompleteRequestsWithError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);

@@ -1524,7 +1526,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,

DCHECK(!is_running());

- net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_STARTED);

+ net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB_STARTED);

had_dns_config_ = resolver_->HaveDnsConfig();

@@ -1752,13 +1754,13 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,

}

if (num_active_requests() == 0) {

- net_log_.AddEvent(NetLog::TYPE_CANCELLED);

- net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,

+ net_log_.AddEvent(NetLogEventType::CANCELLED);

+ net_log_.EndEventWithNetErrorCode(NetLogEventType::HOST_RESOLVER_IMPL_JOB,

OK);

return;

}

- net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,

+ net_log_.EndEventWithNetErrorCode(NetLogEventType::HOST_RESOLVER_IMPL_JOB,

entry.error());

resolver_->SchedulePersist();

@@ -2064,7 +2066,7 @@ int HostResolverImpl::ResolveHelper(const Key& key,

}

if (ServeFromCache(key, info, &net_error, addresses, allow_stale,

stale_info)) {

- source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CACHE_HIT);

+ source_net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_CACHE_HIT);

// |ServeFromCache()| will set |*stale_info| as needed.

RunCacheHitCallbacks(key, info);

return net_error;

@@ -2072,7 +2074,7 @@ int HostResolverImpl::ResolveHelper(const Key& key,

// TODO(szym): Do not do this if nsswitch.conf instructs not to.

// http://crbug.com/117655

if (ServeFromHosts(key, info, addresses)) {

- source_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_HOSTS_HIT);

+ source_net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_HOSTS_HIT);

MakeNotStale(stale_info);

return OK;

}

@@ -2341,7 +2343,7 @@ bool HostResolverImpl::IsIPv6Reachable(const BoundNetLog& net_log) {

last_ipv6_probe_time_ = now;

cached = false;

}

- net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_IPV6_REACHABILITY_CHECK,

+ net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_IPV6_REACHABILITY_CHECK,

base::Bind(&NetLogIPv6AvailableCallback,

last_ipv6_probe_result_, cached));

return last_ipv6_probe_result_;

@@ -2458,7 +2460,7 @@ void HostResolverImpl::UpdateDNSConfig(bool config_changed) {

if (net_log_) {

net_log_->AddGlobalEntry(

- NetLog::TYPE_DNS_CONFIG_CHANGED,

+ NetLogEventType::DNS_CONFIG_CHANGED,

base::Bind(&NetLogDnsConfigCallback, &dns_config));

}