| // Copyright 2018 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/worker_devtools_agent_host.h" | |
| #include "base/bind.h" | |
| #include "base/callback_helpers.h" | |
| #include "content/browser/devtools/devtools_session.h" | |
| #include "content/browser/devtools/protocol/io_handler.h" | |
| #include "content/browser/devtools/protocol/network_handler.h" | |
| #include "content/browser/devtools/protocol/target_handler.h" | |
| #include "content/browser/devtools/shared_worker_devtools_agent_host.h" | |
| #include "content/browser/devtools/worker_devtools_manager.h" | |
| #include "content/browser/renderer_host/render_process_host_impl.h" | |
| #include "content/browser/storage_partition_impl.h" | |
| #include "content/browser/worker_host/dedicated_worker_host.h" | |
| #include "content/public/common/child_process_host.h" | |
| namespace content { | |
| namespace protocol { | |
| class TargetAutoAttacher; | |
| } // namespace protocol | |
| // static | |
| WorkerDevToolsAgentHost* WorkerDevToolsAgentHost::GetFor( | |
| DedicatedWorkerHost* host) { | |
| return WorkerDevToolsManager::GetInstance().GetDevToolsHost(host); | |
| } | |
| WorkerDevToolsAgentHost::WorkerDevToolsAgentHost( | |
| int process_id, | |
| mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote, | |
| mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver, | |
| const GURL& url, | |
| const std::string& name, | |
| const base::UnguessableToken& devtools_worker_token, | |
| const std::string& parent_id, | |
| base::OnceCallback<void(DevToolsAgentHostImpl*)> destroyed_callback) | |
| : DevToolsAgentHostImpl(devtools_worker_token.ToString()), | |
| process_id_(process_id), | |
| url_(url), | |
| name_(name), | |
| parent_id_(parent_id), | |
| auto_attacher_(std::make_unique<protocol::RendererAutoAttacherBase>( | |
| GetRendererChannel())), | |
| destroyed_callback_(std::move(destroyed_callback)), | |
| devtools_worker_token_(devtools_worker_token) { | |
| DCHECK(!devtools_worker_token.is_empty()); | |
| // TODO(crbug.com/906991): Remove AddRef() and Release() once | |
| // PlzDedicatedWorker is enabled and the code for non-PlzDedicatedWorker is | |
| // deleted. Worker agent hosts will be retained by the Worker DevTools manager | |
| // instead. | |
| AddRef(); // Self keep-alive while the worker agent is alive. | |
| NotifyCreated(); | |
| if (!base::FeatureList::IsEnabled(blink::features::kPlzDedicatedWorker)) | |
| SetRenderer(process_id, std::move(agent_remote), std::move(host_receiver)); | |
| } | |
| WorkerDevToolsAgentHost::~WorkerDevToolsAgentHost() = default; | |
| void WorkerDevToolsAgentHost::SetRenderer( | |
| int process_id, | |
| mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote, | |
| mojo::PendingReceiver<blink::mojom::DevToolsAgentHost> host_receiver) { | |
| DCHECK(agent_remote); | |
| DCHECK(host_receiver); | |
| base::OnceClosure connection_error = (base::BindOnce( | |
| &WorkerDevToolsAgentHost::Disconnected, base::Unretained(this))); | |
| GetRendererChannel()->SetRenderer(std::move(agent_remote), | |
| std::move(host_receiver), process_id, | |
| std::move(connection_error)); | |
| } | |
| void WorkerDevToolsAgentHost::ChildWorkerCreated( | |
| const GURL& url, | |
| const std::string& name, | |
| base::OnceCallback<void(DevToolsAgentHostImpl*)> callback) { | |
| DCHECK(base::FeatureList::IsEnabled(blink::features::kPlzDedicatedWorker)); | |
| url_ = url; | |
| name_ = name; | |
| destroyed_callback_ = std::move(callback); | |
| } | |
| void WorkerDevToolsAgentHost::Disconnected() { | |
| ForceDetachAllSessions(); | |
| GetRendererChannel()->SetRenderer(mojo::NullRemote(), mojo::NullReceiver(), | |
| ChildProcessHost::kInvalidUniqueID); | |
| std::move(destroyed_callback_).Run(this); | |
| Release(); // Matches AddRef() in constructor. | |
| } | |
| BrowserContext* WorkerDevToolsAgentHost::GetBrowserContext() { | |
| RenderProcessHost* process = RenderProcessHost::FromID(process_id_); | |
| return process ? process->GetBrowserContext() : nullptr; | |
| } | |
| RenderProcessHost* WorkerDevToolsAgentHost::GetProcessHost() { | |
| return RenderProcessHost::FromID(process_id_); | |
| } | |
| std::string WorkerDevToolsAgentHost::GetType() { | |
| return kTypeDedicatedWorker; | |
| } | |
| std::string WorkerDevToolsAgentHost::GetTitle() { | |
| return name_.empty() ? url_.spec() : name_; | |
| } | |
| std::string WorkerDevToolsAgentHost::GetParentId() { | |
| return parent_id_; | |
| } | |
| GURL WorkerDevToolsAgentHost::GetURL() { | |
| return url_; | |
| } | |
| bool WorkerDevToolsAgentHost::Activate() { | |
| return false; | |
| } | |
| void WorkerDevToolsAgentHost::Reload() {} | |
| bool WorkerDevToolsAgentHost::Close() { | |
| return false; | |
| } | |
| bool WorkerDevToolsAgentHost::AttachSession(DevToolsSession* session, | |
| bool acquire_wake_lock) { | |
| session->CreateAndAddHandler<protocol::IOHandler>(GetIOContext()); | |
| session->CreateAndAddHandler<protocol::TargetHandler>( | |
| protocol::TargetHandler::AccessMode::kAutoAttachOnly, GetId(), | |
| auto_attacher_.get(), session); | |
| session->CreateAndAddHandler<protocol::NetworkHandler>( | |
| GetId(), devtools_worker_token_, GetIOContext(), base::DoNothing(), | |
| session->GetClient()->MayReadLocalFiles()); | |
| return true; | |
| } | |
| void WorkerDevToolsAgentHost::DetachSession(DevToolsSession* session) { | |
| // Destroying session automatically detaches in renderer. | |
| } | |
| protocol::TargetAutoAttacher* WorkerDevToolsAgentHost::auto_attacher() { | |
| return auto_attacher_.get(); | |
| } | |
| DedicatedWorkerHost* WorkerDevToolsAgentHost::GetDedicatedWorkerHost() { | |
| RenderProcessHost* process = RenderProcessHost::FromID(process_id_); | |
| auto* storage_partition_impl = | |
| static_cast<StoragePartitionImpl*>(process->GetStoragePartition()); | |
| auto* service = storage_partition_impl->GetDedicatedWorkerService(); | |
| return service->GetDedicatedWorkerHostFromToken( | |
| blink::DedicatedWorkerToken(devtools_worker_token_)); | |
| } | |
| absl::optional<network::CrossOriginEmbedderPolicy> | |
| WorkerDevToolsAgentHost::cross_origin_embedder_policy(const std::string&) { | |
| DedicatedWorkerHost* host = GetDedicatedWorkerHost(); | |
| if (!host) { | |
| return absl::nullopt; | |
| } | |
| return host->cross_origin_embedder_policy(); | |
| } | |
| } // namespace content |