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

base/win/registry.h

 // 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.
 
 #ifndef BASE_WIN_REGISTRY_H_
 #define BASE_WIN_REGISTRY_H_
 
 #include <windows.h>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/stl_util.h"
-#include "base/win/object_watcher.h"
-#include "base/win/scoped_handle.h"
 
 namespace base {
 namespace win {
 
 // Utility class to read, write and manipulate the Windows Registry.
 // Registry vocabulary primer: a "key" is like a folder, in which there
 // are "values", which are <name, data> pairs, with an associated data type.
 //
 // Note:
 // ReadValue family of functions guarantee that the return arguments
 // are not touched in case of failure.
 class BASE_EXPORT RegKey {
  public:
-  // Called from the MessageLoop when the key changes.
-  typedef base::Callback<void()> ChangeCallback;
-
   RegKey();
   explicit RegKey(HKEY key);
   RegKey(HKEY rootkey, const wchar_t* subkey, REGSAM access);
   ~RegKey();
 
   LONG Create(HKEY rootkey, const wchar_t* subkey, REGSAM access);
 
   LONG CreateWithDisposition(HKEY rootkey, const wchar_t* subkey,
                              DWORD* disposition, REGSAM access);
 
@@ skipping 75 matching lines @@
   LONG WriteValue(const wchar_t* name, const wchar_t* in_value);
 
   // Sets raw data, including type.
   LONG WriteValue(const wchar_t* name,
                   const void* data,
                   DWORD dsize,
                   DWORD dtype);
 
   // Starts watching the key to see if any of its values have changed.
   // The key must have been opened with the KEY_NOTIFY access privilege.
-  // Returns true on success.
-  // To stop watching, delete this RegKey object. To continue watching the
-  // object after the callback is invoked, call StartWatching again.
-  bool StartWatching(const ChangeCallback& callback);
+  LONG StartWatching();
 
+  // If StartWatching hasn't been called, always returns false.
+  // Otherwise, returns true if anything under the key has changed.
+  // This can't be const because the |watch_event_| may be refreshed.
+  bool HasChanged();
+
+  // Will automatically be called by destructor if not manually called
+  // beforehand.  Returns true if it was watching, false otherwise.
+  LONG StopWatching();
+
+  inline bool IsWatching() const { return watch_event_ != 0; }
+  HANDLE watch_event() const { return watch_event_; }
   HKEY Handle() const { return key_; }
 
  private:
-  class Watcher;
-
   // Calls RegDeleteKeyEx on supported platforms, alternatively falls back to
   // RegDeleteKey.
   static LONG RegDeleteKeyExWrapper(HKEY hKey,
                                     const wchar_t* lpSubKey,
                                     REGSAM samDesired,
                                     DWORD Reserved);
 
   // Recursively deletes a key and all of its subkeys.
   static LONG RegDelRecurse(HKEY root_key,
                             const std::wstring& name,
                             REGSAM access);
-
   HKEY key_;  // The registry key being iterated.
+  HANDLE watch_event_;
   REGSAM wow64access_;
-  scoped_ptr<Watcher> key_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(RegKey);
 };
 
 // Iterates the entries found in a particular folder on the registry.
 class BASE_EXPORT RegistryValueIterator {
  public:
   // Construct a Registry Value Iterator with default WOW64 access.
   RegistryValueIterator(HKEY root_key, const wchar_t* folder_key);
 
@@ skipping 87 matching lines @@
 
   wchar_t name_[MAX_PATH];
 
   DISALLOW_COPY_AND_ASSIGN(RegistryKeyIterator);
 };
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_WIN_REGISTRY_H_