mac: Replace base::mac::ScopedCFTypeRef with base::ScopedCFTypeRef.

chrome/browser/storage_monitor/storage_monitor_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/browser/storage_monitor/storage_monitor_mac.h"
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 56 matching lines @@
       dict, kDADiskDescriptionDeviceVendorKey);
   string16 model = GetUTF16FromDictionary(
       dict, kDADiskDescriptionDeviceModelKey);
   string16 label = GetUTF16FromDictionary(
       dict, kDADiskDescriptionVolumeNameKey);
 
   CFUUIDRef uuid = base::mac::GetValueFromDictionary<CFUUIDRef>(
       dict, kDADiskDescriptionVolumeUUIDKey);
   std::string unique_id;
   if (uuid) {
-    base::mac::ScopedCFTypeRef<CFStringRef> uuid_string(
+    base::ScopedCFTypeRef<CFStringRef> uuid_string(
         CFUUIDCreateString(NULL, uuid));
     if (uuid_string.get())
       unique_id = base::SysCFStringRefToUTF8(uuid_string);
   }
   if (unique_id.empty()) {
     string16 revision = GetUTF16FromDictionary(
         dict, kDADiskDescriptionDeviceRevisionKey);
     string16 unique_id2 = vendor;
     unique_id2 = JoinName(unique_id2, model);
     unique_id2 = JoinName(unique_id2, revision);
@@ skipping 10 matching lines @@
   std::string device_id;
   if (!unique_id.empty())
     device_id = StorageInfo::MakeDeviceId(device_type, unique_id);
 
   return StorageInfo(device_id, string16(), location.value(), label, vendor,
                      model, size_in_bytes);
 }
 
 void GetDiskInfoAndUpdateOnFileThread(
     const base::WeakPtr<StorageMonitorMac>& monitor,
-    base::mac::ScopedCFTypeRef<CFDictionaryRef> dict,
+    base::ScopedCFTypeRef<CFDictionaryRef> dict,
     StorageMonitorMac::UpdateType update_type) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
   std::string bsd_name;
   StorageInfo info = BuildStorageInfo(dict, &bsd_name);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&StorageMonitorMac::UpdateDisk,
                  monitor,
                  bsd_name,
                  info,
                  update_type));
 }
 
 struct EjectDiskOptions {
   std::string bsd_name;
   base::Callback<void(StorageMonitor::EjectStatus)> callback;
-  base::mac::ScopedCFTypeRef<DADiskRef> disk;
+  base::ScopedCFTypeRef<DADiskRef> disk;
 };
 
 void PostEjectCallback(DADiskRef disk,
                        DADissenterRef dissenter,
                        void* context) {
   scoped_ptr<EjectDiskOptions> options_deleter(
       static_cast<EjectDiskOptions*>(context));
   if (dissenter) {
     options_deleter->callback.Run(StorageMonitor::EJECT_IN_USE);
     return;
@@ skipping 143 matching lines @@
     }
   }
 
   if (bsd_name.empty()) {
     callback.Run(EJECT_NO_SUCH_DEVICE);
     return;
   }
 
   receiver()->ProcessDetach(device_id);
 
-  base::mac::ScopedCFTypeRef<DADiskRef> disk(
+  base::ScopedCFTypeRef<DADiskRef> disk(
       DADiskCreateFromBSDName(NULL, session_, bsd_name.c_str()));
   if (!disk.get()) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
   // Get the reference to the full disk for ejecting.
   disk.reset(DADiskCopyWholeDisk(disk));
   if (!disk.get()) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
@@ skipping 27 matching lines @@
   monitor->GetDiskInfoAndUpdate(disk, UPDATE_DEVICE_CHANGED);
 }
 
 void StorageMonitorMac::GetDiskInfoAndUpdate(
     DADiskRef disk,
     StorageMonitorMac::UpdateType update_type) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   pending_disk_updates_++;
 
-  base::mac::ScopedCFTypeRef<CFDictionaryRef> dict(DADiskCopyDescription(disk));
+  base::ScopedCFTypeRef<CFDictionaryRef> dict(DADiskCopyDescription(disk));
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE,
       FROM_HERE,
-      base::Bind(GetDiskInfoAndUpdateOnFileThread,
-                 AsWeakPtr(), dict, update_type));
+      base::Bind(
+          GetDiskInfoAndUpdateOnFileThread, AsWeakPtr(), dict, update_type));
 }
 
 
 bool StorageMonitorMac::ShouldPostNotificationForDisk(
     const StorageInfo& info) const {
   // Only post notifications about disks that have no empty fields and
   // are removable. Also exclude disk images (DMGs).
   return !info.device_id().empty() &&
          !info.location().empty() &&
          info.model_name() != ASCIIToUTF16(kDiskImageModelName) &&
          StorageInfo::IsMassStorageDevice(info.device_id());
 }
 
 bool StorageMonitorMac::FindDiskWithMountPoint(
     const base::FilePath& mount_point,
     StorageInfo* info) const {
   for (std::map<std::string, StorageInfo>::const_iterator
       it = disk_info_map_.begin(); it != disk_info_map_.end(); ++it) {
     if (it->second.location() == mount_point.value()) {
       *info = it->second;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace chrome