Replace safe-bool idiom with explicit WeakPtr::operator bool()

net/dns/host_resolver_impl.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/dns/host_resolver_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 323 matching lines @@
     dict->SetInteger("attempt_number", attempt_number);
 
   dict->SetInteger("net_error", net_error);
 
   if (os_error) {
     dict->SetInteger("os_error", os_error);
 #if defined(OS_POSIX)
     dict->SetString("os_error_string", gai_strerror(os_error));
 #elif defined(OS_WIN)
     // Map the error code to a human-readable string.
-    LPWSTR error_string = NULL;
+    LPWSTR error_string = nullptr;
     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                   0,  // Use the internal message table.
                   os_error,
                   0,  // Use default language.
                   (LPWSTR)&error_string,
                   0,  // Buffer size.
                   0);  // Arguments (unused).
     dict->SetString("os_error_string", base::WideToUTF8(error_string));
     LocalFree(error_string);
 #endif
@@ skipping 176 matching lines @@
 class HostResolverImpl::Request {
  public:
   Request(const BoundNetLog& source_net_log,
           const RequestInfo& info,
           RequestPriority priority,
           const CompletionCallback& callback,
           AddressList* addresses)
       : source_net_log_(source_net_log),
         info_(info),
         priority_(priority),
-        job_(NULL),
+        job_(nullptr),
         callback_(callback),
         addresses_(addresses),
         request_time_(base::TimeTicks::Now()) {}
 
   // Mark the request as canceled.
   void MarkAsCanceled() {
-    job_ = NULL;
-    addresses_ = NULL;
+    job_ = nullptr;
+    addresses_ = nullptr;
     callback_.Reset();
   }
 
   bool was_canceled() const {
     return callback_.is_null();
   }
 
   void set_job(Job* job) {
     DCHECK(job);
     // Identify which job the request is waiting on.
@@ skipping 743 matching lines @@
                    source_net_log.source(),
                    &key_.hostname));
   }
 
   ~Job() override {
     if (is_running()) {
       // |resolver_| was destroyed with this Job still in flight.
       // Clean-up, record in the log, but don't run any callbacks.
       if (is_proc_running()) {
         proc_task_->Cancel();
-        proc_task_ = NULL;
+        proc_task_ = nullptr;
       }
       // Clean up now for nice NetLog.
       KillDnsTask();
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_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);
@@ skipping 320 matching lines @@
   }
 
   // Called if DnsTask fails. It is posted from StartDnsTask, so Job may be
   // deleted before this callback. In this case dns_task is deleted as well,
   // so we use it as indicator whether Job is still valid.
   void OnDnsTaskFailure(const base::WeakPtr<DnsTask>& dns_task,
                         base::TimeDelta duration,
                         int net_error) {
     DNS_HISTOGRAM("AsyncDNS.ResolveFail", duration);
 
-    if (dns_task == NULL)
+    if (!dns_task)
       return;
 
     dns_task_error_ = net_error;
 
     // TODO(szym): Run ServeFromHosts now if nsswitch.conf says so.
     // http://crbug.com/117655
 
     // TODO(szym): Some net errors indicate lack of connectivity. Starting
     // ProcTask in that case is a waste of time.
     if (resolver_->fallback_to_proctask_) {
@@ skipping 69 matching lines @@
     // to spawn one. Consequently, the job deletes itself when CompleteRequests
     // is done.
     std::unique_ptr<Job> self_deleter(this);
 
     resolver_->RemoveJob(this);
 
     if (is_running()) {
       if (is_proc_running()) {
         DCHECK(!is_queued());
         proc_task_->Cancel();
-        proc_task_ = NULL;
+        proc_task_ = nullptr;
       }
       KillDnsTask();
 
       // Signal dispatcher that a slot has opened.
       resolver_->dispatcher_->OnJobFinished();
     } else if (is_queued()) {
       resolver_->dispatcher_->Cancel(handle_);
       handle_.Reset();
     }
 
@@ skipping 51 matching lines @@
 
   RequestPriority priority() const {
     return priority_tracker_.highest_priority();
   }
 
   // Number of non-canceled requests in |requests_|.
   size_t num_active_requests() const {
     return priority_tracker_.total_count();
   }
 
-  bool is_dns_running() const {
-    return dns_task_.get() != NULL;
-  }
+  bool is_dns_running() const { return !!dns_task_; }
 
-  bool is_proc_running() const {
-    return proc_task_.get() != NULL;
-  }
+  bool is_proc_running() const { return !!proc_task_; }
 
   base::WeakPtr<HostResolverImpl> resolver_;
 
   Key key_;
 
   // Tracks the highest priority across |requests_|.
   PriorityTracker priority_tracker_;
 
   // Task runner where the HostResolverProc is invoked.
   scoped_refptr<base::TaskRunner> worker_task_runner_;
@@ skipping 304 matching lines @@
 }
 
 std::unique_ptr<base::Value> HostResolverImpl::GetDnsConfigAsValue() const {
   // Check if async DNS is disabled.
   if (!dns_client_.get())
     return nullptr;
 
   // Check if async DNS is enabled, but we currently have no configuration
   // for it.
   const DnsConfig* dns_config = dns_client_->GetConfig();
-  if (dns_config == NULL)
+  if (!dns_config)
     return base::WrapUnique(new base::DictionaryValue());
 
   return dns_config->ToValue();
 }
 
 int HostResolverImpl::ResolveStaleFromCache(
     const RequestInfo& info,
     AddressList* addresses,
     HostCache::EntryStaleness* stale_info,
     const BoundNetLog& source_net_log) {
@@ skipping 354 matching lines @@
     if (self.get())
       TryServingAllJobsFromHosts();
   }
 }
 
 bool HostResolverImpl::HaveDnsConfig() const {
   // Use DnsClient only if it's fully configured and there is no override by
   // ScopedDefaultHostResolverProc.
   // The alternative is to use NetworkChangeNotifier to override DnsConfig,
   // but that would introduce construction order requirements for NCN and SDHRP.
-  return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL) &&
-         !(proc_params_.resolver_proc.get() == NULL &&
-           HostResolverProc::GetDefault() != NULL);
+  return dns_client_ && dns_client_->GetConfig() &&
+         (proc_params_.resolver_proc || !HostResolverProc::GetDefault());
 }
 
 void HostResolverImpl::OnDnsTaskResolve(int net_error) {
   DCHECK(dns_client_);
   if (net_error == OK) {
     num_dns_failures_ = 0;
     return;
   }
   ++num_dns_failures_;
   if (num_dns_failures_ < kMaximumDnsFailures)
@@ skipping 22 matching lines @@
     dns_client_->SetConfig(dns_config);
     num_dns_failures_ = 0;
     if (dns_client_->GetConfig())
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
   }
 
   AbortDnsTasks();
 }
 
 }  // namespace net