| // Copyright 2015 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "content/browser/devtools/protocol/io_handler.h" | |
| #include <stddef.h> | |
| #include <stdint.h> | |
| #include <memory> | |
| #include "base/bind.h" | |
| #include "base/files/file.h" | |
| #include "base/files/file_util.h" | |
| #include "base/memory/ref_counted_memory.h" | |
| #include "base/strings/string_number_conversions.h" | |
| #include "base/strings/string_util.h" | |
| #include "content/browser/blob_storage/chrome_blob_storage_context.h" | |
| #include "content/browser/devtools/devtools_io_context.h" | |
| #include "content/browser/devtools/devtools_stream_blob.h" | |
| #include "content/public/browser/browser_context.h" | |
| #include "content/public/browser/browser_thread.h" | |
| #include "content/public/browser/render_process_host.h" | |
| namespace content { | |
| namespace protocol { | |
| IOHandler::IOHandler(DevToolsIOContext* io_context) | |
| : DevToolsDomainHandler(IO::Metainfo::domainName), | |
| io_context_(io_context), | |
| browser_context_(nullptr), | |
| storage_partition_(nullptr) {} | |
| IOHandler::~IOHandler() = default; | |
| void IOHandler::Wire(UberDispatcher* dispatcher) { | |
| frontend_ = std::make_unique<IO::Frontend>(dispatcher->channel()); | |
| IO::Dispatcher::wire(dispatcher, this); | |
| } | |
| void IOHandler::SetRenderer(int process_host_id, | |
| RenderFrameHostImpl* frame_host) { | |
| RenderProcessHost* process_host = RenderProcessHost::FromID(process_host_id); | |
| if (process_host) { | |
| browser_context_ = process_host->GetBrowserContext(); | |
| storage_partition_ = process_host->GetStoragePartition(); | |
| } else { | |
| browser_context_ = nullptr; | |
| storage_partition_ = nullptr; | |
| } | |
| } | |
| void IOHandler::Read( | |
| const std::string& handle, | |
| Maybe<int> offset, | |
| Maybe<int> max_size, | |
| std::unique_ptr<ReadCallback> callback) { | |
| static const size_t kDefaultChunkSize = 10 * 1024 * 1024; | |
| static const char kBlobPrefix[] = "blob:"; | |
| scoped_refptr<DevToolsIOContext::Stream> stream = | |
| io_context_->GetByHandle(handle); | |
| if (!stream && browser_context_ && | |
| StartsWith(handle, kBlobPrefix, base::CompareCase::SENSITIVE)) { | |
| ChromeBlobStorageContext* blob_context = | |
| ChromeBlobStorageContext::GetFor(browser_context_); | |
| std::string uuid = handle.substr(strlen(kBlobPrefix)); | |
| stream = DevToolsStreamBlob::Create(io_context_, blob_context, | |
| storage_partition_, handle, uuid); | |
| } | |
| if (!stream) { | |
| callback->sendFailure(Response::InvalidParams("Invalid stream handle")); | |
| return; | |
| } | |
| if (offset.isJust() && !stream->SupportsSeek()) { | |
| callback->sendFailure( | |
| Response::InvalidParams("Read offset is specificed for a stream that " | |
| "does not support random access")); | |
| return; | |
| } | |
| int size = max_size.fromMaybe(kDefaultChunkSize); | |
| if (size <= 0) { | |
| callback->sendFailure(Response::InvalidParams("Invalid max read size")); | |
| return; | |
| } | |
| stream->Read(offset.fromMaybe(-1), size, | |
| base::BindOnce(&IOHandler::ReadComplete, | |
| weak_factory_.GetWeakPtr(), std::move(callback))); | |
| } | |
| void IOHandler::ReadComplete(std::unique_ptr<ReadCallback> callback, | |
| std::unique_ptr<std::string> data, | |
| bool base64_encoded, | |
| int status) { | |
| if (status == DevToolsIOContext::Stream::StatusFailure) { | |
| callback->sendFailure(Response::ServerError("Read failed")); | |
| return; | |
| } | |
| bool eof = status == DevToolsIOContext::Stream::StatusEOF; | |
| callback->sendSuccess(base64_encoded, std::move(*data), eof); | |
| } | |
| Response IOHandler::Close(const std::string& handle) { | |
| return io_context_->Close(handle) | |
| ? Response::Success() | |
| : Response::InvalidParams("Invalid stream handle"); | |
| } | |
| } // namespace protocol | |
| } // namespace content |