[Chromoting] Update uninstaller to facilitate testing automation.

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>
 
@@ skipping 19 matching lines @@
 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;
 
-// 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.
-const char kHostConfigFile[] = kHostConfigDir kServiceName ".json";
-
 class DaemonControllerMac : public remoting::DaemonController {
  public:
   DaemonControllerMac();
   virtual ~DaemonControllerMac();
 
   virtual State GetState() OVERRIDE;
   virtual void GetConfig(const GetConfigCallback& callback) OVERRIDE;
   virtual void SetConfigAndStart(
       scoped_ptr<base::DictionaryValue> config,
       bool consent,
@@ skipping 41 matching lines @@
 
 DaemonControllerMac::~DaemonControllerMac() {
   auth_thread_.Stop();
   DeregisterForPreferencePaneNotifications();
 }
 
 void DaemonControllerMac::DeregisterForPreferencePaneNotifications() {
   CFNotificationCenterRemoveObserver(
       CFNotificationCenterGetDistributedCenter(),
       this,
-      CFSTR(kUpdateSucceededNotificationName),
+      CFSTR(UPDATE_SUCCEEDED_NOTIFICATION_NAME),
       NULL);
   CFNotificationCenterRemoveObserver(
       CFNotificationCenterGetDistributedCenter(),
       this,
-      CFSTR(kUpdateFailedNotificationName),
+      CFSTR(UPDATE_FAILED_NOTIFICATION_NAME),
       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;
@@ skipping 50 matching lines @@
 }
 
 void DaemonControllerMac::GetUsageStatsConsent(
     const GetUsageStatsConsentCallback& callback) {
   // Crash dump collection is not implemented on Mac yet.
   // http://crbug.com/130678.
   callback.Run(false, false, false);
 }
 
 void DaemonControllerMac::DoGetConfig(const GetConfigCallback& callback) {
-  FilePath config_path(kHostConfigFile);
+  FilePath config_path(kHostConfigFilePath);
   JsonHostConfig host_config(config_path);
   scoped_ptr<base::DictionaryValue> config;
 
   if (host_config.Read()) {
     config.reset(new base::DictionaryValue());
     std::string value;
     if (host_config.GetString(kHostIdConfigPath, &value))
       config.get()->SetString(kHostIdConfigPath, value);
     if (host_config.GetString(kXmppLoginConfigPath, &value))
       config.get()->SetString(kXmppLoginConfigPath, value);
   }
 
   callback.Run(config.Pass());
 }
 
 void DaemonControllerMac::DoGetVersion(const GetVersionCallback& callback) {
   std::string version = "";
-  std::string command_line = remoting::kHostHelperTool;
+  std::string command_line = remoting::kHostHelperScriptPath;
   command_line += " --host-version";
   FILE* script_output = popen(command_line.c_str(), "r");
   if (script_output) {
     char buffer[100];
     char* result = fgets(buffer, sizeof(buffer), script_output);
     pclose(script_output);
     if (result) {
       // The string is guaranteed to be null-terminated, but probably contains
       // a newline character, which we don't want.
       for (int i = 0; result[i]; ++i) {
@@ skipping 12 matching lines @@
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done) {
   std::string config_data;
   base::JSONWriter::Write(config.get(), &config_data);
   ShowPreferencePane(config_data, done);
 }
 
 void DaemonControllerMac::DoUpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
-  FilePath config_file_path(kHostConfigFile);
+  FilePath config_file_path(kHostConfigFilePath);
   JsonHostConfig config_file(config_file_path);
   if (!config_file.Read()) {
     done_callback.Run(RESULT_FAILED);
     return;
   }
   for (DictionaryValue::key_iterator key(config->begin_keys());
        key != config->end_keys(); ++key) {
     std::string value;
     if (!config->GetString(*key, &value)) {
       LOG(ERROR) << *key << " is not a string.";
@@ skipping 16 matching lines @@
   }
 }
 
 bool DaemonControllerMac::DoShowPreferencePane(const std::string& config_data) {
   if (!config_data.empty()) {
     FilePath config_path;
     if (!file_util::GetTempDir(&config_path)) {
       LOG(ERROR) << "Failed to get filename for saving configuration data.";
       return false;
     }
-    config_path = config_path.Append(kServiceName ".json");
+    config_path = config_path.Append(kHostConfigFileName);
 
     int written = file_util::WriteFile(config_path, config_data.data(),
                                        config_data.size());
     if (written != static_cast<int>(config_data.size())) {
       LOG(ERROR) << "Failed to save configuration data to: "
                  << config_path.value();
       return false;
     }
   }
 
   FilePath pane_path;
   // TODO(lambroslambrou): Use NSPreferencePanesDirectory once we start
   // building against SDK 10.6.
   if (!base::mac::GetLocalDirectory(NSLibraryDirectory, &pane_path)) {
     LOG(ERROR) << "Failed to get directory for local preference panes.";
     return false;
   }
-  pane_path = pane_path.Append("PreferencePanes")
-      .Append(kServiceName ".prefPane");
+  pane_path = pane_path.Append("PreferencePanes").Append(kPrefPaneFileName);
 
   FSRef pane_path_ref;
   if (!base::mac::FSRefFromPath(pane_path.value(), &pane_path_ref)) {
     LOG(ERROR) << "Failed to create FSRef";
     return false;
   }
   OSStatus status = LSOpenFSRef(&pane_path_ref, NULL);
   if (status != noErr) {
     OSSTATUS_LOG(ERROR, status) << "LSOpenFSRef failed for path: "
                                 << pane_path.value();
     return false;
   }
 
   CFNotificationCenterRef center =
       CFNotificationCenterGetDistributedCenter();
-  CFNotificationCenterPostNotification(center, CFSTR(kServiceName), NULL, NULL,
+  base::mac::ScopedCFTypeRef<CFStringRef> service_name(
+        CFStringCreateWithCString(kCFAllocatorDefault, remoting::kServiceName,
+                                  kCFStringEncodingUTF8));
+  CFNotificationCenterPostNotification(center, service_name, NULL, NULL,
                                        TRUE);
   return true;
 }
 
 void DaemonControllerMac::DoStop(const CompletionCallback& done_callback) {
   ShowPreferencePane("", done_callback);
 }
 
 // CFNotificationCenterAddObserver ties the thread on which distributed
 // notifications are received to the one on which it is first called.
 // 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),
+      CFSTR(UPDATE_SUCCEEDED_NOTIFICATION_NAME),
       NULL,
       CFNotificationSuspensionBehaviorDeliverImmediately);
   CFNotificationCenterAddObserver(
       CFNotificationCenterGetDistributedCenter(),
       this,
       &DaemonControllerMac::PreferencePaneCallback,
-      CFSTR(kUpdateFailedNotificationName),
+      CFSTR(UPDATE_FAILED_NOTIFICATION_NAME),
       NULL,
       CFNotificationSuspensionBehaviorDeliverImmediately);
 }
 
 void DaemonControllerMac::PreferencePaneCallbackDelegate(CFStringRef name) {
   AsyncResult result = RESULT_FAILED;
-  if (CFStringCompare(name, CFSTR(kUpdateSucceededNotificationName), 0) ==
+  if (CFStringCompare(name, CFSTR(UPDATE_SUCCEEDED_NOTIFICATION_NAME), 0) ==
           kCFCompareEqualTo) {
     result = RESULT_OK;
-  } else if (CFStringCompare(name, CFSTR(kUpdateFailedNotificationName), 0) ==
+  } else if (CFStringCompare(name, CFSTR(UPDATE_FAILED_NOTIFICATION_NAME), 0) ==
           kCFCompareEqualTo) {
     result = RESULT_FAILED;
   } else {
     LOG(WARNING) << "Ignoring unexpected notification: " << name;
     return;
   }
   DCHECK(!current_callback_.is_null());
   current_callback_.Run(result);
   current_callback_.Reset();
   DeregisterForPreferencePaneNotifications();
@@ skipping 12 matching lines @@
   }
 }
 
 }  // namespace
 
 scoped_ptr<DaemonController> remoting::DaemonController::Create() {
   return scoped_ptr<DaemonController>(new DaemonControllerMac());
 }
 
 }  // namespace remoting