Remove raw handles from base::win::RegKey

net/dns/dns_config_service_win.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/dns_config_service_win.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_path_watcher.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_profile.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
-#include "base/win/object_watcher.h"
 #include "base/win/registry.h"
+#include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
 #include "net/dns/dns_hosts.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/serial_worker.h"
 #include "url/url_canon.h"
 
 #pragma comment(lib, "iphlpapi.lib")
 
@@ skipping 247 matching lines @@
       } else if (!have_ipv6 && (ipe.GetFamily() == ADDRESS_FAMILY_IPV6)) {
         have_ipv6 = true;
         (*hosts)[DnsHostsKey(localname, ADDRESS_FAMILY_IPV6)] = ipe.address();
       }
     }
   }
   return HOSTS_PARSE_WIN_OK;
 }
 
 // Watches a single registry key for changes.
-class RegistryWatcher : public base::win::ObjectWatcher::Delegate,
-                        public base::NonThreadSafe {
+class RegistryWatcher : public base::NonThreadSafe {
  public:
   typedef base::Callback<void(bool succeeded)> CallbackType;
   RegistryWatcher() {}
 
   bool Watch(const wchar_t* key, const CallbackType& callback) {
     DCHECK(CalledOnValidThread());
     DCHECK(!callback.is_null());
     DCHECK(callback_.is_null());
     callback_ = callback;
     if (key_.Open(HKEY_LOCAL_MACHINE, key, KEY_NOTIFY) != ERROR_SUCCESS)
       return false;
-    if (key_.StartWatching() != ERROR_SUCCESS)
-      return false;
-    if (!watcher_.StartWatching(key_.watch_event(), this))
-      return false;
-    return true;
+
+    return key_.StartWatching(base::Bind(&RegistryWatcher::OnObjectSignaled,
+                                         base::Unretained(this)));
   }
 
-  virtual void OnObjectSignaled(HANDLE object) override {
+  void OnObjectSignaled() {
     // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
     tracked_objects::ScopedProfile tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "RegistryWatcher_OnObjectSignaled"));
 
     DCHECK(CalledOnValidThread());
-    bool succeeded = (key_.StartWatching() == ERROR_SUCCESS) &&
-                      watcher_.StartWatching(key_.watch_event(), this);
-    if (!succeeded && key_.Valid()) {
-      watcher_.StopWatching();
-      key_.StopWatching();
+    DCHECK(!callback_.is_null());
+    if (key_.StartWatching(base::Bind(&RegistryWatcher::OnObjectSignaled,
+                                      base::Unretained(this)))) {
+      callback_.Run(true);
+    } else {
       key_.Close();
+      callback_.Run(false);
     }
-    if (!callback_.is_null())
-      callback_.Run(succeeded);
   }
 
  private:
   CallbackType callback_;
   base::win::RegKey key_;
-  base::win::ObjectWatcher watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(RegistryWatcher);
 };
 
 // Returns true iff |address| is DNS address from IPv6 stateless discovery,
 // i.e., matches fec0:0:0:ffff::{1,2,3}.
 // http://tools.ietf.org/html/draft-ietf-ipngwg-dns-discovery
 bool IsStatelessDiscoveryAddress(const IPAddressNumber& address) {
   if (address.size() != kIPv6AddressSize)
     return false;
@@ skipping 386 matching lines @@
 bool DnsConfigServiceWin::StartWatching() {
   // TODO(szym): re-start watcher if that makes sense. http://crbug.com/116139
   watcher_.reset(new Watcher(this));
   UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus", DNS_CONFIG_WATCH_STARTED,
                             DNS_CONFIG_WATCH_MAX);
   return watcher_->Watch();
 }
 
 void DnsConfigServiceWin::OnConfigChanged(bool succeeded) {
   InvalidateConfig();
-  if (succeeded) {
-    config_reader_->WorkNow();
-  } else {
+  config_reader_->WorkNow();
+  if (!succeeded) {
     LOG(ERROR) << "DNS config watch failed.";
     set_watch_failed(true);
     UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                               DNS_CONFIG_WATCH_FAILED_CONFIG,
                               DNS_CONFIG_WATCH_MAX);
   }
 }
 
 void DnsConfigServiceWin::OnHostsChanged(bool succeeded) {
   InvalidateHosts();
   if (succeeded) {
     hosts_reader_->WorkNow();
   } else {
     LOG(ERROR) << "DNS hosts watch failed.";
     set_watch_failed(true);
     UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                               DNS_CONFIG_WATCH_FAILED_HOSTS,
                               DNS_CONFIG_WATCH_MAX);
   }
 }
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServiceWin());
 }
 
 }  // namespace net