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

base/mac/mac_util.mm

 // Copyright (c) 2010 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 "base/mac_util.h"
+#include "base/mac/mac_util.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/message_loop.h"
 #include "base/scoped_nsobject.h"
 #include "base/sys_string_conversions.h"
 
-using base::mac::ScopedCFTypeRef;
+namespace base {
+namespace mac {
 
 namespace {
 
 // a count of currently outstanding requests for full screen mode from browser
 // windows, plugins, etc.
-int g_full_screen_requests[mac_util::kNumFullScreenModes] = { 0, 0, 0};
+int g_full_screen_requests[kNumFullScreenModes] = { 0, 0, 0};
 
 // Sets the appropriate SystemUIMode based on the current full screen requests.
 // Since only one SystemUIMode can be active at a given time, full screen
 // requests are ordered by priority.  If there are no outstanding full screen
 // requests, reverts to normal mode.  If the correct SystemUIMode is already
 // set, does nothing.
 void SetUIMode() {
   // Get the current UI mode.
   SystemUIMode current_mode;
   GetSystemUIMode(&current_mode, NULL);
 
   // Determine which mode should be active, based on which requests are
   // currently outstanding.  More permissive requests take precedence.  For
   // example, plugins request |kFullScreenModeAutoHideAll|, while browser
   // windows request |kFullScreenModeHideDock| when the fullscreen overlay is
   // down.  Precedence goes to plugins in this case, so AutoHideAll wins over
   // HideDock.
   SystemUIMode desired_mode = kUIModeNormal;
   SystemUIOptions desired_options = 0;
-  if (g_full_screen_requests[mac_util::kFullScreenModeAutoHideAll] > 0) {
+  if (g_full_screen_requests[kFullScreenModeAutoHideAll] > 0) {
     desired_mode = kUIModeAllHidden;
     desired_options = kUIOptionAutoShowMenuBar;
-  } else if (g_full_screen_requests[mac_util::kFullScreenModeHideDock] > 0) {
+  } else if (g_full_screen_requests[kFullScreenModeHideDock] > 0) {
     desired_mode = kUIModeContentHidden;
-  } else if (g_full_screen_requests[mac_util::kFullScreenModeHideAll] > 0) {
+  } else if (g_full_screen_requests[kFullScreenModeHideAll] > 0) {
     desired_mode = kUIModeAllHidden;
   }
 
   if (current_mode != desired_mode)
     SetSystemUIMode(desired_mode, desired_options);
 }
 
 bool WasLaunchedAsLoginItem() {
   ProcessSerialNumber psn = { 0, kCurrentProcess };
 
   scoped_nsobject<NSDictionary> process_info(
-      mac_util::CFToNSCast(ProcessInformationCopyDictionary(&psn,
-                               kProcessDictionaryIncludeAllInformationMask)));
+      CFToNSCast(ProcessInformationCopyDictionary(&psn,
+                     kProcessDictionaryIncludeAllInformationMask)));
 
   long long temp = [[process_info objectForKey:@"ParentPSN"] longLongValue];
   ProcessSerialNumber parent_psn =
       { (temp >> 32) & 0x00000000FFFFFFFFLL, temp & 0x00000000FFFFFFFFLL };
 
   scoped_nsobject<NSDictionary> parent_info(
-      mac_util::CFToNSCast(ProcessInformationCopyDictionary(&parent_psn,
-                               kProcessDictionaryIncludeAllInformationMask)));
+      CFToNSCast(ProcessInformationCopyDictionary(&parent_psn,
+                     kProcessDictionaryIncludeAllInformationMask)));
 
   // Check that creator process code is that of loginwindow.
   BOOL result =
       [[parent_info objectForKey:@"FileCreator"] isEqualToString:@"lgnw"];
 
   return result == YES;
 }
 
 // Looks into Shared File Lists corresponding to Login Items for the item
 // representing the current application. If such an item is found, returns
 // retained reference to it. Caller is responsible for releasing the reference.
 LSSharedFileListItemRef GetLoginItemForApp() {
   ScopedCFTypeRef<LSSharedFileListRef> login_items(LSSharedFileListCreate(
       NULL, kLSSharedFileListSessionLoginItems, NULL));
 
   if (!login_items.get()) {
     LOG(ERROR) << "Couldn't get a Login Items list.";
     return NULL;
   }
 
   scoped_nsobject<NSArray> login_items_array(
-      mac_util::CFToNSCast(LSSharedFileListCopySnapshot(login_items, NULL)));
+      CFToNSCast(LSSharedFileListCopySnapshot(login_items, NULL)));
 
   NSURL* url = [NSURL fileURLWithPath:[[NSBundle mainBundle] bundlePath]];
 
   for(NSUInteger i = 0; i < [login_items_array count]; ++i) {
     LSSharedFileListItemRef item = reinterpret_cast<LSSharedFileListItemRef>(
         [login_items_array objectAtIndex:i]);
     CFURLRef item_url_ref = NULL;
 
     if (LSSharedFileListItemResolve(item, 0, &item_url_ref, NULL) == noErr) {
       ScopedCFTypeRef<CFURLRef> item_url(item_url_ref);
@@ skipping 17 matching lines @@
 #endif
 
 bool IsHiddenLoginItem(LSSharedFileListItemRef item) {
   ScopedCFTypeRef<CFBooleanRef> hidden(reinterpret_cast<CFBooleanRef>(
       LSSharedFileListItemCopyProperty(item,
           reinterpret_cast<CFStringRef>(kLSSharedFileListLoginItemHidden))));
 
   return hidden && hidden == kCFBooleanTrue;
 }
 
-}  // end namespace
-
-namespace mac_util {
+}  // namespace
 
 std::string PathFromFSRef(const FSRef& ref) {
   ScopedCFTypeRef<CFURLRef> url(
       CFURLCreateFromFSRef(kCFAllocatorDefault, &ref));
   NSString *path_string = [(NSURL *)url.get() path];
   return [path_string fileSystemRepresentation];
 }
 
 bool FSRefFromPath(const std::string& path, FSRef* ref) {
   OSStatus status = FSPathMakeRef((const UInt8*)path.c_str(),
@@ skipping 565 matching lines @@
 void NSObjectRetain(void* obj) {
   id<NSObject> nsobj = static_cast<id<NSObject> >(obj);
   [nsobj retain];
 }
 
 void NSObjectRelease(void* obj) {
   id<NSObject> nsobj = static_cast<id<NSObject> >(obj);
   [nsobj release];
 }
 
-}  // namespace mac_util
+}  // namespace mac
+}  // namespace base