-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdint.h>
-#include "base/bind.h"
-#include "base/mac/foundation_util.h"
+#include <memory>
+
+#include "base/apple/bridging.h"
+#include "base/apple/foundation_util.h"
+#include "base/functional/bind.h"
#include "base/mac/mac_util.h"
#include "base/strings/sys_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
-#include "base/task/post_task.h"
#include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
#include "base/threading/scoped_blocking_call.h"
#include "components/storage_monitor/image_capture_device_manager.h"
#include "components/storage_monitor/media_storage_util.h"
namespace {
-const char kDiskImageModelName[] = "Disk Image";
+const char16_t kDiskImageModelName[] = u"Disk Image";
-base::string16 GetUTF16FromDictionary(CFDictionaryRef dictionary,
+std::u16string GetUTF16FromDictionary(CFDictionaryRef dictionary,
CFStringRef key) {
CFStringRef value =
- base::mac::GetValueFromDictionary<CFStringRef>(dictionary, key);
+ base::apple::GetValueFromDictionary<CFStringRef>(dictionary, key);
if (!value)
- return base::string16();
+ return std::u16string();
return base::SysCFStringRefToUTF16(value);
}
-base::string16 JoinName(const base::string16& name,
- const base::string16& addition) {
+std::u16string JoinName(const std::u16string& name,
+ const std::u16string& addition) {
if (addition.empty())
return name;
if (name.empty())
return addition;
- return name + static_cast<base::char16>(' ') + addition;
+ return name + u' ' + addition;
}
StorageInfo::Type GetDeviceType(bool is_removable, bool has_dcim) {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
- CFStringRef device_bsd_name = base::mac::GetValueFromDictionary<CFStringRef>(
- dict, kDADiskDescriptionMediaBSDNameKey);
+ CFStringRef device_bsd_name =
+ base::apple::GetValueFromDictionary<CFStringRef>(
+ dict, kDADiskDescriptionMediaBSDNameKey);
if (device_bsd_name && bsd_name)
*bsd_name = base::SysCFStringRefToUTF8(device_bsd_name);
- CFURLRef url = base::mac::GetValueFromDictionary<CFURLRef>(
+ CFURLRef url = base::apple::GetValueFromDictionary<CFURLRef>(
dict, kDADiskDescriptionVolumePathKey);
- NSURL* nsurl = base::mac::CFToNSCast(url);
- base::FilePath location = base::mac::NSStringToFilePath([nsurl path]);
- CFNumberRef size_number =
- base::mac::GetValueFromDictionary<CFNumberRef>(
- dict, kDADiskDescriptionMediaSizeKey);
+ base::FilePath location =
+ base::apple::NSURLToFilePath(base::apple::CFToNSPtrCast(url));
+ CFNumberRef size_number = base::apple::GetValueFromDictionary<CFNumberRef>(
+ dict, kDADiskDescriptionMediaSizeKey);
uint64_t size_in_bytes = 0;
if (size_number)
CFNumberGetValue(size_number, kCFNumberLongLongType, &size_in_bytes);
- base::string16 vendor = GetUTF16FromDictionary(
- dict, kDADiskDescriptionDeviceVendorKey);
- base::string16 model = GetUTF16FromDictionary(
- dict, kDADiskDescriptionDeviceModelKey);
- base::string16 label = GetUTF16FromDictionary(
- dict, kDADiskDescriptionVolumeNameKey);
+ std::u16string vendor =
+ GetUTF16FromDictionary(dict, kDADiskDescriptionDeviceVendorKey);
+ std::u16string model =
+ GetUTF16FromDictionary(dict, kDADiskDescriptionDeviceModelKey);
+ std::u16string label =
+ GetUTF16FromDictionary(dict, kDADiskDescriptionVolumeNameKey);
- CFUUIDRef uuid = base::mac::GetValueFromDictionary<CFUUIDRef>(
+ CFUUIDRef uuid = base::apple::GetValueFromDictionary<CFUUIDRef>(
dict, kDADiskDescriptionVolumeUUIDKey);
std::string unique_id;
if (uuid) {
- base::ScopedCFTypeRef<CFStringRef> uuid_string(
- CFUUIDCreateString(NULL, uuid));
+ base::apple::ScopedCFTypeRef<CFStringRef> uuid_string(
+ CFUUIDCreateString(nullptr, uuid));
if (uuid_string.get())
unique_id = base::SysCFStringRefToUTF8(uuid_string);
}
if (unique_id.empty()) {
- base::string16 revision = GetUTF16FromDictionary(
- dict, kDADiskDescriptionDeviceRevisionKey);
- base::string16 unique_id2 = vendor;
+ std::u16string revision =
+ GetUTF16FromDictionary(dict, kDADiskDescriptionDeviceRevisionKey);
+ std::u16string unique_id2 = vendor;
unique_id2 = JoinName(unique_id2, model);
unique_id2 = JoinName(unique_id2, revision);
unique_id = base::UTF16ToUTF8(unique_id2);
}
CFBooleanRef is_removable_ref =
- base::mac::GetValueFromDictionary<CFBooleanRef>(
+ base::apple::GetValueFromDictionary<CFBooleanRef>(
dict, kDADiskDescriptionMediaRemovableKey);
bool is_removable = is_removable_ref && CFBooleanGetValue(is_removable_ref);
// Checking for DCIM only matters on removable devices.
struct EjectDiskOptions {
std::string bsd_name;
- base::Callback<void(StorageMonitor::EjectStatus)> callback;
- base::ScopedCFTypeRef<DADiskRef> disk;
+ base::OnceCallback<void(StorageMonitor::EjectStatus)> callback;
+ base::apple::ScopedCFTypeRef<DADiskRef> disk;
};
void PostEjectCallback(DADiskRef disk,
std::unique_ptr<EjectDiskOptions> options_deleter(
static_cast<EjectDiskOptions*>(context));
if (dissenter) {
- options_deleter->callback.Run(StorageMonitor::EJECT_IN_USE);
+ std::move(options_deleter->callback).Run(StorageMonitor::EJECT_IN_USE);
return;
}
- options_deleter->callback.Run(StorageMonitor::EJECT_OK);
+ std::move(options_deleter->callback).Run(StorageMonitor::EJECT_OK);
}
void PostUnmountCallback(DADiskRef disk,
std::unique_ptr<EjectDiskOptions> options_deleter(
static_cast<EjectDiskOptions*>(context));
if (dissenter) {
- options_deleter->callback.Run(StorageMonitor::EJECT_IN_USE);
+ std::move(options_deleter->callback).Run(StorageMonitor::EJECT_IN_USE);
return;
}
} // namespace
-StorageMonitorMac::StorageMonitorMac() : pending_disk_updates_(0) {
-}
+StorageMonitorMac::StorageMonitorMac() = default;
StorageMonitorMac::~StorageMonitorMac() {
if (session_.get()) {
}
void StorageMonitorMac::Init() {
- session_.reset(DASessionCreate(NULL));
+ session_.reset(DASessionCreate(nullptr));
// Register for callbacks for attached, changed, and removed devices.
// This will send notifications for existing devices too.
DASessionScheduleWithRunLoop(
session_, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
- image_capture_device_manager_.reset(new ImageCaptureDeviceManager);
+ image_capture_device_manager_ = std::make_unique<ImageCaptureDeviceManager>();
image_capture_device_manager_->SetNotifications(receiver());
}
}
void StorageMonitorMac::EjectDevice(
- const std::string& device_id,
- base::Callback<void(EjectStatus)> callback) {
+ const std::string& device_id,
+ base::OnceCallback<void(EjectStatus)> callback) {
StorageInfo::Type type;
std::string uuid;
if (!StorageInfo::CrackDeviceId(device_id, &type, &uuid)) {
- callback.Run(EJECT_FAILURE);
+ std::move(callback).Run(EJECT_FAILURE);
return;
}
if (type == StorageInfo::MAC_IMAGE_CAPTURE &&
image_capture_device_manager_.get()) {
- image_capture_device_manager_->EjectDevice(uuid, callback);
+ image_capture_device_manager_->EjectDevice(uuid, std::move(callback));
return;
}
}
if (bsd_name.empty()) {
- callback.Run(EJECT_NO_SUCH_DEVICE);
+ std::move(callback).Run(EJECT_NO_SUCH_DEVICE);
return;
}
receiver()->ProcessDetach(device_id);
- base::ScopedCFTypeRef<DADiskRef> disk(
- DADiskCreateFromBSDName(NULL, session_, bsd_name.c_str()));
+ base::apple::ScopedCFTypeRef<DADiskRef> disk(
+ DADiskCreateFromBSDName(nullptr, session_, bsd_name.c_str()));
if (!disk.get()) {
- callback.Run(StorageMonitor::EJECT_FAILURE);
+ std::move(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);
+ std::move(callback).Run(StorageMonitor::EJECT_FAILURE);
return;
}
EjectDiskOptions* options = new EjectDiskOptions;
options->bsd_name = bsd_name;
- options->callback = callback;
+ options->callback = std::move(callback);
options->disk = std::move(disk);
- base::PostTaskWithTraits(FROM_HERE, {content::BrowserThread::UI},
- base::BindOnce(EjectDisk, options));
+ content::GetUIThreadTaskRunner({})->PostTask(
+ FROM_HERE, base::BindOnce(EjectDisk, options));
}
// static
pending_disk_updates_++;
- base::ScopedCFTypeRef<CFDictionaryRef> dict(DADiskCopyDescription(disk));
+ base::apple::ScopedCFTypeRef<CFDictionaryRef> dict(
+ DADiskCopyDescription(disk));
std::string* bsd_name = new std::string;
- base::PostTaskWithTraitsAndReplyWithResult(
+ base::ThreadPool::PostTaskAndReplyWithResult(
FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
base::BindOnce(&BuildStorageInfo, dict, bsd_name),
base::BindOnce(&StorageMonitorMac::UpdateDisk, AsWeakPtr(), update_type,
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() != base::ASCIIToUTF16(kDiskImageModelName) &&
+ return !info.device_id().empty() && !info.location().empty() &&
+ info.model_name() != 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;
+ for (const auto& disk_info : disk_info_map_) {
+ if (disk_info.second.location() == mount_point.value()) {
+ *info = disk_info.second;
return true;
}
}
projects / platform / framework / web / chromium-efl.git / blobdiff