Fixup inputs and outputs in DnsConfigService

Updating everything to match the latest style guide preferences, mostly
using references much more liberally and converting output params to
returns wherever reasonable.

Also switching from copies to moves in a couple places that I happened
to notice, and a couple more random cleanups to make Tricium happy.

Change-Id: I999f511835e70e61ee8c0e7c5dd7e6b7f2396aea
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2626786Reviewed-by: Matt Menke <mmenke@chromium.org>
Commit-Queue: Eric Orth <ericorth@chromium.org>
Cr-Commit-Position: refs/heads/master@{#844119}

net/dns/dns_config_service.cc

@@ -70,8 +70,8 @@ void DnsConfigService::RefreshConfig() {
   NOTREACHED();
 }
 
-DnsConfigService::Watcher::Watcher(DnsConfigService* service)
-    : service_(service) {}
+DnsConfigService::Watcher::Watcher(DnsConfigService& service)
+    : service_(&service) {}
 
 DnsConfigService::Watcher::~Watcher() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
@@ -92,31 +92,41 @@ void DnsConfigService::Watcher::CheckOnCorrectSequence() {
 }
 
 DnsConfigService::HostsReader::HostsReader(
-    DnsConfigService* service,
-    base::FilePath::StringPieceType hosts_file_path)
-    : service_(service), hosts_file_path_(hosts_file_path) {}
+    base::FilePath::StringPieceType hosts_file_path,
+    DnsConfigService& service)
+    : service_(&service), hosts_file_path_(hosts_file_path) {}
 
 DnsConfigService::HostsReader::~HostsReader() = default;
 
-bool DnsConfigService::HostsReader::ReadHosts(DnsHosts* out_dns_hosts) {
+base::Optional<DnsHosts> DnsConfigService::HostsReader::ReadHosts() {
   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                                 base::BlockingType::MAY_BLOCK);
   DCHECK(!hosts_file_path_.empty());
-  return ParseHostsFile(hosts_file_path_, out_dns_hosts);
+  DnsHosts dns_hosts;
+  if (!ParseHostsFile(hosts_file_path_, &dns_hosts))
+    return base::nullopt;
+
+  return dns_hosts;
 }
 
