Detect if user closes the pref-pane without disabling Chromoting

remoting/host/plugin/daemon_controller_mac.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 "remoting/host/plugin/daemon_controller.h"
 
 #include <launch.h>
 #include <stdio.h>
 #include <sys/types.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/launchd.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_launch_data.h"
+#include "base/sys_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "remoting/host/json_host_config.h"
 
 namespace remoting {
 
 namespace {
 
 // The NSSystemDirectories.h header has a conflicting definition of
 // NSSearchPathDirectory with the one in base/mac/foundation_util.h.
 // Foundation.h would work, but it can only be included from Objective-C files.
 // Therefore, we define the needed constants here.
 const int NSLibraryDirectory = 5;
 
 // The name of the Remoting Host service that is registered with launchd.
 #define kServiceName "org.chromium.chromoting"
 
 // Use separate named notifications for success and failure because sandboxed
 // components can't include a dictionary when sending distributed notifications.
 // The preferences panel is not yet sandboxed, but err on the side of caution.
 #define kUpdateSucceededNotificationName kServiceName ".update_succeeded"
 #define kUpdateFailedNotificationName kServiceName ".update_failed"
+#define kUserCanceledNotificationName kServiceName ".user_canceled"
+
+const char* all_notifications[] = {
+  kUpdateSucceededNotificationName,
+  kUpdateFailedNotificationName,
+  kUserCanceledNotificationName
+};
 
 #define kConfigDir "/Library/PrivilegedHelperTools/"
 
 // This helper script is used to get the installed host version.
 const char kHostHelperScript[] = kConfigDir kServiceName ".me2me.sh";
 
 // Use a single configuration file, instead of separate "auth" and "host" files.
 // This is because the SetConfigAndStart() API only provides a single
 // dictionary, and splitting this into two dictionaries would require
 // knowledge of which keys belong in which files.
@@ skipping 47 matching lines @@
     : auth_thread_("Auth thread") {
   auth_thread_.Start();
 }
 
 DaemonControllerMac::~DaemonControllerMac() {
   auth_thread_.Stop();
   DeregisterForPreferencePaneNotifications();
 }
 
 void DaemonControllerMac::DeregisterForPreferencePaneNotifications() {
-  CFNotificationCenterRemoveObserver(
-      CFNotificationCenterGetDistributedCenter(),
-      this,
-      CFSTR(kUpdateSucceededNotificationName),
-      NULL);
-  CFNotificationCenterRemoveObserver(
-      CFNotificationCenterGetDistributedCenter(),
-      this,
-      CFSTR(kUpdateFailedNotificationName),
-      NULL);
+  for (size_t i = 0; i < arraysize(all_notifications); i++) {
+    base::mac::ScopedCFTypeRef<CFStringRef> cfstring(
+        base::SysUTF8ToCFStringRef(all_notifications[i]));
+    CFNotificationCenterRemoveObserver(
+        CFNotificationCenterGetDistributedCenter(),
+        this,
+        cfstring,
+        NULL);
+  }
 }
 
 DaemonController::State DaemonControllerMac::GetState() {
   if (!base::mac::IsOSSnowLeopardOrLater()) {
     return DaemonController::STATE_NOT_IMPLEMENTED;
   }
   pid_t job_pid = base::mac::PIDForJob(kServiceName);
   if (job_pid < 0) {
     return DaemonController::STATE_NOT_INSTALLED;
   } else if (job_pid == 0) {
@@ skipping 185 matching lines @@
 // This is safe because HostNPScriptObject::InvokeAsyncResultCallback
 // bounces the invocation to the correct thread, so it doesn't matter
 // which thread CompletionCallbacks are called on.
 void DaemonControllerMac::RegisterForPreferencePaneNotifications(
     const CompletionCallback& done_callback) {
   // We can only have one callback registered at a time. This is enforced by the
   // UX flow of the web-app.
   DCHECK(current_callback_.is_null());
   current_callback_ = done_callback;
 
-  CFNotificationCenterAddObserver(
-      CFNotificationCenterGetDistributedCenter(),
-      this,
-      &DaemonControllerMac::PreferencePaneCallback,
-      CFSTR(kUpdateSucceededNotificationName),
-      NULL,
-      CFNotificationSuspensionBehaviorDeliverImmediately);
-  CFNotificationCenterAddObserver(
-      CFNotificationCenterGetDistributedCenter(),
-      this,
-      &DaemonControllerMac::PreferencePaneCallback,
-      CFSTR(kUpdateFailedNotificationName),
-      NULL,
-      CFNotificationSuspensionBehaviorDeliverImmediately);
+  for (size_t i = 0; i < arraysize(all_notifications); i++) {
+    base::mac::ScopedCFTypeRef<CFStringRef> cfstring(
+        base::SysUTF8ToCFStringRef(all_notifications[i]));
+    CFNotificationCenterAddObserver(
+        CFNotificationCenterGetDistributedCenter(),
+        this,
+        &DaemonControllerMac::PreferencePaneCallback,
+        cfstring,
+        NULL,
+        CFNotificationSuspensionBehaviorDeliverImmediately);
+  }
 }
 
 void DaemonControllerMac::PreferencePaneCallbackDelegate(CFStringRef name) {
   AsyncResult result = RESULT_FAILED;
   if (CFStringCompare(name, CFSTR(kUpdateSucceededNotificationName), 0) ==
           kCFCompareEqualTo) {
     result = RESULT_OK;
   } else if (CFStringCompare(name, CFSTR(kUpdateFailedNotificationName), 0) ==
           kCFCompareEqualTo) {
+    result = RESULT_FAILED;
+  } else if (CFStringCompare(name, CFSTR(kUserCanceledNotificationName), 0) ==
+          kCFCompareEqualTo) {
     result = RESULT_CANCELLED;
   } else {
     LOG(WARNING) << "Ignoring unexpected notification: " << name;
     return;
   }
   DCHECK(!current_callback_.is_null());
   current_callback_.Run(result);
   current_callback_.Reset();
   DeregisterForPreferencePaneNotifications();
 }
@@ skipping 11 matching lines @@
   }
 }
 
 }  // namespace
 
 scoped_ptr<DaemonController> remoting::DaemonController::Create() {
   return scoped_ptr<DaemonController>(new DaemonControllerMac());
 }
 
 }  // namespace remoting