| // Copyright 2020 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/webshare/win/share_operation.h" |
| |
| #include <shlobj.h> |
| #include <windows.applicationmodel.datatransfer.h> |
| #include <windows.foundation.collections.h> |
| #include <windows.foundation.h> |
| #include <windows.storage.h> |
| #include <windows.storage.streams.h> |
| #include <wininet.h> |
| #include <wrl/client.h> |
| #include <wrl/event.h> |
| |
| #include <utility> |
| |
| #include "base/functional/bind.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/win/core_winrt_util.h" |
| #include "base/win/post_async_results.h" |
| #include "base/win/scoped_hstring.h" |
| #include "base/win/vector.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/webshare/share_service_impl.h" |
| #include "chrome/browser/webshare/win/show_share_ui_for_window_operation.h" |
| #include "content/public/browser/browser_task_traits.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/web_contents.h" |
| #include "net/base/net_errors.h" |
| #include "storage/browser/blob/blob_data_handle.h" |
| #include "storage/browser/blob/blob_storage_context.h" |
| #include "storage/browser/file_system/file_stream_writer.h" |
| #include "storage/browser/file_system/file_writer_delegate.h" |
| #include "storage/common/file_system/file_system_mount_option.h" |
| #include "ui/base/win/internal_constants.h" |
| #include "ui/views/win/hwnd_util.h" |
| #include "url/gurl.h" |
| |
| using ABI::Windows::ApplicationModel::DataTransfer::IDataPackage; |
| using ABI::Windows::ApplicationModel::DataTransfer::IDataPackage2; |
| using ABI::Windows::ApplicationModel::DataTransfer::IDataPackagePropertySet; |
| using ABI::Windows::ApplicationModel::DataTransfer::IDataRequest; |
| using ABI::Windows::ApplicationModel::DataTransfer::IDataRequestDeferral; |
| using ABI::Windows::ApplicationModel::DataTransfer::IDataRequestedEventArgs; |
| using ABI::Windows::Foundation::AsyncStatus; |
| using ABI::Windows::Foundation::IAsyncOperation; |
| using ABI::Windows::Foundation::IAsyncOperationCompletedHandler; |
| using ABI::Windows::Foundation::IClosable; |
| using ABI::Windows::Foundation::IUriRuntimeClass; |
| using ABI::Windows::Foundation::IUriRuntimeClassFactory; |
| using ABI::Windows::Storage::IStorageFile; |
| using ABI::Windows::Storage::IStorageFileStatics; |
| using ABI::Windows::Storage::IStorageItem; |
| using ABI::Windows::Storage::IStreamedFileDataRequestedHandler; |
| using ABI::Windows::Storage::StorageFile; |
| using ABI::Windows::Storage::Streams::IDataWriter; |
| using ABI::Windows::Storage::Streams::IDataWriterFactory; |
| using ABI::Windows::Storage::Streams::IOutputStream; |
| using Microsoft::WRL::Callback; |
| using Microsoft::WRL::ComPtr; |
| using Microsoft::WRL::Make; |
| |
| namespace ABI::Windows::Foundation::Collections { |
| |
| // Define template specializations for the types used. These uuids were randomly |
| // generated. |
| template <> |
| struct __declspec(uuid("CBE31E85-DEC8-4227-987F-9C63D6AA1A2E")) |
| IObservableVector<IStorageItem*> : IObservableVector_impl<IStorageItem*> {}; |
| |
| template <> |
| struct __declspec(uuid("30BE4864-5EE5-4111-916E-15126649F3C9")) |
| VectorChangedEventHandler<IStorageItem*> |
| : VectorChangedEventHandler_impl<IStorageItem*> {}; |
| |
| } // namespace ABI::Windows::Foundation::Collections |
| |
| namespace webshare { |
| namespace { |
| |
| uint64_t g_max_file_bytes = kMaxSharedFileBytes; |
| decltype( |
| &base::win::RoGetActivationFactory) g_ro_get_activation_factory_function = |
| &base::win::RoGetActivationFactory; |
| |
| template <typename InterfaceType, wchar_t const* runtime_class_id> |
| HRESULT GetActivationFactory(InterfaceType** factory) { |
| auto class_id_hstring = base::win::ScopedHString::Create(runtime_class_id); |
| if (!class_id_hstring.is_valid()) |
| return E_FAIL; |
| |
| return g_ro_get_activation_factory_function(class_id_hstring.get(), |
| IID_PPV_ARGS(factory)); |
| } |
| |
| // Implements FileStreamWriter for an IDataWriter. |
| class DataWriterFileStreamWriter final : public storage::FileStreamWriter { |
| public: |
| explicit DataWriterFileStreamWriter( |
| ComPtr<IDataWriter> data_writer, |
| scoped_refptr<base::RefCountedData<uint64_t>> file_bytes_shared) |
| : data_writer_(data_writer), file_bytes_shared_(file_bytes_shared) {} |
| |
| int Cancel(net::CompletionOnceCallback callback) final { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| // If there is no async operation in progress, Cancel() should |
| // return net::ERR_UNEXPECTED per file_stream_header.h |
| if (!flush_operation_ && !write_operation_) |
| return net::ERR_UNEXPECTED; |
| |
| if (flush_operation_) { |
| flush_callback_.Reset(); |
| ComPtr<IAsyncInfo> async_info; |
| auto hr = flush_operation_.As(&async_info); |
| if (FAILED(hr)) |
| return net::ERR_UNEXPECTED; |
| |
| hr = async_info->Cancel(); |
| if (FAILED(hr)) |
| return net::ERR_UNEXPECTED; |
| |
| flush_operation_.Reset(); |
| } |
| |
| if (write_operation_) { |
| write_callback_.Reset(); |
| ComPtr<IAsyncInfo> async_info; |
| auto hr = write_operation_.As(&async_info); |
| if (FAILED(hr)) |
| return net::ERR_UNEXPECTED; |
| |
| hr = async_info->Cancel(); |
| if (FAILED(hr)) |
| return net::ERR_UNEXPECTED; |
| |
| write_operation_.Reset(); |
| } |
| return net::OK; |
| } |
| |
| int Flush(storage::FlushMode /*flush_mode*/, |
| net::CompletionOnceCallback callback) final { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| DCHECK(flush_callback_.is_null()); |
| DCHECK_EQ(flush_operation_, nullptr); |
| DCHECK(write_callback_.is_null()); |
| DCHECK_EQ(write_operation_, nullptr); |
| |
| auto hr = data_writer_->FlushAsync(&flush_operation_); |
| if (FAILED(hr)) |
| return net::ERR_UNEXPECTED; |
| |
| flush_callback_ = std::move(callback); |
| base::win::PostAsyncHandlers( |
| flush_operation_.Get(), |
| base::BindOnce(&DataWriterFileStreamWriter::OnFlushCompleted, |
| weak_factory_.GetWeakPtr())); |
| return net::ERR_IO_PENDING; |
| } |
| |
| int Write(net::IOBuffer* buf, |
| int buf_len, |
| net::CompletionOnceCallback callback) final { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| DCHECK(flush_callback_.is_null()); |
| DCHECK_EQ(flush_operation_, nullptr); |
| DCHECK(write_callback_.is_null()); |
| DCHECK_EQ(write_operation_, nullptr); |
| |
| // Before processing the Write request, increment the total number of file |
| // bytes shared as part of the overall Share operation this belongs to, and |
| // if it has exceeded the maximum allowed, abort writing to the streamed |
| // file. |
| file_bytes_shared_->data += buf_len; |
| if (file_bytes_shared_->data > g_max_file_bytes) |
| return net::ERR_UNEXPECTED; |
| |
| auto hr = |
| data_writer_->WriteBytes(buf_len, reinterpret_cast<BYTE*>(buf->data())); |
| if (FAILED(hr)) |
| return net::ERR_UNEXPECTED; |
| |
| hr = data_writer_->StoreAsync(&write_operation_); |
| if (FAILED(hr)) |
| return net::ERR_UNEXPECTED; |
| |
| write_callback_ = std::move(callback); |
| base::win::PostAsyncHandlers( |
| write_operation_.Get(), |
| base::BindOnce(&DataWriterFileStreamWriter::OnWriteCompleted, |
| weak_factory_.GetWeakPtr())); |
| return net::ERR_IO_PENDING; |
| } |
| |
| private: |
| void OnFlushCompleted(boolean operation_result) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| DCHECK(!flush_callback_.is_null()); |
| DCHECK_NE(flush_operation_, nullptr); |
| DCHECK(write_callback_.is_null()); |
| DCHECK_EQ(write_operation_, nullptr); |
| |
| flush_operation_.Reset(); |
| int result = operation_result == TRUE ? net::OK : net::ERR_UNEXPECTED; |
| std::move(flush_callback_).Run(result); |
| } |
| |
| void OnWriteCompleted(UINT32 operation_result) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| DCHECK(flush_callback_.is_null()); |
| DCHECK_EQ(flush_operation_, nullptr); |
| DCHECK(!write_callback_.is_null()); |
| DCHECK_NE(write_operation_, nullptr); |
| |
| write_operation_.Reset(); |
| std::move(write_callback_).Run(operation_result); |
| } |
| |
| ComPtr<IDataWriter> data_writer_; |
| scoped_refptr<base::RefCountedData<uint64_t>> file_bytes_shared_; |
| net::CompletionOnceCallback flush_callback_; |
| ComPtr<IAsyncOperation<bool>> flush_operation_; |
| net::CompletionOnceCallback write_callback_; |
| ComPtr<IAsyncOperation<UINT32>> write_operation_; |
| base::WeakPtrFactory<DataWriterFileStreamWriter> weak_factory_{this}; |
| }; |
| |
| // Represents an ongoing operation of writing to an IOutputStream. |
| class OutputStreamWriteOperation |
| : public base::RefCounted<OutputStreamWriteOperation> { |
| public: |
| OutputStreamWriteOperation( |
| content::BrowserContext::BlobContextGetter blob_context_getter, |
| scoped_refptr<base::RefCountedData<uint64_t>> file_bytes_shared, |
| mojo::PendingRemote<blink::mojom::Blob> blob) |
| : blob_context_getter_(blob_context_getter), |
| file_bytes_shared_(file_bytes_shared), |
| blob_(std::move(blob)) {} |
| |
| // Begins the write operation on the |stream|, maintaining a reference to the |
| // |stream| until the operation is completed, at which point it will be closed |
| // (if possible) and the |on_complete| callback will be invoked. The caller |
| // is still responsible for the lifetime of this object, but not of the |
| // |stream|. |
| void WriteStream(IOutputStream* stream, |
| base::OnceCallback<void()> on_complete) { |
| stream_ = ComPtr<IOutputStream>(stream); |
| on_complete_ = std::move(on_complete); |
| if (!content::GetIOThreadTaskRunner({})->PostTask( |
| FROM_HERE, |
| base::BindOnce(&OutputStreamWriteOperation::WriteStreamOnIOThread, |
| weak_factory_.GetWeakPtr()))) |
| Complete(); |
| } |
| |
| private: |
| friend class base::RefCounted<OutputStreamWriteOperation>; |
| |
| ~OutputStreamWriteOperation() = default; |
| |
| void WriteStreamOnIOThread() { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| |
| storage::BlobStorageContext* blob_storage_context = |
| blob_context_getter_.Run().get(); |
| if (!blob_storage_context) { |
| Complete(); |
| return; |
| } |
| |
| blob_storage_context->GetBlobDataFromBlobRemote( |
| std::move(blob_), |
| base::BindOnce(&OutputStreamWriteOperation::BlobDataHandleReady, |
| weak_factory_.GetWeakPtr())); |
| } |
| |
| void BlobDataHandleReady( |
| std::unique_ptr<storage::BlobDataHandle> data_handle) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| |
| blob_handle_ = std::move(data_handle); |
| ComPtr<IDataWriterFactory> data_writer_factory; |
| auto hr = |
| GetActivationFactory<IDataWriterFactory, |
| RuntimeClass_Windows_Storage_Streams_DataWriter>( |
| &data_writer_factory); |
| if (FAILED(hr)) { |
| Complete(); |
| return; |
| } |
| |
| ComPtr<IDataWriter> data_writer; |
| hr = data_writer_factory->CreateDataWriter(stream_.Get(), &data_writer); |
| if (FAILED(hr)) { |
| Complete(); |
| return; |
| } |
| |
| writer_delegate_ = std::make_unique<storage::FileWriterDelegate>( |
| std::make_unique<DataWriterFileStreamWriter>(std::move(data_writer), |
| file_bytes_shared_), |
| storage::FlushPolicy::FLUSH_ON_COMPLETION); |
| writer_delegate_->Start( |
| blob_handle_->CreateReader(), |
| base::BindRepeating(&OutputStreamWriteOperation::OnFileWritten, |
| weak_factory_.GetWeakPtr())); |
| } |
| |
| void OnFileWritten( |
| base::File::Error error, |
| int64_t bytes_wrriten, |
| storage::FileWriterDelegate::WriteProgressStatus write_status) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| // Any status other than SUCCESS_IO_PENDING indicates completion. |
| if (write_status != |
| storage::FileWriterDelegate::WriteProgressStatus::SUCCESS_IO_PENDING) { |
| Complete(); |
| } |
| } |
| |
| void Complete() { |
| // If the IOutputStream implements IClosable (e.g. the OutputStream class), |
| // close the stream whenever we are done with this operation, regardless of |
| // the outcome. |
| if (stream_) { |
| ComPtr<IClosable> closable; |
| if (SUCCEEDED(stream_.As(&closable))) |
| closable->Close(); |
| } |
| |
| std::move(on_complete_).Run(); |
| } |
| |
| content::BrowserContext::BlobContextGetter blob_context_getter_; |
| std::unique_ptr<storage::BlobDataHandle> blob_handle_; |
| scoped_refptr<base::RefCountedData<uint64_t>> file_bytes_shared_; |
| base::OnceCallback<void()> on_complete_; |
| ComPtr<IOutputStream> stream_; |
| mojo::PendingRemote<blink::mojom::Blob> blob_; |
| std::unique_ptr<storage::FileWriterDelegate> writer_delegate_; |
| base::WeakPtrFactory<OutputStreamWriteOperation> weak_factory_{this}; |
| }; |
| } // namespace |
| |
| // static |
| void ShareOperation::SetMaxFileBytesForTesting(uint64_t max_file_bytes) { |
| g_max_file_bytes = max_file_bytes; |
| } |
| |
| // static |
| void ShareOperation::SetRoGetActivationFactoryFunctionForTesting( |
| decltype(&base::win::RoGetActivationFactory) value) { |
| g_ro_get_activation_factory_function = value; |
| } |
| |
| ShareOperation::ShareOperation(const std::string& title, |
| const std::string& text, |
| const GURL& url, |
| content::WebContents* web_contents) |
| : web_contents_(web_contents->GetWeakPtr()), |
| title_(std::move(title)), |
| text_(std::move(text)), |
| url_(std::move(url)) {} |
| |
| ShareOperation::~ShareOperation() { |
| if (callback_) |
| Complete(blink::mojom::ShareError::CANCELED); |
| } |
| |
| base::WeakPtr<ShareOperation> ShareOperation::AsWeakPtr() { |
| return weak_factory_.GetWeakPtr(); |
| } |
| |
| void ShareOperation::Run(SharedFiles files, |
| blink::mojom::ShareService::ShareCallback callback) { |
| DCHECK(!callback_); |
| callback_ = std::move(callback); |
| |
| // If the corresponding web_contents have already been cleaned up, cancel |
| // the operation. |
| if (!web_contents_) { |
| Complete(blink::mojom::ShareError::CANCELED); |
| return; |
| } |
| |
| if (files.size() > 0) { |
| // Determine the source for use with the OS IAttachmentExecute. |
| // If the source cannot be determined, does not appear to be valid, |
| // or is longer than the max length supported by the IAttachmentExecute |
| // service, use a generic value that reliably maps to the Internet zone. |
| GURL source_url = web_contents_->GetLastCommittedURL(); |
| std::wstring source = (source_url.is_valid() && |
| source_url.spec().size() <= INTERNET_MAX_URL_LENGTH) |
| ? base::UTF8ToWide(source_url.spec()) |
| : L"about:internet"; |
| |
| // For each "file", check against the OS that it is allowed |
| // The same instance cannot be used to check multiple files, so this |
| // makes a new one per-file. For more details on this functionality, see |
| // https://docs.microsoft.com/en-us/windows/win32/api/shobjidl_core/nf-shobjidl_core-iattachmentexecute-checkpolicy |
| for (auto& file : files) { |
| ComPtr<IAttachmentExecute> attachment_services; |
| if (FAILED(CoCreateInstance(CLSID_AttachmentServices, nullptr, CLSCTX_ALL, |
| IID_PPV_ARGS(&attachment_services)))) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| if (FAILED(attachment_services->SetSource(source.c_str()))) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| if (FAILED(attachment_services->SetFileName( |
| file->name.path().value().c_str()))) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| if (FAILED(attachment_services->CheckPolicy())) { |
| Complete(blink::mojom::ShareError::PERMISSION_DENIED); |
| return; |
| } |
| } |
| } |
| |
| HWND hwnd = |
| views::HWNDForNativeWindow(web_contents_->GetTopLevelNativeWindow()); |
| |
| // Attempt to fetch the special HWND maintained for the primary WebContents of |
| // this window. For the sake of better communication with screen readers this |
| // HWND is (virtually) scoped to the same space as the WebContents (rather |
| // than the entire actual window), so allows the resulting Share dialog to |
| // better position/associate itself with the WebContents. |
| // |
| // Note: Though this is exposed to accessibility tools via standardized routes |
| // we could expect to leverage here, the browser may choose to not set up all |
| // these routes until an accessibility tool has been detected. Instead we look |
| // for this specific class directly so we can find it even if accessibility |
| // has not been configured yet. |
| if (hwnd) { |
| HWND accessible_hwnd = |
| ::FindWindowExW(/*hWndParent*/ hwnd, /*hWndChildAfter*/ NULL, |
| /*lpszClass*/ ui::kLegacyRenderWidgetHostHwnd, |
| /*lpszWindow*/ NULL); |
| if (accessible_hwnd) { |
| hwnd = accessible_hwnd; |
| } |
| } |
| |
| show_share_ui_for_window_operation_ = |
| std::make_unique<ShowShareUIForWindowOperation>(hwnd); |
| show_share_ui_for_window_operation_->Run( |
| base::BindOnce(&ShareOperation::OnDataRequested, |
| weak_factory_.GetWeakPtr(), std::move(files))); |
| } |
| |
| void ShareOperation::OnDataRequested(SharedFiles files, |
| IDataRequestedEventArgs* event_args) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| blink::mojom::ShareError share_result; |
| if (!web_contents_) { |
| share_result = blink::mojom::ShareError::CANCELED; |
| } else if (PutShareContentInEventArgs(std::move(files), event_args)) { |
| share_result = blink::mojom::ShareError::OK; |
| } else { |
| share_result = blink::mojom::ShareError::INTERNAL_ERROR; |
| } |
| |
| // If the share operation failed or is not being deferred, mark it as complete |
| if (share_result != blink::mojom::ShareError::OK || !data_request_deferral_) |
| Complete(share_result); |
| } |
| |
| bool ShareOperation::PutShareContentInEventArgs( |
| SharedFiles files, |
| IDataRequestedEventArgs* event_args) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| if (!event_args) |
| return false; |
| |
| ComPtr<IDataRequest> data_request; |
| if (FAILED(event_args->get_Request(&data_request))) |
| return false; |
| |
| if (FAILED(data_request->get_Data(&data_package_))) |
| return false; |
| |
| ComPtr<IDataPackagePropertySet> data_prop_sets; |
| if (FAILED(data_package_->get_Properties(&data_prop_sets))) |
| return false; |
| |
| // Title is a required property for the UWP Share contract, so |
| // if the provided title is empty we instead use a blank value. |
| // https://docs.microsoft.com/en-us/windows/uwp/app-to-app/share-data |
| base::win::ScopedHString title_h = |
| base::win::ScopedHString::Create(title_.empty() ? " " : title_.c_str()); |
| if (FAILED(data_prop_sets->put_Title(title_h.get()))) |
| return false; |
| |
| return PutShareContentInDataPackage(std::move(files), data_request.Get()); |
| } |
| |
| bool ShareOperation::PutShareContentInDataPackage(SharedFiles files, |
| IDataRequest* data_request) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| if (!text_.empty()) { |
| auto text_h = base::win::ScopedHString::Create(text_); |
| if (FAILED(data_package_->SetText(text_h.get()))) |
| return false; |
| } |
| |
| if (!url_.spec().empty()) { |
| ComPtr<IUriRuntimeClassFactory> uri_factory; |
| auto hr = |
| GetActivationFactory<IUriRuntimeClassFactory, |
| RuntimeClass_Windows_Foundation_Uri>(&uri_factory); |
| if (FAILED(hr)) |
| return hr; |
| |
| auto url_h = base::win::ScopedHString::Create(url_.spec().c_str()); |
| ComPtr<IUriRuntimeClass> uri; |
| if (FAILED(uri_factory->CreateUri(url_h.get(), &uri))) |
| return false; |
| |
| ComPtr<IDataPackage2> data_package_2; |
| if (FAILED(data_package_.As(&data_package_2))) |
| return false; |
| |
| if (FAILED(data_package_2->SetWebLink(uri.Get()))) |
| return false; |
| } |
| |
| if (!files.empty()) { |
| // Fetch a deferral to allow for async operations |
| if (FAILED(data_request->GetDeferral(&data_request_deferral_))) |
| return false; |
| |
| // Initialize the output collection for the async operation(s) |
| storage_items_ = Make<base::win::Vector<IStorageItem*>>(); |
| |
| // Create a variable to be shared between all the operations processing the |
| // blobs to streams. This will be used to keep a running count of total file |
| // bytes shared as part of this Share operation so that if the maximum |
| // allowed is exceeded the processing can be halted. Currently the |
| // ShareOperation class is not guaranteed to outlive these operations, but |
| // if that changes in the future it may be appropriate to make this a member |
| // of the ShareOperation that is shared only be reference. |
| auto file_bytes_shared = |
| base::MakeRefCounted<base::RefCountedData<uint64_t>>(0); |
| |
| ComPtr<IStorageFileStatics> storage_statics; |
| auto hr = GetActivationFactory<IStorageFileStatics, |
| RuntimeClass_Windows_Storage_StorageFile>( |
| &storage_statics); |
| if (FAILED(hr)) |
| return false; |
| |
| for (auto& file : files) { |
| // This operation for converting the corresponding blob to a stream is |
| // maintained as a scoped_refptr because it may out live this |
| // ShareOperation instance. It is only invoked when the user has chosen a |
| // Share target and that target decides to start reading the contents of |
| // the corresponding IStorageFile. See |
| // https://docs.microsoft.com/en-us/uwp/api/windows.storage.storagefile.createstreamedfileasync |
| // If in the future the ShareOperation class is changed to live until the |
| // target app has finished fully processing the shared content this could |
| // be updated to be owned/maintained by this ShareOperation instance. |
| auto operation = base::MakeRefCounted<OutputStreamWriteOperation>( |
| web_contents_->GetBrowserContext()->GetBlobStorageContext(), |
| file_bytes_shared, std::move(file->blob->blob)); |
| auto name_h = base::win::ScopedHString::Create(file->name.path().value()); |
| auto raw_data_requested_callback = |
| Callback<IStreamedFileDataRequestedHandler>( |
| [operation](IOutputStream* stream) -> HRESULT { |
| // No additional work is needed when the write has been |
| // completed, but a callback is created to hold a reference |
| // to the |operation| until the operation has completed. |
| operation->WriteStream( |
| stream, |
| base::BindOnce( |
| [](scoped_refptr<OutputStreamWriteOperation>) {}, |
| operation)); |
| return S_OK; |
| }); |
| // The Callback function may return null in the E_OUTOFMEMORY case |
| if (!raw_data_requested_callback) |
| return false; |
| ComPtr<IAsyncOperation<StorageFile*>> async_operation; |
| if (FAILED(storage_statics->CreateStreamedFileAsync( |
| name_h.get(), raw_data_requested_callback.Get(), |
| /*thumbnail*/ nullptr, &async_operation))) { |
| return false; |
| } |
| |
| async_operations_.push_back(async_operation); |
| |
| if (FAILED(base::win::PostAsyncHandlers( |
| async_operation.Get(), |
| base::BindOnce(&ShareOperation::OnStreamedFileCreated, |
| weak_factory_.GetWeakPtr(), files.size())))) { |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| void ShareOperation::OnStreamedFileCreated(uint32_t expected_file_count, |
| ComPtr<IStorageFile> storage_file) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| // If there is no callback this ShareOperation already completed due to an |
| // error, so work can be halted early. |
| if (!callback_) |
| return; |
| |
| if (!storage_file) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| |
| ComPtr<IStorageItem> storage_item; |
| if (FAILED(storage_file.As(&storage_item))) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| |
| if (FAILED(storage_items_->Append(storage_item.Get()))) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| |
| unsigned int size; |
| if (FAILED(storage_items_->get_Size(&size))) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| |
| // If this is not the final file, no more work to do |
| if (size != expected_file_count) { |
| return; |
| } |
| |
| if (FAILED(data_package_->SetStorageItems(storage_items_.Get(), |
| true /*readonly*/))) { |
| Complete(blink::mojom::ShareError::INTERNAL_ERROR); |
| return; |
| } |
| |
| data_request_deferral_->Complete(); |
| Complete(blink::mojom::ShareError::OK); |
| return; |
| } |
| |
| void ShareOperation::Complete(const blink::mojom::ShareError share_result) { |
| std::move(callback_).Run(share_result); |
| } |
| |
| } // namespace webshare |