-bool DnsConfigService::HostsReader::AddAdditionalHostsTo(DnsHosts& dns_hosts) {
+bool DnsConfigService::HostsReader::AddAdditionalHostsTo(
+    DnsHosts& in_out_dns_hosts) {
   // Nothing to add in base implementation.
   return true;
 }
 
 void DnsConfigService::HostsReader::DoWork() {
-  success_ = ReadHosts(&hosts_) && AddAdditionalHostsTo(hosts_);
+  hosts_ = ReadHosts();
+  if (!hosts_.has_value())
+    return;
+
+  if (!AddAdditionalHostsTo(hosts_.value()))
+    hosts_.reset();
 }
 
 void DnsConfigService::HostsReader::OnWorkFinished() {
-  if (success_) {
-    service_->OnHostsRead(hosts_);
+  if (hosts_.has_value()) {
+    service_->OnHostsRead(std::move(hosts_).value());
   } else {
     LOG(WARNING) << "Failed to read DnsHosts.";
   }
@@ -128,7 +138,7 @@ void DnsConfigService::ReadHostsNow() {
   if (!hosts_reader_) {
     DCHECK(!hosts_file_path_.empty());
     hosts_reader_ =
-        base::MakeRefCounted<HostsReader>(this, hosts_file_path_.value());
+        base::MakeRefCounted<HostsReader>(hosts_file_path_.value(), *this);
   }
   hosts_reader_->WorkNow();
 }
@@ -149,7 +159,7 @@ void DnsConfigService::InvalidateHosts() {
   StartTimer();
 }
 
-void DnsConfigService::OnConfigRead(const DnsConfig& config) {
+void DnsConfigService::OnConfigRead(DnsConfig config) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(config.IsValid());
 
@@ -163,11 +173,11 @@ void DnsConfigService::OnConfigRead(const DnsConfig& config) {
     OnCompleteConfig();
 }
 
-void DnsConfigService::OnHostsRead(const DnsHosts& hosts) {
+void DnsConfigService::OnHostsRead(DnsHosts hosts) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (hosts != dns_config_.hosts) {
-    dns_config_.hosts = hosts;
+    dns_config_.hosts = std::move(hosts);
     need_update_ = true;
   }
 

net/dns/dns_config_service.h

@@ -80,7 +80,7 @@ class NET_EXPORT_PRIVATE DnsConfigService {
    public:
     // `service` is expected to own the created Watcher and thus stay valid for
     // the lifetime of the created Watcher.
-    explicit Watcher(DnsConfigService* service);
+    explicit Watcher(DnsConfigService& service);
     virtual ~Watcher();
 
     Watcher(const Watcher&) = delete;
@@ -108,11 +108,13 @@ class NET_EXPORT_PRIVATE DnsConfigService {
 
   // Reader of HOSTS files. In this base implementation, uses standard logic
   // appropriate to most platforms to read the HOSTS file located at
-  // `service->GetHostsFilePath()`.
+  // `hosts_file_path`.
   class HostsReader : public SerialWorker {
    public:
-    HostsReader(DnsConfigService* service,
-                base::FilePath::StringPieceType hosts_file_path);
+    // `service` is expected to own the created reader and thus stay valid for
+    // the lifetime of the created reader.
+    HostsReader(base::FilePath::StringPieceType hosts_file_path,
+                DnsConfigService& service);
 
     HostsReader(const HostsReader&) = delete;
     HostsReader& operator=(const HostsReader&) = delete;
@@ -120,19 +122,19 @@ class NET_EXPORT_PRIVATE DnsConfigService {
    protected:
     ~HostsReader() override;
 
-    // Reads the HOSTS file and parses to a `DnsHosts`. Returns false on
+    // Reads the HOSTS file and parses to a `DnsHosts`. Returns nullopt on
     // failure. Will be called on a separate blockable ThreadPool thread.
     //
     // Override if needed to implement platform-specific behavior, e.g. for a
     // platform-specific HOSTS format.
-    virtual bool ReadHosts(DnsHosts* out_dns_hosts);
+    virtual base::Optional<DnsHosts> ReadHosts();
 
     // Adds any necessary additional entries to the given `DnsHosts`. Returns
     // false on failure. Will be called on a separate blockable ThreadPool
     // thread.
     //
     // Override if needed to implement platform-specific behavior.
-    virtual bool AddAdditionalHostsTo(DnsHosts& dns_hosts);
+    virtual bool AddAdditionalHostsTo(DnsHosts& in_out_dns_hosts);
 
     // SerialWorker:
     void DoWork() final;
@@ -144,8 +146,7 @@ class NET_EXPORT_PRIVATE DnsConfigService {
     // running on worker thread.
     DnsConfigService* const service_;
     // Written in DoWork, read in OnWorkFinished, no locking necessary.
-    DnsHosts hosts_;
-    bool success_ = false;
+    base::Optional<DnsHosts> hosts_;
 
     const base::FilePath hosts_file_path_;
   };
@@ -162,9 +163,9 @@ class NET_EXPORT_PRIVATE DnsConfigService {
   void InvalidateHosts();
 
   // Called with new config. |config|.hosts is ignored.
-  void OnConfigRead(const DnsConfig& config);
+  void OnConfigRead(DnsConfig config);
   // Called with new hosts. Rest of the config is assumed unchanged.
-  void OnHostsRead(const DnsHosts& hosts);
+  void OnHostsRead(DnsHosts hosts);
 
   SEQUENCE_CHECKER(sequence_checker_);
 

net/dns/dns_config_service_posix.cc

@@ -7,6 +7,7 @@
 #include <memory>
 #include <string>
 #include <type_traits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
@@ -15,6 +16,7 @@
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/optional.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/scoped_blocking_call.h"
@@ -143,24 +145,24 @@ bool IsVpnPresent() {
 }
 #endif  // defined(OS_ANDROID)
 
-bool ReadDnsConfig(DnsConfig* dns_config) {
+base::Optional<DnsConfig> ReadDnsConfig() {
   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                                 base::BlockingType::MAY_BLOCK);
-  dns_config->unhandled_options = false;
+
 #if !defined(OS_ANDROID)
-  bool success = false;
+  base::Optional<DnsConfig> dns_config;
 // TODO(fuchsia): Use res_ninit() when it's implemented on Fuchsia.
 #if defined(OS_OPENBSD) || defined(OS_FUCHSIA)
   // Note: res_ninit in glibc always returns 0 and sets RES_INIT.
   // res_init behaves the same way.
   memset(&_res, 0, sizeof(_res));
   if (res_init() == 0)
-    success = ConvertResStateToDnsConfig(_res, dns_config);
+    dns_config = ConvertResStateToDnsConfig(_res);
 #else  // all other OS_POSIX
   struct __res_state res;
   memset(&res, 0, sizeof(res));
   if (res_ninit(&res) == 0)
-    success = ConvertResStateToDnsConfig(res, dns_config);
+    dns_config = ConvertResStateToDnsConfig(res);
     // Prefer res_ndestroy where available.
 #if defined(OS_APPLE) || defined(OS_FREEBSD)
   res_ndestroy(&res);
@@ -169,26 +171,34 @@ bool ReadDnsConfig(DnsConfig* dns_config) {
 #endif  // defined(OS_APPLE) || defined(OS_FREEBSD)
 #endif  // defined(OS_OPENBSD)
 
+  if (!dns_config.has_value())
+    return dns_config;
+
 #if defined(OS_MAC)
-  if (!DnsConfigWatcher::CheckDnsConfig(&dns_config->unhandled_options))
-    return false;
+  if (!DnsConfigWatcher::CheckDnsConfig(
+          dns_config->unhandled_options /* out_unhandled_options */)) {
+    return base::nullopt;
+  }
 #endif  // defined(OS_MAC)
   // Override |fallback_period| value to match default setting on Windows.
   dns_config->fallback_period = kDnsDefaultFallbackPeriod;
-  return success;
+  return dns_config;
 #else  // defined(OS_ANDROID)
-  dns_config->nameservers.clear();
+  DnsConfig dns_config;
 
   if (base::android::BuildInfo::GetInstance()->sdk_int() >=
       base::android::SDK_VERSION_MARSHMALLOW) {
-    return net::android::GetDnsServers(&dns_config->nameservers,
-                                       &dns_config->dns_over_tls_active,
-                                       &dns_config->dns_over_tls_hostname);
+    if (net::android::GetDnsServers(&dns_config.nameservers,
+                                    &dns_config.dns_over_tls_active,
+                                    &dns_config.dns_over_tls_hostname)) {
+      return dns_config;
+    }
+    return base::nullopt;
   }
 
   if (IsVpnPresent()) {
-    dns_config->unhandled_options = true;
-    return true;
+    dns_config.unhandled_options = true;
+    return dns_config;
   }
 
   // NOTE(pauljensen): __system_property_get and the net.dns1/2 properties are
@@ -200,25 +210,25 @@ bool ReadDnsConfig(DnsConfig* dns_config) {
   __system_property_get("net.dns2", property_value);
   std::string dns2_string = property_value;
   if (dns1_string.empty() && dns2_string.empty())
-    return false;
+    return base::nullopt;
 
   IPAddress dns1_address;
   IPAddress dns2_address;
   bool parsed1 = dns1_address.AssignFromIPLiteral(dns1_string);
   bool parsed2 = dns2_address.AssignFromIPLiteral(dns2_string);
   if (!parsed1 && !parsed2)
-    return false;
+    return base::nullopt;
 
   if (parsed1) {
     IPEndPoint dns1(dns1_address, dns_protocol::kDefaultPort);
-    dns_config->nameservers.push_back(dns1);
+    dns_config.nameservers.push_back(dns1);
   }
   if (parsed2) {
     IPEndPoint dns2(dns2_address, dns_protocol::kDefaultPort);
-    dns_config->nameservers.push_back(dns2);
+    dns_config.nameservers.push_back(dns2);
   }
 
-  return true;
+  return dns_config;
 #endif  // !defined(OS_ANDROID)
 }
 
@@ -226,7 +236,7 @@ bool ReadDnsConfig(DnsConfig* dns_config) {
 
 class DnsConfigServicePosix::Watcher : public DnsConfigService::Watcher {
  public:
-  explicit Watcher(DnsConfigServicePosix* service)
+  explicit Watcher(DnsConfigServicePosix& service)
       : DnsConfigService::Watcher(service) {}
   ~Watcher() override = default;
 
@@ -274,19 +284,18 @@ class DnsConfigServicePosix::Watcher : public DnsConfigService::Watcher {
 // net.dns1 and net.dns2; see #if around ReadDnsConfig above.)
 class DnsConfigServicePosix::ConfigReader : public SerialWorker {
  public:
-  explicit ConfigReader(DnsConfigServicePosix* service)
-      : service_(service), success_(false) {
+  explicit ConfigReader(DnsConfigServicePosix& service) : service_(&service) {
     // Allow execution on another thread; nothing thread-specific about
     // constructor.
     DETACH_FROM_SEQUENCE(sequence_checker_);
   }
 
-  void DoWork() override { success_ = ReadDnsConfig(&dns_config_); }
+  void DoWork() override { dns_config_ = ReadDnsConfig(); }
 
   void OnWorkFinished() override {
     DCHECK(!IsCancelled());
-    if (success_) {
-      service_->OnConfigRead(dns_config_);
+    if (dns_config_.has_value()) {
+      service_->OnConfigRead(std::move(dns_config_).value());
     } else {
       LOG(WARNING) << "Failed to read DnsConfig.";
     }
@@ -300,8 +309,7 @@ class DnsConfigServicePosix::ConfigReader : public SerialWorker {
   // on worker thread.
   DnsConfigServicePosix* const service_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
-  DnsConfig dns_config_;
-  bool success_;
+  base::Optional<DnsConfig> dns_config_;
 
   DISALLOW_COPY_AND_ASSIGN(ConfigReader);
 };
@@ -330,25 +338,24 @@ void DnsConfigServicePosix::ReadConfigNow() {
 bool DnsConfigServicePosix::StartWatching() {
   CreateReader();
   // TODO(szym): re-start watcher if that makes sense. http://crbug.com/116139
-  watcher_.reset(new Watcher(this));
+  watcher_ = std::make_unique<Watcher>(*this);
   return watcher_->Watch();
 }
 
 void DnsConfigServicePosix::CreateReader() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!config_reader_);
-  config_reader_ = base::MakeRefCounted<ConfigReader>(this);
+  config_reader_ = base::MakeRefCounted<ConfigReader>(*this);
 }
 
 #if !defined(OS_ANDROID)
-bool ConvertResStateToDnsConfig(const struct __res_state& res,
-                                DnsConfig* dns_config) {
-  DCHECK(dns_config);
+base::Optional<DnsConfig> ConvertResStateToDnsConfig(
+    const struct __res_state& res) {
+  DnsConfig dns_config;
+  dns_config.unhandled_options = false;
 
   if (!(res.options & RES_INIT))
-    return false;
-
-  dns_config->nameservers.clear();
+    return base::nullopt;
 
 #if defined(OS_APPLE) || defined(OS_FREEBSD)
   union res_sockaddr_union addresses[MAXNS];
@@ -360,9 +367,9 @@ bool ConvertResStateToDnsConfig(const struct __res_state& res,
     if (!ipe.FromSockAddr(
             reinterpret_cast<const struct sockaddr*>(&addresses[i]),
             sizeof addresses[i])) {
-      return false;
+      return base::nullopt;
     }
-    dns_config->nameservers.push_back(ipe);
+    dns_config.nameservers.push_back(ipe);
   }
 #elif defined(OS_LINUX) || defined(OS_CHROMEOS)
   static_assert(std::extent<decltype(res.nsaddr_list)>() >= MAXNS &&
@@ -383,11 +390,11 @@ bool ConvertResStateToDnsConfig(const struct __res_state& res,
       addr = reinterpret_cast<const struct sockaddr*>(res._u._ext.nsaddrs[i]);
       addr_len = sizeof *res._u._ext.nsaddrs[i];
     } else {
-      return false;
+      return base::nullopt;
     }
     if (!ipe.FromSockAddr(addr, addr_len))
-      return false;
-    dns_config->nameservers.push_back(ipe);
+      return base::nullopt;
+    dns_config.nameservers.push_back(ipe);
   }
 #else   // !(defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_APPLE) ||
         // defined(OS_FREEBSD))
@@ -397,22 +404,22 @@ bool ConvertResStateToDnsConfig(const struct __res_state& res,
     if (!ipe.FromSockAddr(
             reinterpret_cast<const struct sockaddr*>(&res.nsaddr_list[i]),
             sizeof res.nsaddr_list[i])) {
-      return false;
+      return base::nullopt;
     }
-    dns_config->nameservers.push_back(ipe);
+    dns_config.nameservers.push_back(ipe);
   }
 #endif  // defined(OS_APPLE) || defined(OS_FREEBSD)
 
-  dns_config->search.clear();
+  dns_config.search.clear();
   for (int i = 0; (i < MAXDNSRCH) && res.dnsrch[i]; ++i) {
-    dns_config->search.push_back(std::string(res.dnsrch[i]));
+    dns_config.search.emplace_back(res.dnsrch[i]);
   }
 
-  dns_config->ndots = res.ndots;
-  dns_config->fallback_period = base::TimeDelta::FromSeconds(res.retrans);
-  dns_config->attempts = res.retry;
+  dns_config.ndots = res.ndots;
+  dns_config.fallback_period = base::TimeDelta::FromSeconds(res.retrans);
+  dns_config.attempts = res.retry;
 #if defined(RES_ROTATE)
-  dns_config->rotate = res.options & RES_ROTATE;
+  dns_config.rotate = res.options & RES_ROTATE;
 #endif
 #if !defined(RES_USE_DNSSEC)
   // Some versions of libresolv don't have support for the DO bit. In this
@@ -424,26 +431,26 @@ bool ConvertResStateToDnsConfig(const struct __res_state& res,
   // cannot be overwritten by /etc/resolv.conf
   const unsigned kRequiredOptions = RES_RECURSE | RES_DEFNAMES | RES_DNSRCH;
   if ((res.options & kRequiredOptions) != kRequiredOptions) {
-    dns_config->unhandled_options = true;
-    return true;
+    dns_config.unhandled_options = true;
+    return dns_config;
   }
 
   const unsigned kUnhandledOptions = RES_USEVC | RES_IGNTC | RES_USE_DNSSEC;
   if (res.options & kUnhandledOptions) {
-    dns_config->unhandled_options = true;
-    return true;
+    dns_config.unhandled_options = true;
+    return dns_config;
   }
 
-  if (dns_config->nameservers.empty())
-    return false;
+  if (dns_config.nameservers.empty())
+    return base::nullopt;
 
   // If any name server is 0.0.0.0, assume the configuration is invalid.
   // TODO(szym): Measure how often this happens. http://crbug.com/125599
-  for (unsigned i = 0; i < dns_config->nameservers.size(); ++i) {
-    if (dns_config->nameservers[i].address().IsZero())
-      return false;
+  for (const IPEndPoint& nameserver : dns_config.nameservers) {
+    if (nameserver.address().IsZero())
+      return base::nullopt;
   }
-  return true;
+  return dns_config;
 }
 
 #endif  // !defined(OS_ANDROID)

net/dns/dns_config_service_posix.h

@@ -59,11 +59,9 @@ class NET_EXPORT_PRIVATE DnsConfigServicePosix : public DnsConfigService {
 };
 
 #if !defined(OS_ANDROID)
-// Fills in |dns_config| from |res|. Returns false iff a valid config could not
-// be determined.
-bool NET_EXPORT_PRIVATE
-ConvertResStateToDnsConfig(const struct __res_state& res,
-                           DnsConfig* dns_config);
+// Returns nullopt iff a valid config could not be determined.
+base::Optional<DnsConfig> NET_EXPORT_PRIVATE
+ConvertResStateToDnsConfig(const struct __res_state& res);
 #endif
 
 }  // namespace internal

net/dns/dns_config_service_posix_unittest.cc

@@ -8,6 +8,7 @@
 
 #include "base/cancelable_callback.h"
 #include "base/files/file_util.h"
+#include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
@@ -146,17 +147,16 @@ void InitializeExpectedConfig(DnsConfig* config) {
 
 TEST(DnsConfigServicePosixTest, ConvertResStateToDnsConfig) {
   struct __res_state res;
-  DnsConfig config;
-  EXPECT_FALSE(config.IsValid());
   InitializeResState(&res);
-  ASSERT_TRUE(internal::ConvertResStateToDnsConfig(res, &config));
+  base::Optional<DnsConfig> config = internal::ConvertResStateToDnsConfig(res);
   CloseResState(&res);
-  EXPECT_TRUE(config.IsValid());
+  ASSERT_TRUE(config.has_value());
+  EXPECT_TRUE(config->IsValid());
 
   DnsConfig expected_config;
-  EXPECT_FALSE(expected_config.EqualsIgnoreHosts(config));
+  EXPECT_FALSE(expected_config.EqualsIgnoreHosts(config.value()));
   InitializeExpectedConfig(&expected_config);
-  EXPECT_TRUE(expected_config.EqualsIgnoreHosts(config));
+  EXPECT_TRUE(expected_config.EqualsIgnoreHosts(config.value()));
 }
 
 TEST(DnsConfigServicePosixTest, RejectEmptyNameserver) {
@@ -175,12 +175,11 @@ TEST(DnsConfigServicePosixTest, RejectEmptyNameserver) {
   res.nsaddr_list[1] = sa;
   res.nscount = 2;
 
-  DnsConfig config;
-  EXPECT_FALSE(internal::ConvertResStateToDnsConfig(res, &config));
+  EXPECT_FALSE(internal::ConvertResStateToDnsConfig(res));
 
   sa.sin_addr.s_addr = 0xDEADBEEF;
   res.nsaddr_list[0] = sa;
-  EXPECT_TRUE(internal::ConvertResStateToDnsConfig(res, &config));
+  EXPECT_TRUE(internal::ConvertResStateToDnsConfig(res));
 }
 
 TEST(DnsConfigServicePosixTest, DestroyWhileJobsWorking) {

net/dns/dns_config_service_win.cc

@@ -74,42 +74,53 @@ const wchar_t kDnsConnectionsProxies[] =
 // Convenience for reading values using RegKey.
 class RegistryReader {
  public:
-  explicit RegistryReader(const wchar_t* key) {
+  explicit RegistryReader(const wchar_t key[]) {
     // Ignoring the result. |key_.Valid()| will catch failures.
     key_.Open(HKEY_LOCAL_MACHINE, key, KEY_QUERY_VALUE);
   }
 
   ~RegistryReader() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); }
 
-  bool ReadString(const wchar_t* name,
-                  DnsSystemSettings::RegString* out) const {
+  base::Optional<DnsSystemSettings::RegString> ReadString(
+      const wchar_t name[]) const {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-    out->set = false;
+    DnsSystemSettings::RegString reg_string;
+    reg_string.set = false;
     if (!key_.Valid()) {
       // Assume that if the |key_| is invalid then the key is missing.
-      return true;
+      return reg_string;
     }
-    LONG result = key_.ReadValue(name, &out->value);
+    LONG result = key_.ReadValue(name, &reg_string.value);
     if (result == ERROR_SUCCESS) {
-      out->set = true;
-      return true;
+      reg_string.set = true;
+      return reg_string;
     }
-    return (result == ERROR_FILE_NOT_FOUND);
+
+    if (result == ERROR_FILE_NOT_FOUND)
+      return reg_string;
+
+    return base::nullopt;
   }
 
-  bool ReadDword(const wchar_t* name, DnsSystemSettings::RegDword* out) const {
+  base::Optional<DnsSystemSettings::RegDword> ReadDword(
+      const wchar_t name[]) const {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-    out->set = false;
+    DnsSystemSettings::RegDword reg_dword;
+    reg_dword.set = false;
     if (!key_.Valid()) {
       // Assume that if the |key_| is invalid then the key is missing.
-      return true;
+      return reg_dword;
     }
-    LONG result = key_.ReadValueDW(name, &out->value);
+    LONG result = key_.ReadValueDW(name, &reg_dword.value);
     if (result == ERROR_SUCCESS) {
-      out->set = true;
-      return true;
+      reg_dword.set = true;
+      return reg_dword;
     }
-    return (result == ERROR_FILE_NOT_FOUND);
+
+    if (result == ERROR_FILE_NOT_FOUND)
+      return reg_dword;
+
+    return base::nullopt;
   }
 
  private:
@@ -141,22 +152,35 @@ std::unique_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> ReadIpHelper(
   return out;
 }
 
-bool ReadDevolutionSetting(const RegistryReader& reader,
-                           DnsSystemSettings::DevolutionSetting* setting) {
-  return reader.ReadDword(L"UseDomainNameDevolution", &setting->enabled) &&
-         reader.ReadDword(L"DomainNameDevolutionLevel", &setting->level);
+base::Optional<DnsSystemSettings::DevolutionSetting> ReadDevolutionSetting(
+    const RegistryReader& reader) {
+  DnsSystemSettings::DevolutionSetting setting;
+
+  base::Optional<DnsSystemSettings::RegDword> reg_value =
+      reader.ReadDword(L"UseDomainNameDevolution");
+  if (!reg_value)
+    return base::nullopt;
+  setting.enabled = reg_value.value();
+
+  reg_value = reader.ReadDword(L"DomainNameDevolutionLevel");
+  if (!reg_value)
+    return base::nullopt;
+  setting.level = reg_value.value();
+
+  return setting;
 }
 
 // Reads DnsSystemSettings from IpHelper and registry.
-bool ReadSystemSettings(DnsSystemSettings* settings) {
+base::Optional<DnsSystemSettings> ReadSystemSettings() {
   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                                 base::BlockingType::MAY_BLOCK);
-  settings->addresses = ReadIpHelper(GAA_FLAG_SKIP_ANYCAST |
-                                     GAA_FLAG_SKIP_UNICAST |
-                                     GAA_FLAG_SKIP_MULTICAST |
-                                     GAA_FLAG_SKIP_FRIENDLY_NAME);
-  if (!settings->addresses.get())
-    return false;
+  DnsSystemSettings settings;
+
+  settings.addresses =
+      ReadIpHelper(GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_UNICAST |
+                   GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_FRIENDLY_NAME);
+  if (!settings.addresses.get())
+    return base::nullopt;
 
   RegistryReader tcpip_reader(kTcpipPath);
   RegistryReader tcpip6_reader(kTcpip6Path);
@@ -164,76 +188,91 @@ bool ReadSystemSettings(DnsSystemSettings* settings) {
   RegistryReader policy_reader(kPolicyPath);
   RegistryReader primary_dns_suffix_reader(kPrimaryDnsSuffixPath);
 
-  if (!policy_reader.ReadString(L"SearchList", &settings->policy_search_list)) {
-    return false;
-  }
-
-  if (!tcpip_reader.ReadString(L"SearchList", &settings->tcpip_search_list))
-    return false;
-
-  if (!tcpip_reader.ReadString(L"Domain", &settings->tcpip_domain))
-    return false;
-
-  if (!ReadDevolutionSetting(policy_reader, &settings->policy_devolution))
-    return false;
-
-  if (!ReadDevolutionSetting(dnscache_reader, &settings->dnscache_devolution))
-    return false;
-
-  if (!ReadDevolutionSetting(tcpip_reader, &settings->tcpip_devolution))
-    return false;
-
-  if (!policy_reader.ReadDword(L"AppendToMultiLabelName",
-                               &settings->append_to_multi_label_name)) {
-    return false;
-  }
-
-  if (!primary_dns_suffix_reader.ReadString(L"PrimaryDnsSuffix",
-                                            &settings->primary_dns_suffix)) {
-    return false;
+  base::Optional<DnsSystemSettings::RegString> reg_string =
+      policy_reader.ReadString(L"SearchList");
+  if (!reg_string)
+    return base::nullopt;
+  settings.policy_search_list = std::move(reg_string).value();
+
+  reg_string = tcpip_reader.ReadString(L"SearchList");
+  if (!reg_string)
+    return base::nullopt;
+  settings.tcpip_search_list = std::move(reg_string).value();
+
+  reg_string = tcpip_reader.ReadString(L"Domain");
+  if (!reg_string)
+    return base::nullopt;
+  settings.tcpip_domain = std::move(reg_string).value();
+
+  base::Optional<DnsSystemSettings::DevolutionSetting> devolution_setting =
+      ReadDevolutionSetting(policy_reader);
+  if (!devolution_setting)
+    return base::nullopt;
+  settings.policy_devolution = devolution_setting.value();
+
+  devolution_setting = ReadDevolutionSetting(dnscache_reader);
+  if (!devolution_setting)
+    return base::nullopt;
+  settings.dnscache_devolution = devolution_setting.value();
+
+  devolution_setting = ReadDevolutionSetting(tcpip_reader);
+  if (!devolution_setting)
+    return base::nullopt;
+  settings.tcpip_devolution = devolution_setting.value();
+
+  base::Optional<DnsSystemSettings::RegDword> reg_dword =
+      policy_reader.ReadDword(L"AppendToMultiLabelName");
+  if (!reg_dword)
+    return base::nullopt;
+  settings.append_to_multi_label_name = reg_dword.value();
+
+  reg_string = primary_dns_suffix_reader.ReadString(L"PrimaryDnsSuffix");
+  if (!reg_string) {
+    return base::nullopt;
   }
+  settings.primary_dns_suffix = std::move(reg_string).value();
 
   base::win::RegistryKeyIterator nrpt_rules(HKEY_LOCAL_MACHINE, kNrptPath);
   base::win::RegistryKeyIterator cs_nrpt_rules(HKEY_LOCAL_MACHINE,
                                                kControlSetNrptPath);
-  settings->have_name_resolution_policy =
+  settings.have_name_resolution_policy =
       (nrpt_rules.SubkeyCount() > 0 || cs_nrpt_rules.SubkeyCount() > 0);
 
   base::win::RegistryKeyIterator dns_connections(HKEY_LOCAL_MACHINE,
                                                  kDnsConnectionsPath);
   base::win::RegistryKeyIterator dns_connections_proxies(
       HKEY_LOCAL_MACHINE, kDnsConnectionsProxies);
-  settings->have_proxy = (dns_connections.SubkeyCount() > 0 ||
-                          dns_connections_proxies.SubkeyCount() > 0);
+  settings.have_proxy = (dns_connections.SubkeyCount() > 0 ||
+                         dns_connections_proxies.SubkeyCount() > 0);
 
-  return true;
+  return settings;
 }
 
 // Default address of "localhost" and local computer name can be overridden
 // by the HOSTS file, but if it's not there, then we need to fill it in.
-bool AddLocalhostEntries(DnsHosts* hosts) {
+bool AddLocalhostEntriesTo(DnsHosts& in_out_hosts) {
   IPAddress loopback_ipv4 = IPAddress::IPv4Localhost();
   IPAddress loopback_ipv6 = IPAddress::IPv6Localhost();
 
   // This does not override any pre-existing entries from the HOSTS file.
-  hosts->insert(std::make_pair(DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4),
-                               loopback_ipv4));
-  hosts->insert(std::make_pair(DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6),
-                               loopback_ipv6));
+  in_out_hosts.insert(std::make_pair(
+      DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4), loopback_ipv4));
+  in_out_hosts.insert(std::make_pair(
+      DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6), loopback_ipv6));
 
   wchar_t buffer[MAX_PATH];
   DWORD size = MAX_PATH;
-  std::string localname;
-  if (!GetComputerNameExW(ComputerNameDnsHostname, buffer, &size) ||
-      !ParseDomainASCII(buffer, &localname)) {
+  if (!GetComputerNameExW(ComputerNameDnsHostname, buffer, &size))
+    return false;
+  std::string localname = ParseDomainASCII(buffer);
+  if (localname.empty())
     return false;
-  }
   localname = base::ToLowerASCII(localname);
 
   bool have_ipv4 =
-      hosts->count(DnsHostsKey(localname, ADDRESS_FAMILY_IPV4)) > 0;
+      in_out_hosts.count(DnsHostsKey(localname, ADDRESS_FAMILY_IPV4)) > 0;
   bool have_ipv6 =
-      hosts->count(DnsHostsKey(localname, ADDRESS_FAMILY_IPV6)) > 0;
+      in_out_hosts.count(DnsHostsKey(localname, ADDRESS_FAMILY_IPV6)) > 0;
 
   if (have_ipv4 && have_ipv6)
     return true;
@@ -264,10 +303,12 @@ bool AddLocalhostEntries(DnsHosts* hosts) {
       }
       if (!have_ipv4 && (ipe.GetFamily() == ADDRESS_FAMILY_IPV4)) {
         have_ipv4 = true;
-        (*hosts)[DnsHostsKey(localname, ADDRESS_FAMILY_IPV4)] = ipe.address();
+        in_out_hosts[DnsHostsKey(localname, ADDRESS_FAMILY_IPV4)] =
+            ipe.address();
       } else if (!have_ipv6 && (ipe.GetFamily() == ADDRESS_FAMILY_IPV6)) {
         have_ipv6 = true;
-        (*hosts)[DnsHostsKey(localname, ADDRESS_FAMILY_IPV6)] = ipe.address();
+        in_out_hosts[DnsHostsKey(localname, ADDRESS_FAMILY_IPV6)] =
+            ipe.address();
       }
     }
   }
@@ -282,7 +323,7 @@ class RegistryWatcher {
 
   ~RegistryWatcher() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); }
 
-  bool Watch(const wchar_t* key, const CallbackType& callback) {
+  bool Watch(const wchar_t key[], const CallbackType& callback) {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     DCHECK(!callback.is_null());
     DCHECK(callback_.is_null());
@@ -336,19 +377,21 @@ base::FilePath GetHostsPath() {
 }
 
 void ConfigureSuffixSearch(const DnsSystemSettings& settings,
-                           DnsConfig* config) {
+                           DnsConfig& in_out_config) {
   // SearchList takes precedence, so check it first.
   if (settings.policy_search_list.set) {
-    std::vector<std::string> search;
-    if (ParseSearchList(settings.policy_search_list.value, &search)) {
-      config->search.swap(search);
+    std::vector<std::string> search =
+        ParseSearchList(settings.policy_search_list.value);
+    if (!search.empty()) {
+      in_out_config.search = std::move(search);
       return;
     }
     // Even if invalid, the policy disables the user-specified setting below.
   } else if (settings.tcpip_search_list.set) {
-    std::vector<std::string> search;
-    if (ParseSearchList(settings.tcpip_search_list.value, &search)) {
-      config->search.swap(search);
+    std::vector<std::string> search =
+        ParseSearchList(settings.tcpip_search_list.value);
+    if (!search.empty()) {
+      in_out_config.search = std::move(search);
       return;
     }
   }
@@ -365,15 +408,14 @@ void ConfigureSuffixSearch(const DnsSystemSettings& settings,
   // The user setting (tcpip_domain) can be configurred at Computer Name in
   // System Settings
   std::string primary_suffix;
-  if ((settings.primary_dns_suffix.set &&
-       ParseDomainASCII(settings.primary_dns_suffix.value, &primary_suffix)) ||
-      (settings.tcpip_domain.set &&
-       ParseDomainASCII(settings.tcpip_domain.value, &primary_suffix))) {
-    // Primary suffix goes in front.
-    config->search.insert(config->search.begin(), primary_suffix);
-  } else {
+  if (settings.primary_dns_suffix.set)
+    primary_suffix = ParseDomainASCII(settings.primary_dns_suffix.value);
+  if (primary_suffix.empty() && settings.tcpip_domain.set)
+    primary_suffix = ParseDomainASCII(settings.tcpip_domain.value);
+  if (primary_suffix.empty())
     return;  // No primary suffix, hence no devolution.
-  }
+  // Primary suffix goes in front.
+  in_out_config.search.insert(in_out_config.search.begin(), primary_suffix);
 
   // Devolution is determined by precedence: policy > dnscache > tcpip.
   // |enabled|: UseDomainNameDevolution and |level|: DomainNameDevolutionLevel
@@ -415,7 +457,7 @@ void ConfigureSuffixSearch(const DnsSystemSettings& settings,
 
   for (size_t offset = 0; num_dots >= devolution.level.value; --num_dots) {
     offset = primary_suffix.find('.', offset + 1);
-    config->search.push_back(primary_suffix.substr(offset + 1));
+    in_out_config.search.push_back(primary_suffix.substr(offset + 1));
   }
 }
 
@@ -448,39 +490,40 @@ DnsSystemSettings::DnsSystemSettings()
 DnsSystemSettings::~DnsSystemSettings() {
 }
 
-bool ParseDomainASCII(base::WStringPiece widestr, std::string* domain) {
-  DCHECK(domain);
+DnsSystemSettings::DnsSystemSettings(DnsSystemSettings&&) = default;
+DnsSystemSettings& DnsSystemSettings::operator=(DnsSystemSettings&&) = default;
+
+std::string ParseDomainASCII(base::WStringPiece widestr) {
   if (widestr.empty())
-    return false;
+    return "";
 
   // Check if already ASCII.
   if (base::IsStringASCII(base::AsStringPiece16(widestr))) {
-    domain->assign(widestr.begin(), widestr.end());
-    return true;
+    return std::string(widestr.begin(), widestr.end());
   }
 
   // Otherwise try to convert it from IDN to punycode.
   const int kInitialBufferSize = 256;
   url::RawCanonOutputT<base::char16, kInitialBufferSize> punycode;
   if (!url::IDNToASCII(base::as_u16cstr(widestr), widestr.length(), &punycode))
-    return false;
+    return "";
 
   // |punycode_output| should now be ASCII; convert it to a std::string.
   // (We could use UTF16ToASCII() instead, but that requires an extra string
   // copy. Since ASCII is a subset of UTF8 the following is equivalent).
-  bool success = base::UTF16ToUTF8(punycode.data(), punycode.length(), domain);
+  std::string converted;
+  bool success =
+      base::UTF16ToUTF8(punycode.data(), punycode.length(), &converted);
   DCHECK(success);
-  DCHECK(base::IsStringASCII(*domain));
-  return success && !domain->empty();
+  DCHECK(base::IsStringASCII(converted));
+  return converted;
 }
 
-bool ParseSearchList(const std::wstring& value,
-                     std::vector<std::string>* output) {
-  DCHECK(output);
+std::vector<std::string> ParseSearchList(base::WStringPiece value) {
   if (value.empty())
-    return false;
+    return {};
 
-  output->clear();
+  std::vector<std::string> output;
 
   // If the list includes an empty hostname (",," or ", ,"), it is terminated.
   // Although nslookup and network connection property tab ignore such
@@ -490,18 +533,19 @@ bool ParseSearchList(const std::wstring& value,
            value, L",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     // Convert non-ASCII to punycode, although getaddrinfo does not properly
     // handle such suffixes.
-    std::string parsed;
-    if (!ParseDomainASCII(t, &parsed))
+    std::string parsed = ParseDomainASCII(t);
+    if (parsed.empty())
       break;
-    output->push_back(parsed);
+    output.push_back(std::move(parsed));
   }
-  return !output->empty();
+  return output;
 }
 
-bool ConvertSettingsToDnsConfig(const DnsSystemSettings& settings,
-                                DnsConfig* config) {
+base::Optional<DnsConfig> ConvertSettingsToDnsConfig(
+    const DnsSystemSettings& settings) {
   bool uses_vpn = false;
-  *config = DnsConfig();
+
+  DnsConfig dns_config;
 
   // Use GetAdapterAddresses to get effective DNS server order and
   // connection-specific DNS suffix. Ignore disconnected and loopback adapters.
@@ -519,7 +563,7 @@ bool ConvertSettingsToDnsConfig(const DnsSystemSettings& settings,
     // previously found, skip processing another adapter.
     if (adapter->OperStatus != IfOperStatusUp ||
         adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK ||
-        !config->nameservers.empty())
+        !dns_config.nameservers.empty())
       continue;
 
     for (const IP_ADAPTER_DNS_SERVER_ADDRESS* address =
@@ -533,9 +577,9 @@ bool ConvertSettingsToDnsConfig(const DnsSystemSettings& settings,
         // Override unset port.
         if (!ipe.port())
           ipe = IPEndPoint(ipe.address(), dns_protocol::kDefaultPort);
-        config->nameservers.push_back(ipe);
+        dns_config.nameservers.push_back(ipe);
       } else {
-        return false;
+        return base::nullopt;
       }
     }
 
@@ -544,34 +588,34 @@ bool ConvertSettingsToDnsConfig(const DnsSystemSettings& settings,
     // |DnsSuffix| stores the effective connection-specific suffix, which is
     // obtained via DHCP (regkey: Tcpip\Parameters\Interfaces\{XXX}\DhcpDomain)
     // or specified by the user (regkey: Tcpip\Parameters\Domain).
-    std::string dns_suffix;
-    if (ParseDomainASCII(adapter->DnsSuffix, &dns_suffix))
-      config->search.push_back(dns_suffix);
+    std::string dns_suffix = ParseDomainASCII(adapter->DnsSuffix);
+    if (!dns_suffix.empty())
+      dns_config.search.push_back(std::move(dns_suffix));
   }
 
-  if (config->nameservers.empty())
-    return false;  // No point continuing.
+  if (dns_config.nameservers.empty())
+    return base::nullopt;  // No point continuing.
 
   // Windows always tries a multi-label name "as is" before using suffixes.
-  config->ndots = 1;
+  dns_config.ndots = 1;
 
   if (!settings.append_to_multi_label_name.set) {
-    config->append_to_multi_label_name = false;
+    dns_config.append_to_multi_label_name = false;
   } else {
-    config->append_to_multi_label_name =
+    dns_config.append_to_multi_label_name =
         (settings.append_to_multi_label_name.value != 0);
   }
 
   if (settings.have_name_resolution_policy) {
     // TODO(szym): only set this to true if NRPT has DirectAccess rules.
-    config->use_local_ipv6 = true;
+    dns_config.use_local_ipv6 = true;
   }
 
   if (settings.have_name_resolution_policy || settings.have_proxy || uses_vpn)
-    config->unhandled_options = true;
+    dns_config.unhandled_options = true;
 
-  ConfigureSuffixSearch(settings, config);
-  return true;
+  ConfigureSuffixSearch(settings, dns_config);
+  return dns_config;
 }
 
 // Watches registry and HOSTS file for changes. Must live on a sequence which
@@ -580,7 +624,7 @@ class DnsConfigServiceWin::Watcher
     : public NetworkChangeNotifier::IPAddressObserver,
       public DnsConfigService::Watcher {
  public:
-  explicit Watcher(DnsConfigServiceWin* service)
+  explicit Watcher(DnsConfigServiceWin& service)
       : DnsConfigService::Watcher(service) {}
   ~Watcher() override { NetworkChangeNotifier::RemoveIPAddressObserver(this); }
 
@@ -648,25 +692,22 @@ class DnsConfigServiceWin::Watcher
 // Reads config from registry and IpHelper. All work performed in ThreadPool.
 class DnsConfigServiceWin::ConfigReader : public SerialWorker {
  public:
-  explicit ConfigReader(DnsConfigServiceWin* service)
-      : service_(service),
-        success_(false) {}
+  explicit ConfigReader(DnsConfigServiceWin& service) : service_(&service) {}
 
  private:
   ~ConfigReader() override {}
 
   void DoWork() override {
-    DnsSystemSettings settings = {};
-    success_ = false;
-    if (ReadSystemSettings(&settings))
-      success_ = ConvertSettingsToDnsConfig(settings, &dns_config_);
+    base::Optional<DnsSystemSettings> settings = ReadSystemSettings();
+    if (settings.has_value())
+      dns_config_ = ConvertSettingsToDnsConfig(settings.value());
   }
 
   void OnWorkFinished() override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     DCHECK(!IsCancelled());
-    if (success_) {
-      service_->OnConfigRead(dns_config_);
+    if (dns_config_.has_value()) {
+      service_->OnConfigRead(std::move(dns_config_).value());
     } else {
       LOG(WARNING) << "Failed to read DnsConfig.";
       // Try again in a while in case DnsConfigWatcher missed the signal.
@@ -678,25 +719,24 @@ class DnsConfigServiceWin::ConfigReader : public SerialWorker {
 
   DnsConfigServiceWin* service_;
   // Written in DoWork(), read in OnWorkFinished(). No locking required.
-  DnsConfig dns_config_;
-  bool success_;
+  base::Optional<DnsConfig> dns_config_;
 };
 
 // Extension of DnsConfigService::HostsReader that fills in localhost and local
 // computer name if necessary.
 class DnsConfigServiceWin::HostsReader : public DnsConfigService::HostsReader {
  public:
-  explicit HostsReader(DnsConfigServiceWin* service)
-      : DnsConfigService::HostsReader(service, GetHostsPath().value()) {}
+  explicit HostsReader(DnsConfigServiceWin& service)
+      : DnsConfigService::HostsReader(GetHostsPath().value(), service) {}
 
   HostsReader(const HostsReader&) = delete;
   HostsReader& operator=(const HostsReader&) = delete;
 
  protected:
-  bool AddAdditionalHostsTo(DnsHosts& dns_hosts) override {
+  bool AddAdditionalHostsTo(DnsHosts& in_out_dns_hosts) override {
     base::ScopedBlockingCall scoped_blocking_call(
         FROM_HERE, base::BlockingType::MAY_BLOCK);
-    return AddLocalhostEntries(&dns_hosts);
+    return AddLocalhostEntriesTo(in_out_dns_hosts);
   }
 
  private:
@@ -727,11 +767,11 @@ void DnsConfigServiceWin::ReadHostsNow() {
 
 bool DnsConfigServiceWin::StartWatching() {
   if (!config_reader_)
-    config_reader_ = base::MakeRefCounted<ConfigReader>(this);
+    config_reader_ = base::MakeRefCounted<ConfigReader>(*this);
   if (!hosts_reader_)
-    hosts_reader_ = base::MakeRefCounted<HostsReader>(this);
+    hosts_reader_ = base::MakeRefCounted<HostsReader>(*this);
   // TODO(szym): re-start watcher if that makes sense. http://crbug.com/116139
-  watcher_.reset(new Watcher(this));
+  watcher_.reset(new Watcher(*this));
   return watcher_->Watch();
 }
 

net/dns/dns_config_service_win.h

@@ -39,17 +39,15 @@ namespace net {
 namespace internal {
 
 // Converts a UTF-16 domain name to ASCII, possibly using punycode.
-// Returns true if the conversion succeeds and output is not empty. In case of
-// failure, |domain| might become dirty.
-bool NET_EXPORT_PRIVATE ParseDomainASCII(base::WStringPiece widestr,
-                                         std::string* domain);
+// Returns empty string on failure.
+std::string NET_EXPORT_PRIVATE ParseDomainASCII(base::WStringPiece widestr);
 
 // Parses |value| as search list (comma-delimited list of domain names) from
-// a registry key and stores it in |out|. Returns true on success. Empty
+// a registry key and stores it in |out|. Returns empty vector on failure. Empty
 // entries (e.g., "chromium.org,,org") terminate the list. Non-ascii hostnames
 // are converted to punycode.
-bool NET_EXPORT_PRIVATE ParseSearchList(const std::wstring& value,
-                                        std::vector<std::string>* out);
+std::vector<std::string> NET_EXPORT_PRIVATE
+ParseSearchList(base::WStringPiece value);
 
 // All relevant settings read from registry and IP Helper. This isolates our
 // logic from system calls and is exposed for unit tests. Keep it an aggregate
@@ -76,6 +74,9 @@ struct NET_EXPORT_PRIVATE DnsSystemSettings {
   DnsSystemSettings();
   ~DnsSystemSettings();
 
+  DnsSystemSettings(DnsSystemSettings&&);
+  DnsSystemSettings& operator=(DnsSystemSettings&&);
+
   // Filled in by GetAdapterAddresses. Note that the alternative
   // GetNetworkParams does not include IPv6 addresses.
   std::unique_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> addresses;
@@ -114,11 +115,10 @@ struct NET_EXPORT_PRIVATE DnsSystemSettings {
   bool have_proxy = false;
 };
 
-// Fills in |dns_config| from |settings|. Exposed for tests. Returns false if a
-// valid config could not be determined.
-bool NET_EXPORT_PRIVATE
-ConvertSettingsToDnsConfig(const DnsSystemSettings& settings,
-                           DnsConfig* dns_config);
+// Fills in |dns_config| from |settings|. Exposed for tests. Returns nullopt if
+// a valid config could not be determined.
+base::Optional<DnsConfig> NET_EXPORT_PRIVATE
+ConvertSettingsToDnsConfig(const DnsSystemSettings& settings);
 
 // Service for reading and watching Windows system DNS settings. This object is
 // not thread-safe and methods may perform blocking I/O so methods must be

net/dns/dns_config_service_win_unittest.cc

@@ -4,11 +4,16 @@
 
 #include "net/dns/dns_config_service_win.h"
 
+#include <string>
+#include <vector>
+
 #include "base/check.h"
 #include "base/memory/free_deleter.h"
+#include "base/optional.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/dns/public/dns_protocol.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -18,33 +23,22 @@ namespace {
 TEST(DnsConfigServiceWinTest, ParseSearchList) {
   const struct TestCase {
     const wchar_t* input;
-    const char* output[4];  // NULL-terminated, empty if expected false
+    std::vector<std::string> expected;
   } cases[] = {
-      {L"chromium.org", {"chromium.org", nullptr}},
-      {L"chromium.org,org", {"chromium.org", "org", nullptr}},
+      {L"chromium.org", {"chromium.org"}},
+      {L"chromium.org,org", {"chromium.org", "org"}},
       // Empty suffixes terminate the list
-      {L"crbug.com,com,,org", {"crbug.com", "com", nullptr}},
+      {L"crbug.com,com,,org", {"crbug.com", "com"}},
       // IDN are converted to punycode
       {L"\u017c\xf3\u0142ta.pi\u0119\u015b\u0107.pl,pl",
-       {"xn--ta-4ja03asj.xn--pi-wla5e0q.pl", "pl", nullptr}},
+       {"xn--ta-4ja03asj.xn--pi-wla5e0q.pl", "pl"}},
       // Empty search list is invalid
-      {L"", {nullptr}},
-      {L",,", {nullptr}},
+      {L"", {}},
+      {L",,", {}},
   };
 
   for (const auto& t : cases) {
-    std::vector<std::string> actual_output, expected_output;
-    actual_output.push_back("UNSET");
-    for (const char* const* output = t.output; *output; ++output) {
-      expected_output.push_back(*output);
-    }
-    bool result = internal::ParseSearchList(t.input, &actual_output);
-    if (!expected_output.empty()) {
-      EXPECT_TRUE(result);
-      EXPECT_EQ(expected_output, actual_output);
-    } else {
-      EXPECT_FALSE(result) << "Unexpected parse success on " << t.input;
-    }
+    EXPECT_EQ(internal::ParseSearchList(t.input), t.expected);
   }
 }
 
@@ -183,14 +177,13 @@ TEST(DnsConfigServiceWinTest, ConvertAdapterAddresses) {
       expected_nameservers.push_back(IPEndPoint(ip, port));
     }
 
-    DnsConfig config;
-    bool success = internal::ConvertSettingsToDnsConfig(settings, &config);
+    base::Optional<DnsConfig> config =
+        internal::ConvertSettingsToDnsConfig(settings);
     bool expected_success = !expected_nameservers.empty();
-    EXPECT_EQ(expected_success, success);
-    EXPECT_EQ(expected_nameservers, config.nameservers);
-    if (success) {
-      ASSERT_EQ(1u, config.search.size());
-      EXPECT_EQ(t.expected_suffix, config.search[0]);
+    EXPECT_EQ(expected_success, config.has_value());
+    if (config.has_value()) {
+      EXPECT_EQ(expected_nameservers, config->nameservers);
+      EXPECT_THAT(config->search, testing::ElementsAre(t.expected_suffix));
     }
   }
 }
@@ -211,7 +204,7 @@ TEST(DnsConfigServiceWinTest, ConvertSuffixSearch) {
       internal::DnsSystemSettings::DevolutionSetting dnscache_devolution;
       internal::DnsSystemSettings::DevolutionSetting tcpip_devolution;
     } input_settings;
-    std::string expected_search[5];
+    std::vector<std::string> expected_search;
   } cases[] = {
       {
           // Policy SearchList override.
@@ -389,13 +382,10 @@ TEST(DnsConfigServiceWinTest, ConvertSuffixSearch) {
     settings.dnscache_devolution = t.input_settings.dnscache_devolution;
     settings.tcpip_devolution = t.input_settings.tcpip_devolution;
 
-    DnsConfig config;
-    EXPECT_TRUE(internal::ConvertSettingsToDnsConfig(settings, &config));
-    std::vector<std::string> expected_search;
-    for (size_t j = 0; !t.expected_search[j].empty(); ++j) {
-      expected_search.push_back(t.expected_search[j]);
-    }
-    EXPECT_EQ(expected_search, config.search);
+    EXPECT_THAT(
+        internal::ConvertSettingsToDnsConfig(settings),
+        testing::Optional(testing::Field(
+            &DnsConfig::search, testing::ElementsAreArray(t.expected_search))));
   }
 }
 
@@ -416,9 +406,10 @@ TEST(DnsConfigServiceWinTest, AppendToMultiLabelName) {
     internal::DnsSystemSettings settings;
     settings.addresses = CreateAdapterAddresses(infos);
     settings.append_to_multi_label_name = t.input;
-    DnsConfig config;
-    EXPECT_TRUE(internal::ConvertSettingsToDnsConfig(settings, &config));
-    EXPECT_EQ(t.expected_output, config.append_to_multi_label_name);
+    EXPECT_THAT(
+        internal::ConvertSettingsToDnsConfig(settings),
+        testing::Optional(testing::Field(&DnsConfig::append_to_multi_label_name,
+                                         testing::Eq(t.expected_output))));
   }
 }
 
@@ -441,10 +432,11 @@ TEST(DnsConfigServiceWinTest, HaveNRPT) {
     internal::DnsSystemSettings settings;
     settings.addresses = CreateAdapterAddresses(infos);
     settings.have_name_resolution_policy = t.have_nrpt;
-    DnsConfig config;
-    EXPECT_TRUE(internal::ConvertSettingsToDnsConfig(settings, &config));
-    EXPECT_EQ(t.unhandled_options, config.unhandled_options);
-    EXPECT_EQ(t.have_nrpt, config.use_local_ipv6);
+    base::Optional<DnsConfig> config =
+        internal::ConvertSettingsToDnsConfig(settings);
+    ASSERT_TRUE(config.has_value());
+    EXPECT_EQ(t.unhandled_options, config->unhandled_options);
+    EXPECT_EQ(t.have_nrpt, config->use_local_ipv6);
   }
 }
 
@@ -467,9 +459,10 @@ TEST(DnsConfigServiceWinTest, HaveProxy) {
     internal::DnsSystemSettings settings;
     settings.addresses = CreateAdapterAddresses(infos);
     settings.have_proxy = t.have_proxy;
-    DnsConfig config;
-    EXPECT_TRUE(internal::ConvertSettingsToDnsConfig(settings, &config));
-    EXPECT_EQ(t.unhandled_options, config.unhandled_options);
+    EXPECT_THAT(
+        internal::ConvertSettingsToDnsConfig(settings),
+        testing::Optional(testing::Field(&DnsConfig::unhandled_options,
+                                         testing::Eq(t.unhandled_options))));
   }
 }
 
@@ -483,9 +476,9 @@ TEST(DnsConfigServiceWinTest, UsesVpn) {
 
   internal::DnsSystemSettings settings;
   settings.addresses = CreateAdapterAddresses(infos);
-  DnsConfig config;
-  EXPECT_TRUE(internal::ConvertSettingsToDnsConfig(settings, &config));
-  EXPECT_TRUE(config.unhandled_options);
+  EXPECT_THAT(internal::ConvertSettingsToDnsConfig(settings),
+              testing::Optional(testing::Field(&DnsConfig::unhandled_options,
+                                               testing::IsTrue())));
 }
 
 }  // namespace

net/dns/dns_config_watcher_mac.cc

@@ -78,9 +78,7 @@ bool DnsConfigWatcher::Watch(
 }
 
 // static
-bool DnsConfigWatcher::CheckDnsConfig(bool* out_unhandled_options) {
-  DCHECK(out_unhandled_options);
-
+bool DnsConfigWatcher::CheckDnsConfig(bool& out_unhandled_options) {
   if (!GetDnsInfoApi().dns_configuration_copy)
     return false;
   std::unique_ptr<dns_config_t, DnsConfigTDeleter> dns_config(
@@ -100,7 +98,7 @@ bool DnsConfigWatcher::CheckDnsConfig(bool* out_unhandled_options) {
     ++num_resolvers;
   }
 
-  *out_unhandled_options = num_resolvers > 1;
+  out_unhandled_options = num_resolvers > 1;
   return true;
 }
 

net/dns/dns_config_watcher_mac.h

@@ -17,7 +17,7 @@ class DnsConfigWatcher {
   bool Watch(const base::RepeatingCallback<void(bool succeeded)>& callback);
 
   // Returns false iff a valid config could not be determined.
-  static bool CheckDnsConfig(bool* out_unhandled_options);
+  static bool CheckDnsConfig(bool& out_unhandled_options);
 
  private:
   NotifyWatcherMac watcher_;

net/dns/dns_parse_domain_ascii_win_fuzzer.cc

@@ -18,9 +18,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 
   base::StringPiece16 widestr(
       reinterpret_cast<const base::StringPiece16::value_type*>(data), size / 2);
-  std::string result;
+  std::string result = net::internal::ParseDomainASCII(widestr);
 
-  if (net::internal::ParseDomainASCII(widestr, &result))
+  if (!result.empty())
     // Call base::ToLowerASCII to get some additional code coverage signal.
     result = base::ToLowerASCII(result);