Revert of Remove raw handles from base::win::RegKey

base/win/registry.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 "base/win/registry.h"
 
 #include <shlwapi.h>
 #include <algorithm>
 
 #include "base/logging.h"
@@ skipping 16 matching lines @@
 // a size in wchar_t that can store a truncated wchar_t if necessary.
 inline DWORD to_wchar_size(DWORD byte_size) {
   return (byte_size + sizeof(wchar_t) - 1) / sizeof(wchar_t);
 }
 
 // Mask to pull WOW64 access flags out of REGSAM access.
 const REGSAM kWow64AccessMask = KEY_WOW64_32KEY | KEY_WOW64_64KEY;
 
 }  // namespace
 
-// Watches for modifications to a key.
-class RegKey::Watcher : public ObjectWatcher::Delegate {
- public:
-  explicit Watcher(RegKey* owner) : owner_(owner) {}
-  ~Watcher() {}
+// RegKey ----------------------------------------------------------------------
 
-  bool StartWatching(HKEY key, const ChangeCallback& callback);
-
-  // Implementation of ObjectWatcher::Delegate.
-  void OnObjectSignaled(HANDLE object) override {
-    DCHECK(watch_event_.IsValid() && watch_event_.Get() == object);
-    ChangeCallback callback = callback_;
-    callback_.Reset();
-    callback.Run();
-  }
-
- private:
-  RegKey* owner_;
-  ScopedHandle watch_event_;
-  ObjectWatcher object_watcher_;
-  ChangeCallback callback_;
-  DISALLOW_COPY_AND_ASSIGN(Watcher);
-};
-
-bool RegKey::Watcher::StartWatching(HKEY key, const ChangeCallback& callback) {
-  DCHECK(key);
-  DCHECK(callback_.is_null());
-  if (GetVersion() < VERSION_VISTA) {
-    // It is an error to register multiple times before Vista.
-    if (watch_event_.IsValid()) {
-      callback_ = callback;
-      return true;
-    }
-  }
-
-  if (!watch_event_.IsValid())
-    watch_event_.Set(CreateEvent(NULL, TRUE, FALSE, NULL));
-
-  if (!watch_event_.IsValid())
-    return false;
-
-  DWORD filter = REG_NOTIFY_CHANGE_NAME |
-                 REG_NOTIFY_CHANGE_ATTRIBUTES |
-                 REG_NOTIFY_CHANGE_LAST_SET |
-                 REG_NOTIFY_CHANGE_SECURITY;
-
-  // Watch the registry key for a change of value.
-  LONG result = RegNotifyChangeKeyValue(key, TRUE, filter, watch_event_.Get(),
-                                        TRUE);
-  if (result != ERROR_SUCCESS) {
-    watch_event_.Close();
-    return false;
-  }
-
-  callback_ = callback;
-  return object_watcher_.StartWatching(watch_event_.Get(), this);
+RegKey::RegKey()
+    : key_(NULL),
+      watch_event_(0),
+      wow64access_(0) {
 }
 
-// RegKey ----------------------------------------------------------------------
-
-RegKey::RegKey() : key_(NULL), wow64access_(0) {
-}
-
-RegKey::RegKey(HKEY key) : key_(key), wow64access_(0) {
+RegKey::RegKey(HKEY key)
+    : key_(key),
+      watch_event_(0),
+      wow64access_(0) {
 }
 
 RegKey::RegKey(HKEY rootkey, const wchar_t* subkey, REGSAM access)
     : key_(NULL),
+      watch_event_(0),
       wow64access_(0) {
   if (rootkey) {
     if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK))
       Create(rootkey, subkey, access);
     else
       Open(rootkey, subkey, access);
   } else {
     DCHECK(!subkey);
     wow64access_ = access & kWow64AccessMask;
   }
@@ skipping 79 matching lines @@
   // one.
   if (result == ERROR_SUCCESS) {
     Close();
     key_ = subkey;
     wow64access_ = access & kWow64AccessMask;
   }
   return result;
 }
 
 void RegKey::Close() {
+  StopWatching();
   if (key_) {
     ::RegCloseKey(key_);
     key_ = NULL;
     wow64access_ = 0;
   }
 }
 
 // TODO(wfh): Remove this and other unsafe methods. See http://crbug.com/375400
 void RegKey::Set(HKEY key) {
   if (key_ != key) {
     Close();
     key_ = key;
   }
 }
 
 HKEY RegKey::Take() {
   DCHECK(wow64access_ == 0);
+  StopWatching();
   HKEY key = key_;
   key_ = NULL;
   return key;
 }
 
 bool RegKey::HasValue(const wchar_t* name) const {
   return RegQueryValueEx(key_, name, 0, NULL, NULL, NULL) == ERROR_SUCCESS;
 }
 
 DWORD RegKey::GetValueCount() const {
@@ skipping 178 matching lines @@
                         const void* data,
                         DWORD dsize,
                         DWORD dtype) {
   DCHECK(data || !dsize);
 
   LONG result = RegSetValueEx(key_, name, 0, dtype,
       reinterpret_cast<LPBYTE>(const_cast<void*>(data)), dsize);
   return result;
 }
 
-bool RegKey::StartWatching(const ChangeCallback& callback) {
-  if (!key_watcher_)
-    key_watcher_.reset(new Watcher(this));
+LONG RegKey::StartWatching() {
+  DCHECK(key_);
+  if (!watch_event_)
+    watch_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
 
-  if (!key_watcher_.get()->StartWatching(key_, callback))
-    return false;
+  DWORD filter = REG_NOTIFY_CHANGE_NAME |
+                 REG_NOTIFY_CHANGE_ATTRIBUTES |
+                 REG_NOTIFY_CHANGE_LAST_SET |
+                 REG_NOTIFY_CHANGE_SECURITY;
 
-  return true;
+  // Watch the registry key for a change of value.
+  LONG result = RegNotifyChangeKeyValue(key_, TRUE, filter, watch_event_, TRUE);
+  if (result != ERROR_SUCCESS) {
+    CloseHandle(watch_event_);
+    watch_event_ = 0;
+  }
+
+  return result;
+}
+
+bool RegKey::HasChanged() {
+  if (watch_event_) {
+    if (WaitForSingleObject(watch_event_, 0) == WAIT_OBJECT_0) {
+      StartWatching();
+      return true;
+    }
+  }
+  return false;
+}
+
+LONG RegKey::StopWatching() {
+  LONG result = ERROR_INVALID_HANDLE;
+  if (watch_event_) {
+    CloseHandle(watch_event_);
+    watch_event_ = 0;
+    result = ERROR_SUCCESS;
+  }
+  return result;
 }
 
 // static
 LONG RegKey::RegDeleteKeyExWrapper(HKEY hKey,
                                    const wchar_t* lpSubKey,
                                    REGSAM samDesired,
                                    DWORD Reserved) {
   typedef LSTATUS(WINAPI* RegDeleteKeyExPtr)(HKEY, LPCWSTR, REGSAM, DWORD);
 
   RegDeleteKeyExPtr reg_delete_key_ex_func =
@@ skipping 241 matching lines @@
     } else {
       index_ = count - 1;
     }
   }
 
   Read();
 }
 
 }  // namespace win
 }  // namespace base