[Chromoting] Update uninstaller to facilitate testing automation.

remoting/host/me2me_preference_pane.mm

 // 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.
 
 #import "remoting/host/me2me_preference_pane.h"
 
 #import <Cocoa/Cocoa.h>
 #include <CommonCrypto/CommonHMAC.h>
 #include <errno.h>
 #include <launch.h>
@@ skipping 15 matching lines @@
 #include "third_party/jsoncpp/source/include/json/writer.h"
 #include "third_party/modp_b64/modp_b64.h"
 
 namespace {
 
 bool GetTemporaryConfigFilePath(std::string* path) {
   NSString* filename = NSTemporaryDirectory();
   if (filename == nil)
     return false;
 
-  filename = [filename stringByAppendingString:@"/" kServiceName ".json"];
-  *path = [filename UTF8String];
+  *path = [[NSString stringWithFormat:@"%@/%s",
+            filename, remoting::kHostConfigFileName] UTF8String];
   return true;
 }
 
 bool IsConfigValid(const remoting::JsonHostConfig* config) {
   std::string value;
   return (config->GetString(remoting::kHostIdConfigPath, &value) &&
           config->GetString(remoting::kHostSecretHashConfigPath, &value) &&
           config->GetString(remoting::kXmppLoginConfigPath, &value));
 }
 
@@ skipping 171 matching lines @@
     *pid = line_pid;
   }
 
   return status;
 }
 
 }  // namespace mac
 }  // namespace base
 
 namespace remoting {
+
 JsonHostConfig::JsonHostConfig(const std::string& filename)
     : filename_(filename) {
 }
 
 JsonHostConfig::~JsonHostConfig() {
 }
 
 bool JsonHostConfig::Read() {
   std::ifstream file(filename_.c_str());
   Json::Reader reader;
@@ skipping 36 matching lines @@
 }
 
 - (void)willSelect {
   have_new_config_ = NO;
   awaiting_service_stop_ = NO;
 
   NSDistributedNotificationCenter* center =
       [NSDistributedNotificationCenter defaultCenter];
   [center addObserver:self
              selector:@selector(onNewConfigFile:)
-                 name:@kServiceName
+                 name:[NSString stringWithUTF8String:remoting::kServiceName]
                object:nil];
 
   service_status_timer_ =
       [[NSTimer scheduledTimerWithTimeInterval:2.0
                                         target:self
                                       selector:@selector(refreshServiceStatus:)
                                       userInfo:nil
                                        repeats:YES] retain];
   [self updateServiceStatus];
   [self updateAuthorizationStatus];
@@ skipping 11 matching lines @@
 
 - (void)willUnselect {
   NSDistributedNotificationCenter* center =
       [NSDistributedNotificationCenter defaultCenter];
   [center removeObserver:self];
 
   [service_status_timer_ invalidate];
   [service_status_timer_ release];
   service_status_timer_ = nil;
 
-  [self notifyPlugin:kUpdateFailedNotificationName];
+  [self notifyPlugin:UPDATE_FAILED_NOTIFICATION_NAME];
 }
 
 - (void)applyConfiguration:(id)sender
                        pin:(NSString*)pin {
   if (!have_new_config_) {
     // It shouldn't be possible to hit the button if there is no config to
     // apply, but check anyway just in case it happens somehow.
     return;
   }
 
@@ skipping 23 matching lines @@
   // Ensure the authorization token is up-to-date before using it.
   [self updateAuthorizationStatus];
   [self updateUI];
   if (!is_pane_unlocked_)
     return;
 
   if (![self runHelperAsRootWithCommand:"--disable"
                               inputData:""]) {
     NSLog(@"Failed to run the helper tool");
     [self showError];
-    [self notifyPlugin: kUpdateFailedNotificationName];
+    [self notifyPlugin:UPDATE_FAILED_NOTIFICATION_NAME];
     return;
   }
 
   // Stop the launchd job.  This cannot easily be done by the helper tool,
   // since the launchd job runs in the current user's context.
   [self sendJobControlMessage:LAUNCH_KEY_STOPJOB];
   awaiting_service_stop_ = YES;
 }
 
 - (void)onNewConfigFile:(NSNotification*)notification {
   [self checkInstalledVersion];
   if (!restart_pending_or_canceled_)
     [self readNewConfig];
 
   [self updateUI];
 }
 
 - (void)refreshServiceStatus:(NSTimer*)timer {
   BOOL was_running = is_service_running_;
   [self updateServiceStatus];
   if (awaiting_service_stop_ && !is_service_running_) {
     awaiting_service_stop_ = NO;
-    [self notifyPlugin:kUpdateSucceededNotificationName];
+    [self notifyPlugin:UPDATE_SUCCEEDED_NOTIFICATION_NAME];
   }
 
   if (was_running != is_service_running_)
     [self updateUI];
 }
 
 - (void)authorizationViewDidAuthorize:(SFAuthorizationView*)view {
   [self updateAuthorizationStatus];
   [self updateUI];
 }
 
 - (void)authorizationViewDidDeauthorize:(SFAuthorizationView*)view {
   [self updateAuthorizationStatus];
   [self updateUI];
 }
 
 - (void)updateServiceStatus {
-  pid_t job_pid = base::mac::PIDForJob(kServiceName);
+  pid_t job_pid = base::mac::PIDForJob(remoting::kServiceName);
   is_service_running_ = (job_pid > 0);
 }
 
 - (void)updateAuthorizationStatus {
   is_pane_unlocked_ = [authorization_view_ updateStatus:authorization_view_];
 }
 
 - (void)readNewConfig {
   std::string file;
   if (!GetTemporaryConfigFilePath(&file)) {
@@ skipping 105 matching lines @@
     NSLog(@"Failed to run the helper tool");
     [self showError];
     return;
   }
 
   have_new_config_ = NO;
 
   // If the service is running, send a signal to cause it to reload its
   // configuration, otherwise start the service.
   if (is_service_running_) {
-    pid_t job_pid = base::mac::PIDForJob(kServiceName);
+    pid_t job_pid = base::mac::PIDForJob(remoting::kServiceName);
     if (job_pid > 0) {
       kill(job_pid, SIGHUP);
     } else {
-      NSLog(@"Failed to obtain PID of service " kServiceName);
+      NSLog(@"Failed to obtain PID of service %s", remoting::kServiceName);
       [self showError];
     }
   } else {
     [self sendJobControlMessage:LAUNCH_KEY_STARTJOB];
   }
 
   // Broadcast a distributed notification to inform the plugin that the
   // configuration has been applied.
-  [self notifyPlugin: kUpdateSucceededNotificationName];
+  [self notifyPlugin:UPDATE_SUCCEEDED_NOTIFICATION_NAME];
 }
 
 - (BOOL)runHelperAsRootWithCommand:(const char*)command
                          inputData:(const std::string&)input_data {
   AuthorizationRef authorization =
       [[authorization_view_ authorization] authorizationRef];
   if (!authorization) {
     NSLog(@"Failed to obtain authorizationRef");
     return NO;
   }
 
   // TODO(lambroslambrou): Replace the deprecated ExecuteWithPrivileges
   // call with a launchd-based helper tool, which is more secure.
   // http://crbug.com/120903
   const char* arguments[] = { command, NULL };
   FILE* pipe = NULL;
   pid_t pid;
   OSStatus status = base::mac::ExecuteWithPrivilegesAndGetPID(
       authorization,
-      remoting::kHostHelperTool,
+      remoting::kHostHelperScriptPath,
       kAuthorizationFlagDefaults,
       arguments,
       &pipe,
       &pid);
   if (status != errAuthorizationSuccess) {
     NSLog(@"AuthorizationExecuteWithPrivileges: %s (%d)",
           GetMacOSStatusErrorString(status), static_cast<int>(status));
     return NO;
   }
   if (pid == -1) {
@@ skipping 39 matching lines @@
     error = YES;
   }
 
   // No more cleanup needed.
   if (error)
     return NO;
 
   if (WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == 0) {
     return YES;
   } else {
-    NSLog(@"%s failed with exit status %d", remoting::kHostHelperTool,
+    NSLog(@"%s failed with exit status %d", remoting::kHostHelperScriptPath,
           exit_status);
     return NO;
   }
 }
 
 - (BOOL)sendJobControlMessage:(const char*)launch_key {
   base::mac::ScopedLaunchData response(
-      base::mac::MessageForJob(kServiceName, launch_key));
+      base::mac::MessageForJob(remoting::kServiceName, launch_key));
   if (!response) {
     NSLog(@"Failed to send message to launchd");
     [self showError];
     return NO;
   }
 
   // Expect a response of type LAUNCH_DATA_ERRNO.
   launch_data_type_t type = launch_data_get_type(response.get());
   if (type != LAUNCH_DATA_ERRNO) {
     NSLog(@"launchd returned unexpected type: %d", type);
@@ skipping 95 matching lines @@
     std::string file;
     if (!GetTemporaryConfigFilePath(&file)) {
       // There's no point in alerting the user here.  The same error would
       // happen when the pane is eventually restarted, so the user would be
       // alerted at that time.
       NSLog(@"Failed to get path of configuration data.");
       return;
     }
 
     remove(file.c_str());
-    [self notifyPlugin:kUpdateFailedNotificationName];
+    [self notifyPlugin:UPDATE_FAILED_NOTIFICATION_NAME];
   }
 }
 
 - (void)restartSystemPreferences {
   NSTask* task = [[NSTask alloc] init];
   NSString* command =
-      [NSString stringWithUTF8String:remoting::kHostHelperTool];
+      [NSString stringWithUTF8String:remoting::kHostHelperScriptPath];
   NSArray* arguments = [NSArray arrayWithObjects:@"--relaunch-prefpane", nil];
   [task setLaunchPath:command];
   [task setArguments:arguments];
   [task setStandardInput:[NSPipe pipe]];
   [task launch];
   [task release];
   [NSApp terminate:nil];
 }
 
 @end