| // Copyright 2017 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/exo/data_offer.h" |
| |
| #include <iterator> |
| #include <memory> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/files/file_util.h" |
| #include "base/functional/bind.h" |
| #include "base/i18n/icu_string_conversions.h" |
| #include "base/memory/ref_counted_memory.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "base/no_destructor.h" |
| #include "base/pickle.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/task/thread_pool.h" |
| #include "components/exo/data_device.h" |
| #include "components/exo/data_exchange_delegate.h" |
| #include "components/exo/data_offer_delegate.h" |
| #include "components/exo/data_offer_observer.h" |
| #include "components/exo/security_delegate.h" |
| #include "net/base/filename_util.h" |
| #include "ui/base/clipboard/clipboard.h" |
| #include "ui/base/clipboard/clipboard_buffer.h" |
| #include "ui/base/clipboard/clipboard_constants.h" |
| #include "ui/base/clipboard/file_info.h" |
| #include "ui/base/data_transfer_policy/data_transfer_endpoint.h" |
| #include "ui/base/dragdrop/os_exchange_data.h" |
| #include "url/gurl.h" |
| |
| namespace exo { |
| namespace { |
| |
| constexpr char kTextMimeTypeUtf16[] = "text/plain;charset=utf-16"; |
| constexpr char kTextHtmlMimeTypeUtf16[] = "text/html;charset=utf-16"; |
| |
| constexpr char kUTF8[] = "utf8"; |
| constexpr char kUTF16[] = "utf16"; |
| |
| void WriteFileDescriptorOnWorkerThread( |
| base::ScopedFD fd, |
| scoped_refptr<base::RefCountedMemory> memory) { |
| if (!base::WriteFileDescriptor(fd.get(), *memory)) |
| DLOG(ERROR) << "Failed to write drop data"; |
| } |
| |
| void WriteFileDescriptor(base::ScopedFD fd, |
| scoped_refptr<base::RefCountedMemory> memory) { |
| base::ThreadPool::PostTask( |
| FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_BLOCKING}, |
| base::BindOnce(&WriteFileDescriptorOnWorkerThread, std::move(fd), |
| std::move(memory))); |
| } |
| |
| ui::ClipboardFormatType GetClipboardFormatType() { |
| static const char kFormatString[] = "chromium/x-file-system-files"; |
| static base::NoDestructor<ui::ClipboardFormatType> format_type( |
| ui::ClipboardFormatType::CustomPlatformType(kFormatString)); |
| return *format_type; |
| } |
| |
| scoped_refptr<base::RefCountedString> EncodeAsRefCountedString( |
| const std::u16string& text, |
| const std::string& charset) { |
| std::string encoded_text; |
| base::UTF16ToCodepage(text, charset.c_str(), |
| base::OnStringConversionError::SUBSTITUTE, |
| &encoded_text); |
| return base::MakeRefCounted<base::RefCountedString>(std::move(encoded_text)); |
| } |
| |
| DataOffer::AsyncSendDataCallback AsyncEncodeAsRefCountedString( |
| const std::u16string& text, |
| const std::string& charset) { |
| return base::BindOnce( |
| [](const std::u16string& text, const std::string& charset, |
| DataOffer::SendDataCallback callback) { |
| std::move(callback).Run(EncodeAsRefCountedString(text, charset)); |
| }, |
| text, charset); |
| } |
| |
| void ReadTextFromClipboard(const std::string& charset, |
| const ui::DataTransferEndpoint data_dst, |
| DataOffer::SendDataCallback callback) { |
| std::u16string text; |
| ui::Clipboard::GetForCurrentThread()->ReadText( |
| ui::ClipboardBuffer::kCopyPaste, &data_dst, &text); |
| std::move(callback).Run(EncodeAsRefCountedString(text, charset)); |
| } |
| |
| void ReadHTMLFromClipboard(const std::string& charset, |
| const ui::DataTransferEndpoint data_dst, |
| DataOffer::SendDataCallback callback) { |
| std::u16string text; |
| std::string url; |
| uint32_t start, end; |
| ui::Clipboard::GetForCurrentThread()->ReadHTML( |
| ui::ClipboardBuffer::kCopyPaste, &data_dst, &text, &url, &start, &end); |
| std::move(callback).Run(EncodeAsRefCountedString(text, charset)); |
| } |
| |
| void ReadRTFFromClipboard(const ui::DataTransferEndpoint data_dst, |
| DataOffer::SendDataCallback callback) { |
| std::string text; |
| ui::Clipboard::GetForCurrentThread()->ReadRTF(ui::ClipboardBuffer::kCopyPaste, |
| &data_dst, &text); |
| std::move(callback).Run( |
| base::MakeRefCounted<base::RefCountedString>(std::move(text))); |
| } |
| |
| void OnReceivePNGFromClipboard(DataOffer::SendDataCallback callback, |
| const std::vector<uint8_t>& png) { |
| scoped_refptr<base::RefCountedMemory> rc_mem = |
| base::MakeRefCounted<base::RefCountedBytes>(png); |
| std::move(callback).Run(std::move(rc_mem)); |
| } |
| |
| void ReadPNGFromClipboard(const ui::DataTransferEndpoint data_dst, |
| DataOffer::SendDataCallback callback) { |
| ui::Clipboard::GetForCurrentThread()->ReadPng( |
| ui::ClipboardBuffer::kCopyPaste, &data_dst, |
| base::BindOnce(&OnReceivePNGFromClipboard, std::move(callback))); |
| } |
| |
| } // namespace |
| |
| ScopedDataOffer::ScopedDataOffer(DataOffer* data_offer, |
| DataOfferObserver* observer) |
| : data_offer_(data_offer), observer_(observer) { |
| data_offer_->AddObserver(observer_); |
| } |
| |
| ScopedDataOffer::~ScopedDataOffer() { |
| data_offer_->RemoveObserver(observer_); |
| } |
| |
| DataOffer::DataOffer(DataOfferDelegate* delegate) |
| : delegate_(delegate), dnd_action_(DndAction::kNone), finished_(false) {} |
| |
| DataOffer::~DataOffer() { |
| delegate_->OnDataOfferDestroying(this); |
| for (DataOfferObserver& observer : observers_) { |
| observer.OnDataOfferDestroying(this); |
| } |
| } |
| |
| void DataOffer::AddObserver(DataOfferObserver* observer) { |
| observers_.AddObserver(observer); |
| } |
| |
| void DataOffer::RemoveObserver(DataOfferObserver* observer) { |
| observers_.RemoveObserver(observer); |
| } |
| |
| void DataOffer::Accept(const std::string* mime_type) {} |
| |
| void DataOffer::Receive(const std::string& mime_type, base::ScopedFD fd) { |
| const auto callbacks_it = data_callbacks_.find(mime_type); |
| if (callbacks_it != data_callbacks_.end()) { |
| // Set cache with empty data to indicate in process. |
| DCHECK(data_cache_.count(mime_type) == 0); |
| data_cache_.emplace(mime_type, nullptr); |
| std::move(callbacks_it->second) |
| .Run(base::BindOnce(&DataOffer::OnDataReady, |
| weak_ptr_factory_.GetWeakPtr(), mime_type, |
| std::move(fd))); |
| data_callbacks_.erase(callbacks_it); |
| return; |
| } |
| |
| const auto cache_it = data_cache_.find(mime_type); |
| if (cache_it == data_cache_.end()) { |
| DLOG(ERROR) << "Unexpected mime type is requested " << mime_type; |
| return; |
| } |
| |
| if (cache_it->second) { |
| WriteFileDescriptor(std::move(fd), cache_it->second); |
| } else { |
| // Data bytes for this mime type are being processed currently. |
| pending_receive_requests_.push_back( |
| std::make_pair(mime_type, std::move(fd))); |
| } |
| } |
| |
| void DataOffer::Finish() { |
| finished_ = true; |
| } |
| |
| void DataOffer::SetActions(const base::flat_set<DndAction>& dnd_actions, |
| DndAction preferred_action) { |
| dnd_action_ = preferred_action; |
| delegate_->OnAction(preferred_action); |
| } |
| |
| void DataOffer::SetSourceActions( |
| const base::flat_set<DndAction>& source_actions) { |
| source_actions_ = source_actions; |
| delegate_->OnSourceActions(source_actions); |
| } |
| |
| void DataOffer::SetDropData(DataExchangeDelegate* data_exchange_delegate, |
| aura::Window* target, |
| const ui::OSExchangeData& data) { |
| DCHECK_EQ(0u, data_callbacks_.size()); |
| |
| ui::EndpointType endpoint_type = |
| data_exchange_delegate->GetDataTransferEndpointType(target); |
| |
| const std::string uri_list_mime_type = |
| data_exchange_delegate->GetMimeTypeForUriList(endpoint_type); |
| // We accept the filenames pickle from FilesApp, or |
| // OSExchangeData::GetFilenames(). |
| std::vector<ui::FileInfo> filenames; |
| if (std::optional<base::Pickle> pickle = data.GetPickledData( |
| ui::ClipboardFormatType::DataTransferCustomType()); |
| pickle.has_value()) { |
| filenames = data_exchange_delegate->ParseFileSystemSources(data.GetSource(), |
| pickle.value()); |
| } |
| |
| if (filenames.empty() && data.HasFile()) { |
| if (std::optional<std::vector<ui::FileInfo>> file_info = |
| data.GetFilenames(); |
| file_info.has_value()) { |
| std::ranges::move(file_info.value(), std::back_inserter(filenames)); |
| } |
| } |
| |
| if (!filenames.empty()) { |
| data_callbacks_.emplace( |
| uri_list_mime_type, |
| base::BindOnce(&SecurityDelegate::SendFileInfo, |
| base::Unretained(delegate_->GetSecurityDelegate()), |
| endpoint_type, std::move(filenames))); |
| delegate_->OnOffer(uri_list_mime_type); |
| return; |
| } |
| |
| if (std::optional<base::Pickle> pickle = |
| data.GetPickledData(GetClipboardFormatType()); |
| pickle.has_value() && |
| data_exchange_delegate->HasUrlsInPickle(pickle.value())) { |
| data_callbacks_.emplace( |
| uri_list_mime_type, |
| base::BindOnce(&SecurityDelegate::SendPickle, |
| base::Unretained(delegate_->GetSecurityDelegate()), |
| endpoint_type, pickle.value())); |
| delegate_->OnOffer(uri_list_mime_type); |
| return; |
| } |
| |
| if (std::optional<ui::OSExchangeDataProvider::FileContentsInfo> |
| file_contents = data.provider().GetFileContents(); |
| file_contents.has_value()) { |
| std::string filename = file_contents->filename.value(); |
| base::ReplaceChars(filename, "\\", "\\\\", &filename); |
| base::ReplaceChars(filename, "\"", "\\\"", &filename); |
| const std::string mime_type = |
| base::StrCat({"application/octet-stream;name=\"", filename, "\""}); |
| auto callback = base::BindOnce( |
| [](scoped_refptr<base::RefCountedString> contents, |
| DataOffer::SendDataCallback callback) { |
| std::move(callback).Run(std::move(contents)); |
| }, |
| base::MakeRefCounted<base::RefCountedString>( |
| std::move(file_contents->file_contents))); |
| |
| data_callbacks_.emplace(mime_type, std::move(callback)); |
| delegate_->OnOffer(mime_type); |
| } |
| |
| if (std::optional<std::u16string> string_content = data.GetString(); |
| string_content.has_value()) { |
| const std::string utf8_mime_type = std::string(ui::kMimeTypeUtf8PlainText); |
| data_callbacks_.emplace( |
| utf8_mime_type, AsyncEncodeAsRefCountedString(*string_content, kUTF8)); |
| delegate_->OnOffer(utf8_mime_type); |
| const std::string utf16_mime_type = std::string(kTextMimeTypeUtf16); |
| data_callbacks_.emplace(utf16_mime_type, AsyncEncodeAsRefCountedString( |
| *string_content, kUTF16)); |
| delegate_->OnOffer(utf16_mime_type); |
| const std::string text_plain_mime_type = |
| std::string(ui::kMimeTypePlainText); |
| // The MIME type standard says that new text/ subtypes should default to a |
| // UTF-8 encoding, but that old ones, including text/plain, keep ASCII as |
| // the default. Nonetheless, we use UTF8 here because it is a superset of |
| // ASCII and the defacto standard text encoding. |
| data_callbacks_.emplace(text_plain_mime_type, AsyncEncodeAsRefCountedString( |
| *string_content, kUTF8)); |
| delegate_->OnOffer(text_plain_mime_type); |
| } |
| |
| if (std::optional<ui::OSExchangeData::HtmlInfo> html_content = data.GetHtml(); |
| html_content.has_value()) { |
| const std::string utf8_html_mime_type = std::string(ui::kMimeTypeUtf8Html); |
| data_callbacks_.emplace( |
| utf8_html_mime_type, |
| AsyncEncodeAsRefCountedString(html_content->html, kUTF8)); |
| delegate_->OnOffer(utf8_html_mime_type); |
| |
| const std::string utf16_html_mime_type = |
| std::string(kTextHtmlMimeTypeUtf16); |
| data_callbacks_.emplace( |
| utf16_html_mime_type, |
| AsyncEncodeAsRefCountedString(html_content->html, kUTF16)); |
| delegate_->OnOffer(utf16_html_mime_type); |
| } |
| } |
| |
| void DataOffer::SetClipboardData(DataExchangeDelegate* data_exchange_delegate, |
| const ui::Clipboard& data, |
| ui::EndpointType endpoint_type) { |
| DCHECK_EQ(0u, data_callbacks_.size()); |
| const ui::DataTransferEndpoint data_dst(endpoint_type); |
| |
| if (data.IsFormatAvailable(ui::ClipboardFormatType::PlainTextType(), |
| ui::ClipboardBuffer::kCopyPaste, &data_dst)) { |
| auto utf8_callback = base::BindRepeating(&ReadTextFromClipboard, |
| std::string(kUTF8), data_dst); |
| delegate_->OnOffer(std::string(ui::kMimeTypeUtf8PlainText)); |
| data_callbacks_.emplace(std::string(ui::kMimeTypeUtf8PlainText), |
| utf8_callback); |
| delegate_->OnOffer(std::string(ui::kMimeTypeLinuxUtf8String)); |
| data_callbacks_.emplace(std::string(ui::kMimeTypeLinuxUtf8String), |
| utf8_callback); |
| delegate_->OnOffer(std::string(kTextMimeTypeUtf16)); |
| data_callbacks_.emplace( |
| std::string(kTextMimeTypeUtf16), |
| base::BindOnce(&ReadTextFromClipboard, std::string(kUTF16), data_dst)); |
| } |
| if (data.IsFormatAvailable(ui::ClipboardFormatType::HtmlType(), |
| ui::ClipboardBuffer::kCopyPaste, &data_dst)) { |
| delegate_->OnOffer(std::string(ui::kMimeTypeUtf8Html)); |
| data_callbacks_.emplace( |
| std::string(ui::kMimeTypeUtf8Html), |
| base::BindOnce(&ReadHTMLFromClipboard, std::string(kUTF8), data_dst)); |
| delegate_->OnOffer(std::string(kTextHtmlMimeTypeUtf16)); |
| data_callbacks_.emplace( |
| std::string(kTextHtmlMimeTypeUtf16), |
| base::BindOnce(&ReadHTMLFromClipboard, std::string(kUTF16), data_dst)); |
| delegate_->OnOffer(std::string(ui::kMimeTypeHtml)); |
| data_callbacks_.emplace( |
| std::string(ui::kMimeTypeHtml), |
| base::BindOnce(&ReadHTMLFromClipboard, std::string(kUTF8), data_dst)); |
| } |
| if (data.IsFormatAvailable(ui::ClipboardFormatType::RtfType(), |
| ui::ClipboardBuffer::kCopyPaste, &data_dst)) { |
| delegate_->OnOffer(std::string(ui::kMimeTypeRtf)); |
| data_callbacks_.emplace(std::string(ui::kMimeTypeRtf), |
| base::BindOnce(&ReadRTFFromClipboard, data_dst)); |
| } |
| if (data.IsFormatAvailable(ui::ClipboardFormatType::BitmapType(), |
| ui::ClipboardBuffer::kCopyPaste, &data_dst)) { |
| delegate_->OnOffer(std::string(ui::kMimeTypePng)); |
| data_callbacks_.emplace(std::string(ui::kMimeTypePng), |
| base::BindOnce(&ReadPNGFromClipboard, data_dst)); |
| } |
| |
| // For clipboard, FilesApp filenames pickle is already converted to files |
| // in VolumeManager::OnClipboardDataChanged(). |
| std::vector<ui::FileInfo> filenames; |
| if (data.IsFormatAvailable(ui::ClipboardFormatType::FilenamesType(), |
| ui::ClipboardBuffer::kCopyPaste, &data_dst)) { |
| data.ReadFilenames(ui::ClipboardBuffer::kCopyPaste, &data_dst, &filenames); |
| } |
| if (!filenames.empty()) { |
| delegate_->OnOffer(std::string(ui::kMimeTypeUriList)); |
| data_callbacks_.emplace( |
| std::string(ui::kMimeTypeUriList), |
| base::BindOnce(&SecurityDelegate::SendFileInfo, |
| base::Unretained(delegate_->GetSecurityDelegate()), |
| endpoint_type, std::move(filenames))); |
| } |
| } |
| |
| void DataOffer::OnDataReady(const std::string& mime_type, |
| base::ScopedFD fd, |
| scoped_refptr<base::RefCountedMemory> data) { |
| // Update cache from nullptr to data. |
| const auto cache_it = data_cache_.find(mime_type); |
| CHECK(cache_it != data_cache_.end()); |
| DCHECK(!cache_it->second); |
| data_cache_.erase(cache_it); |
| data_cache_.emplace(mime_type, data); |
| |
| WriteFileDescriptor(std::move(fd), data); |
| |
| // Process pending receive requests for this mime type, if there are any. |
| auto it = pending_receive_requests_.begin(); |
| while (it != pending_receive_requests_.end()) { |
| if (it->first == mime_type) { |
| WriteFileDescriptor(std::move(it->second), data); |
| it = pending_receive_requests_.erase(it); |
| } else { |
| ++it; |
| } |
| } |
| } |
| |
| } // namespace exo |