Standardize struct public member variables in ServiceProcessState::StateData

chrome/common/service_process_util_mac.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.
 
 #include "chrome/common/service_process_util_posix.h"
 
 #import <Foundation/Foundation.h>
 #include <launch.h>
 
 #include <vector>
@@ skipping 162 matching lines @@
 bool ServiceProcessState::Initialize() {
   CFErrorRef err = NULL;
   CFDictionaryRef dict =
       Launchd::GetInstance()->CopyDictionaryByCheckingIn(&err);
   if (!dict) {
     DLOG(ERROR) << "ServiceProcess must be launched by launchd. "
                 << "CopyLaunchdDictionaryByCheckingIn: " << err;
     CFRelease(err);
     return false;
   }
-  state_->launchd_conf_.reset(dict);
+  state_->launchd_conf.reset(dict);
   return true;
 }
 
 IPC::ChannelHandle ServiceProcessState::GetServiceProcessChannel() {
   DCHECK(state_);
-  NSDictionary *ns_launchd_conf = base::mac::CFToNSCast(state_->launchd_conf_);
+  NSDictionary *ns_launchd_conf = base::mac::CFToNSCast(state_->launchd_conf);
   NSDictionary* socket_dict =
       [ns_launchd_conf objectForKey:@ LAUNCH_JOBKEY_SOCKETS];
   NSArray* sockets =
       [socket_dict objectForKey:GetServiceProcessLaunchDSocketKey()];
   DCHECK_EQ([sockets count], 1U);
   int socket = [[sockets objectAtIndex:0] intValue];
   base::FileDescriptor fd(socket, false);
   return IPC::ChannelHandle(std::string(), fd);
 }
 
@@ skipping 94 matching lines @@
                                                   name,
                                                   plist);
 }
 
 bool ServiceProcessState::RemoveFromAutoRun() {
   return RemoveFromLaunchd();
 }
 
 bool ServiceProcessState::StateData::WatchExecutable() {
   base::mac::ScopedNSAutoreleasePool pool;
-  NSDictionary* ns_launchd_conf = base::mac::CFToNSCast(launchd_conf_);
+  NSDictionary* ns_launchd_conf = base::mac::CFToNSCast(launchd_conf);
   NSString* exe_path = [ns_launchd_conf objectForKey:@ LAUNCH_JOBKEY_PROGRAM];
   if (!exe_path) {
     DLOG(ERROR) << "No " LAUNCH_JOBKEY_PROGRAM;
     return false;
   }
 
   base::FilePath executable_path =
       base::FilePath([exe_path fileSystemRepresentation]);
   scoped_ptr<ExecFilePathWatcherCallback> callback(
       new ExecFilePathWatcherCallback);
   if (!callback->Init(executable_path)) {
-    DLOG(ERROR) << "executable_watcher_.Init " << executable_path.value();
+    DLOG(ERROR) << "executable_watcher.Init " << executable_path.value();
     return false;
   }
-  if (!executable_watcher_.Watch(
+  if (!executable_watcher.Watch(
           executable_path,
           false,
           base::Bind(&ExecFilePathWatcherCallback::NotifyPathChanged,
                      base::Owned(callback.release())))) {
-    DLOG(ERROR) << "executable_watcher_.watch " << executable_path.value();
+    DLOG(ERROR) << "executable_watcher.watch " << executable_path.value();
     return false;
   }
   return true;
 }
 
 bool ExecFilePathWatcherCallback::Init(const base::FilePath& path) {
   return base::mac::FSRefFromPath(path.value(), &executable_fsref_);
 }
 
 void ExecFilePathWatcherCallback::NotifyPathChanged(const base::FilePath& path,
@@ skipping 99 matching lines @@
       CFErrorRef err = NULL;
       if (!Launchd::GetInstance()->RemoveJob(label, &err)) {
         base::ScopedCFTypeRef<CFErrorRef> scoped_err(err);
         DLOG(ERROR) << "RemoveJob " << err;
         // Exiting with zero, so launchd doesn't restart the process.
         exit(0);
       }
     }
   }
 }