Add a self-destruct mechanism to user-level Chrome Frame when it detects that system-level Chrome...

chrome_frame/registry_watcher.cc

+// Copyright (c) 2011 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.
+//
+// A utility class that makes it easy to register for registry change
+// notifications.
+//
+
+#include "chrome_frame/registry_watcher.h"
+
+#include "chrome_frame/chrome_frame_helper_util.h"
+
+namespace {
+const wchar_t kRegistryWatcherEventName[] = L"chrome_registry_watcher_event";
+}  // namespace
+
+RegistryWatcher::RegistryWatcher(HKEY hive,
+                                 const wchar_t* path,
+                                 WAITORTIMERCALLBACK callback)
+    : callback_(callback),
+      wait_event_(NULL),
+      wait_handle_(NULL),
+      stopping_(false) {
+  // Enforce that we can open the given registry path with the KEY_NOTIFY
+  // permission.
+  LONG result = RegOpenKeyEx(hive, path, 0, KEY_NOTIFY, &registry_key_);
+  if (result != ERROR_SUCCESS) {
+    registry_key_ = NULL;
+  }
+}
+
+RegistryWatcher::~RegistryWatcher() {
+  StopWatching();
+  if (registry_key_) {
+    RegCloseKey(registry_key_);
+    registry_key_ = NULL;
+  }
+}
+
+bool RegistryWatcher::StartWatching() {
+  if (!registry_key_ || wait_event_ || !callback_) {
+    return false;
+  }
+
+  bool result = false;
+  wait_event_ = CreateEvent(NULL,
+                            FALSE,  // Auto-resets
+                            FALSE,  // Initially non-signalled
+                            kRegistryWatcherEventName);
+  if (wait_event_ != NULL) {
+    LONG notify_result = RegNotifyChangeKeyValue(
+        registry_key_,
+        TRUE,  // Watch subtree
+        REG_NOTIFY_CHANGE_NAME,  // Notifies if a subkey is added.
+        wait_event_,
+        TRUE);  // Asynchronous, signal the event when a change occurs.
+
+    if (notify_result == ERROR_SUCCESS) {
+      if (RegisterWaitForSingleObject(&wait_handle_,
+                                      wait_event_,
+                                      callback_,
+                                      reinterpret_cast<void*>(this),
+                                      INFINITE,
+                                      WT_EXECUTEDEFAULT)) {
+        stopping_ = false;
+        result = true;
+      }

[grt (UTC plus 2), 2011/05/26 17:08:58]

 else { CloseHandle(wait_event_); wait_event_ = NULL; }
so that a failed call to StartWatching leaves the instance in the same state as
before the call.

[robertshield, 2011/05/27 03:34:59]

Need to do this if either the RegisterWait..() or the RegNotify..() fail so
moved below.

+    }
+  }
+
+  return result;
+}
+
+void RegistryWatcher::StopWatching() {
+  stopping_ = true;
+  if (wait_handle_) {
+    // Unregister the wait and block until any current handlers have returned.
+    UnregisterWaitEx(wait_handle_, INVALID_HANDLE_VALUE);
+    wait_handle_ = NULL;
+  }
+  if (wait_event_) {
+    CloseHandle(wait_event_);
+    wait_event_ = NULL;
+  }
+}