Move base/mac_util.h to base/mac and use the base::mac namespace....

chrome/browser/ui/cocoa/keystone_glue.mm

 // Copyright (c) 2009 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 "chrome/browser/ui/cocoa/keystone_glue.h"
 
 #include <sys/param.h>
 #include <sys/mount.h>
 
 #include <vector>
 
 #include "app/l10n_util.h"
 #import "app/l10n_util_mac.h"
 #include "base/logging.h"
-#include "base/mac_util.h"
+#include "base/mac/mac_util.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/sys_string_conversions.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/ui/cocoa/authorization_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
@@ skipping 405 matching lines @@
 
   }
   return result;
 }
 
 - (BOOL)loadKeystoneRegistration {
   if (!productID_ || !appPath_ || !url_ || !version_)
     return NO;
 
   // Load the KeystoneRegistration framework bundle if present.  It lives
-  // inside the framework, so use mac_util::MainAppBundle();
+  // inside the framework, so use base::mac::MainAppBundle();
   NSString* ksrPath =
-      [[mac_util::MainAppBundle() privateFrameworksPath]
+      [[base::mac::MainAppBundle() privateFrameworksPath]
           stringByAppendingPathComponent:@"KeystoneRegistration.framework"];
   NSBundle* ksrBundle = [NSBundle bundleWithPath:ksrPath];
   [ksrBundle load];
 
   // Harness the KSRegistration class.
   Class ksrClass = [ksrBundle classNamed:@"KSRegistration"];
   KSRegistration* ksr = [ksrClass registrationWithProductID:productID_];
   if (!ksr)
     return NO;
 
@@ skipping 261 matching lines @@
   // Check the outermost bundle directory, the main executable path, and the
   // framework directory.  It may be enough to just look at the outermost
   // bundle directory, but checking an interior file and directory can be
   // helpful in case permissions are set differently only on the outermost
   // directory.  An interior file and directory are both checked because some
   // file operations, such as Snow Leopard's Finder's copy operation when
   // authenticating, may actually result in different ownership being applied
   // to files and directories.
   NSFileManager* fileManager = [NSFileManager defaultManager];
   NSString* executablePath = [[NSBundle mainBundle] executablePath];
-  NSString* frameworkPath = [mac_util::MainAppBundle() bundlePath];
+  NSString* frameworkPath = [base::mac::MainAppBundle() bundlePath];
   return ![fileManager isWritableFileAtPath:appPath_] ||
          ![fileManager isWritableFileAtPath:executablePath] ||
          ![fileManager isWritableFileAtPath:frameworkPath];
 }
 
 - (BOOL)wantsPromotion {
   // -needsPromotion checks these too, but this method doesn't necessarily
   // return NO just becuase -needsPromotion returns NO, so another check is
   // needed here.
   if (![self isUserTicket] || [self isOnReadOnlyFilesystem]) {
@@ skipping 66 matching lines @@
   // -[KSRegistration promoteWithParameters:authorization:] is currently
   // synchronous too, and this operation needs to happen before that one.
   //
   // TODO(mark): Make asynchronous.  That only makes sense if the promotion
   // operation itself is asynchronous too.  http://b/2290009.  Hopefully,
   // the Keystone promotion code will just be changed to do what preflight
   // now does, and then the preflight script can be removed instead.
   // However, preflight operation (and promotion) should only be asynchronous
   // if the synchronous parameter is NO.
   NSString* preflightPath =
-      [mac_util::MainAppBundle() pathForResource:@"keystone_promote_preflight"
+      [base::mac::MainAppBundle() pathForResource:@"keystone_promote_preflight"
                                           ofType:@"sh"];
   const char* preflightPathC = [preflightPath fileSystemRepresentation];
   const char* userBrandFile = NULL;
   const char* systemBrandFile = NULL;
   if (brandFileType_ == kBrandFileTypeUser) {
     // Running with user level brand file, promote to the system level.
     userBrandFile = [UserBrandFilePath() fileSystemRepresentation];
     systemBrandFile = [SystemBrandFilePath() fileSystemRepresentation];
   }
   const char* arguments[] = {userBrandFile, systemBrandFile, NULL};
@@ skipping 65 matching lines @@
 }
 
 - (void)changePermissionsForPromotionAsync {
   // NSBundle is not documented as being thread-safe.  Do NSBundle operations
   // on the main thread before jumping over to a WorkerPool-managed
   // thread to run the tool.
   DCHECK([NSThread isMainThread]);
 
   SEL selector = @selector(changePermissionsForPromotionWithTool:);
   NSString* toolPath =
-      [mac_util::MainAppBundle() pathForResource:@"keystone_promote_postflight"
+      [base::mac::MainAppBundle() pathForResource:@"keystone_promote_postflight"
                                           ofType:@"sh"];
 
   PerformBridge::PostPerform(self, selector, toolPath);
 }
 
 - (void)changePermissionsForPromotionWithTool:(NSString*)toolPath {
   const char* toolPathC = [toolPath fileSystemRepresentation];
 
   const char* appPathC = [appPath_ fileSystemRepresentation];
   const char* arguments[] = {appPathC, NULL};
@@ skipping 39 matching lines @@
   return [KeystoneGlue defaultKeystoneGlue] != nil;
 }
 
 string16 CurrentlyInstalledVersion() {
   KeystoneGlue* keystoneGlue = [KeystoneGlue defaultKeystoneGlue];
   NSString* version = [keystoneGlue currentlyInstalledVersion];
   return base::SysNSStringToUTF16(version);
 }
 
 }  // namespace keystone_glue