diff options
Diffstat (limited to 'content/browser/devtools')
14 files changed, 202 insertions, 140 deletions
diff --git a/content/browser/devtools/browser_devtools_agent_host.cc b/content/browser/devtools/browser_devtools_agent_host.cc index d045571..d7c3423 100644 --- a/content/browser/devtools/browser_devtools_agent_host.cc +++ b/content/browser/devtools/browser_devtools_agent_host.cc @@ -31,10 +31,7 @@ BrowserDevToolsAgentHost::BrowserDevToolsAgentHost( tethering_task_runner)), tracing_handler_(new devtools::tracing::TracingHandler( devtools::tracing::TracingHandler::Browser, GetIOContext())), - protocol_handler_(new DevToolsProtocolHandler( - this, - base::Bind(&BrowserDevToolsAgentHost::SendMessageToClient, - base::Unretained(this)))) { + protocol_handler_(new DevToolsProtocolHandler(this)) { DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher(); dispatcher->SetIOHandler(io_handler_.get()); dispatcher->SetMemoryHandler(memory_handler_.get()); @@ -74,7 +71,7 @@ bool BrowserDevToolsAgentHost::Close() { bool BrowserDevToolsAgentHost::DispatchProtocolMessage( const std::string& message) { - protocol_handler_->HandleMessage(message); + protocol_handler_->HandleMessage(session_id(), message); return true; } diff --git a/content/browser/devtools/devtools_agent_host_impl.cc b/content/browser/devtools/devtools_agent_host_impl.cc index 4d93551..7385def 100644 --- a/content/browser/devtools/devtools_agent_host_impl.cc +++ b/content/browser/devtools/devtools_agent_host_impl.cc @@ -76,8 +76,7 @@ scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForWorker( } DevToolsAgentHostImpl::DevToolsAgentHostImpl() - : id_(base::GenerateGUID()), - client_(NULL) { + : id_(base::GenerateGUID()), session_id_(0), client_(NULL) { DCHECK_CURRENTLY_ON(BrowserThread::UI); g_instances.Get()[id_] = this; } @@ -106,6 +105,7 @@ scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::Create( void DevToolsAgentHostImpl::AttachClient(DevToolsAgentHostClient* client) { scoped_refptr<DevToolsAgentHostImpl> protect(this); + ++session_id_; if (client_) { client_->AgentHostClosed(this, true); InnerDetach(); @@ -153,6 +153,16 @@ void DevToolsAgentHostImpl::DisconnectWebContents() { void DevToolsAgentHostImpl::ConnectWebContents(WebContents* wc) { } +void DevToolsAgentHostImpl::SendProtocolResponse(int session_id, + const std::string& message) { + SendMessageToClient(session_id, message); +} + +void DevToolsAgentHostImpl::SendProtocolNotification( + const std::string& message) { + SendMessageToClient(session_id_, message); +} + void DevToolsAgentHostImpl::HostClosed() { if (!client_) return; @@ -164,9 +174,13 @@ void DevToolsAgentHostImpl::HostClosed() { client->AgentHostClosed(this, false); } -void DevToolsAgentHostImpl::SendMessageToClient(const std::string& message) { +void DevToolsAgentHostImpl::SendMessageToClient(int session_id, + const std::string& message) { if (!client_) return; + // Filter any messages from previous sessions. + if (session_id != session_id_) + return; client_->DispatchProtocolMessage(this, message); } @@ -249,7 +263,7 @@ void DevToolsMessageChunkProcessor::ProcessChunkedMessageFromAgent( if (chunk.is_first && chunk.is_last) { CHECK(message_buffer_size_ == 0); - callback_.Run(chunk.data); + callback_.Run(chunk.session_id, chunk.data); return; } @@ -265,7 +279,7 @@ void DevToolsMessageChunkProcessor::ProcessChunkedMessageFromAgent( if (chunk.is_last) { CHECK(message_buffer_.size() == message_buffer_size_); - callback_.Run(message_buffer_); + callback_.Run(chunk.session_id, message_buffer_); message_buffer_ = std::string(); message_buffer_size_ = 0; } diff --git a/content/browser/devtools/devtools_agent_host_impl.h b/content/browser/devtools/devtools_agent_host_impl.h index 8474c0a..2dc09cc 100644 --- a/content/browser/devtools/devtools_agent_host_impl.h +++ b/content/browser/devtools/devtools_agent_host_impl.h @@ -9,6 +9,7 @@ #include "base/compiler_specific.h" #include "content/browser/devtools/devtools_io_context.h" +#include "content/browser/devtools/protocol/devtools_protocol_delegate.h" #include "content/common/content_export.h" #include "content/common/devtools_messages.h" #include "content/public/browser/devtools_agent_host.h" @@ -22,7 +23,8 @@ namespace content { class BrowserContext; // Describes interface for managing devtools agents from the browser process. -class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost { +class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost, + public DevToolsProtocolDelegate { public: // Informs the hosted agent that a client host has attached. virtual void Attach() = 0; @@ -44,14 +46,21 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost { void DisconnectWebContents() override; void ConnectWebContents(WebContents* wc) override; + // DevToolsProtocolDelegate implementation. + void SendProtocolResponse(int session_id, + const std::string& message) override; + void SendProtocolNotification(const std::string& message) override; + protected: DevToolsAgentHostImpl(); ~DevToolsAgentHostImpl() override; void HostClosed(); - void SendMessageToClient(const std::string& message); + void SendMessageToClient(int session_id, const std::string& message); devtools::DevToolsIOContext* GetIOContext() { return &io_context_; } + int session_id() { DCHECK(client_); return session_id_; } + static void NotifyCallbacks(DevToolsAgentHostImpl* agent_host, bool attached); private: @@ -59,13 +68,14 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost { void InnerDetach(); const std::string id_; + int session_id_; DevToolsAgentHostClient* client_; devtools::DevToolsIOContext io_context_; }; class DevToolsMessageChunkProcessor { public: - using SendMessageCallback = base::Callback<void(const std::string&)>; + using SendMessageCallback = base::Callback<void(int, const std::string&)>; explicit DevToolsMessageChunkProcessor(const SendMessageCallback& callback); ~DevToolsMessageChunkProcessor(); diff --git a/content/browser/devtools/devtools_protocol_handler.cc b/content/browser/devtools/devtools_protocol_handler.cc index 86ccd8e..9f69cfb 100644 --- a/content/browser/devtools/devtools_protocol_handler.cc +++ b/content/browser/devtools/devtools_protocol_handler.cc @@ -7,6 +7,7 @@ #include "base/bind.h" #include "base/json/json_reader.h" #include "base/json/json_writer.h" +#include "content/browser/devtools/devtools_agent_host_impl.h" #include "content/browser/devtools/devtools_manager.h" #include "content/public/browser/devtools_manager_delegate.h" @@ -36,35 +37,35 @@ scoped_ptr<base::DictionaryValue> TakeDictionary(base::DictionaryValue* dict, } // namespace DevToolsProtocolHandler::DevToolsProtocolHandler( - DevToolsAgentHost* agent_host, const Notifier& notifier) - : agent_host_(agent_host), - client_(notifier), - dispatcher_(notifier) { -} + DevToolsAgentHostImpl* agent_host) + : agent_host_(agent_host), client_(agent_host), dispatcher_(agent_host) {} DevToolsProtocolHandler::~DevToolsProtocolHandler() { } -void DevToolsProtocolHandler::HandleMessage(const std::string& message) { - scoped_ptr<base::DictionaryValue> command = ParseCommand(message); +void DevToolsProtocolHandler::HandleMessage(int session_id, + const std::string& message) { + scoped_ptr<base::DictionaryValue> command = ParseCommand(session_id, message); if (!command) return; - if (PassCommandToDelegate(command.get())) + if (PassCommandToDelegate(session_id, command.get())) return; - HandleCommand(command.Pass()); + HandleCommand(session_id, command.Pass()); } -bool DevToolsProtocolHandler::HandleOptionalMessage( - const std::string& message, int* call_id) { - scoped_ptr<base::DictionaryValue> command = ParseCommand(message); +bool DevToolsProtocolHandler::HandleOptionalMessage(int session_id, + const std::string& message, + int* call_id) { + scoped_ptr<base::DictionaryValue> command = ParseCommand(session_id, message); if (!command) return true; - if (PassCommandToDelegate(command.get())) + if (PassCommandToDelegate(session_id, command.get())) return true; - return HandleOptionalCommand(command.Pass(), call_id); + return HandleOptionalCommand(session_id, command.Pass(), call_id); } bool DevToolsProtocolHandler::PassCommandToDelegate( + int session_id, base::DictionaryValue* command) { DevToolsManagerDelegate* delegate = DevToolsManager::GetInstance()->delegate(); @@ -74,41 +75,41 @@ bool DevToolsProtocolHandler::PassCommandToDelegate( scoped_ptr<base::DictionaryValue> response( delegate->HandleCommand(agent_host_, command)); if (response) { - std::string json_response; - base::JSONWriter::Write(*response, &json_response); - client_.SendRawMessage(json_response); + client_.SendMessage(session_id, *response); return true; } return false; } -scoped_ptr<base::DictionaryValue> -DevToolsProtocolHandler::ParseCommand(const std::string& message) { +scoped_ptr<base::DictionaryValue> DevToolsProtocolHandler::ParseCommand( + int session_id, + const std::string& message) { scoped_ptr<base::Value> value = base::JSONReader::Read(message); if (!value || !value->IsType(base::Value::TYPE_DICTIONARY)) { - client_.SendError(DevToolsProtocolClient::kNoId, - Response(kStatusParseError, - "Message must be in JSON format")); + client_.SendError( + DevToolsCommandId(DevToolsCommandId::kNoId, session_id), + Response(kStatusParseError, "Message must be in JSON format")); return nullptr; } scoped_ptr<base::DictionaryValue> command = make_scoped_ptr(static_cast<base::DictionaryValue*>(value.release())); - int id = DevToolsProtocolClient::kNoId; - bool ok = command->GetInteger(kIdParam, &id) && id >= 0; + int call_id = DevToolsCommandId::kNoId; + bool ok = command->GetInteger(kIdParam, &call_id) && call_id >= 0; if (!ok) { - client_.SendError(id, Response(kStatusInvalidRequest, - "The type of 'id' property must be number")); + client_.SendError(DevToolsCommandId(call_id, session_id), + Response(kStatusInvalidRequest, + "The type of 'id' property must be number")); return nullptr; } std::string method; ok = command->GetString(kMethodParam, &method); if (!ok) { - client_.SendError(id, - Response(kStatusInvalidRequest, - "The type of 'method' property must be string")); + client_.SendError(DevToolsCommandId(call_id, session_id), + Response(kStatusInvalidRequest, + "The type of 'method' property must be string")); return nullptr; } @@ -116,34 +117,39 @@ DevToolsProtocolHandler::ParseCommand(const std::string& message) { } void DevToolsProtocolHandler::HandleCommand( + int session_id, scoped_ptr<base::DictionaryValue> command) { - int id = DevToolsProtocolClient::kNoId; + int call_id = DevToolsCommandId::kNoId; std::string method; - command->GetInteger(kIdParam, &id); + command->GetInteger(kIdParam, &call_id); command->GetString(kMethodParam, &method); DevToolsProtocolDispatcher::CommandHandler command_handler( dispatcher_.FindCommandHandler(method)); if (command_handler.is_null()) { - client_.SendError(id, Response(kStatusNoSuchMethod, "No such method")); + client_.SendError(DevToolsCommandId(call_id, session_id), + Response(kStatusNoSuchMethod, "No such method")); return; } bool result = - command_handler.Run(id, TakeDictionary(command.get(), kParamsParam)); + command_handler.Run(DevToolsCommandId(call_id, session_id), + TakeDictionary(command.get(), kParamsParam)); DCHECK(result); } bool DevToolsProtocolHandler::HandleOptionalCommand( - scoped_ptr<base::DictionaryValue> command, int* call_id) { - *call_id = DevToolsProtocolClient::kNoId; + int session_id, + scoped_ptr<base::DictionaryValue> command, + int* call_id) { + *call_id = DevToolsCommandId::kNoId; std::string method; command->GetInteger(kIdParam, call_id); command->GetString(kMethodParam, &method); DevToolsProtocolDispatcher::CommandHandler command_handler( dispatcher_.FindCommandHandler(method)); if (!command_handler.is_null()) { - return command_handler.Run( - *call_id, TakeDictionary(command.get(), kParamsParam)); + return command_handler.Run(DevToolsCommandId(*call_id, session_id), + TakeDictionary(command.get(), kParamsParam)); } return false; } diff --git a/content/browser/devtools/devtools_protocol_handler.h b/content/browser/devtools/devtools_protocol_handler.h index 299b342..32f4928 100644 --- a/content/browser/devtools/devtools_protocol_handler.h +++ b/content/browser/devtools/devtools_protocol_handler.h @@ -10,26 +10,30 @@ namespace content { class DevToolsAgentHost; +class DevToolsAgentHostImpl; +class DevToolsProtocolDelegate; class DevToolsProtocolHandler { public: using Response = DevToolsProtocolClient::Response; - using Notifier = base::Callback<void(const std::string& message)>; - DevToolsProtocolHandler(DevToolsAgentHost* agent_host, - const Notifier& notifier); + explicit DevToolsProtocolHandler(DevToolsAgentHostImpl* agent_host); virtual ~DevToolsProtocolHandler(); - void HandleMessage(const std::string& message); - bool HandleOptionalMessage(const std::string& message, int* call_id); + void HandleMessage(int session_id, const std::string& message); + bool HandleOptionalMessage(int session_id, + const std::string& message, + int* call_id); DevToolsProtocolDispatcher* dispatcher() { return &dispatcher_; } private: - scoped_ptr<base::DictionaryValue> ParseCommand(const std::string& message); - bool PassCommandToDelegate(base::DictionaryValue* command); - void HandleCommand(scoped_ptr<base::DictionaryValue> command); - bool HandleOptionalCommand(scoped_ptr<base::DictionaryValue> command, + scoped_ptr<base::DictionaryValue> ParseCommand(int session_id, + const std::string& message); + bool PassCommandToDelegate(int session_id, base::DictionaryValue* command); + void HandleCommand(int session_id, scoped_ptr<base::DictionaryValue> command); + bool HandleOptionalCommand(int session_id, + scoped_ptr<base::DictionaryValue> command, int* call_id); DevToolsAgentHost* agent_host_; diff --git a/content/browser/devtools/forwarding_agent_host.cc b/content/browser/devtools/forwarding_agent_host.cc index ef7f82c..b8b8c2f 100644 --- a/content/browser/devtools/forwarding_agent_host.cc +++ b/content/browser/devtools/forwarding_agent_host.cc @@ -18,7 +18,7 @@ ForwardingAgentHost::~ForwardingAgentHost() { } void ForwardingAgentHost::DispatchOnClientHost(const std::string& message) { - SendMessageToClient(message); + SendMessageToClient(session_id(), message); } void ForwardingAgentHost::ConnectionClosed() { diff --git a/content/browser/devtools/protocol/devtools_protocol_client.cc b/content/browser/devtools/protocol/devtools_protocol_client.cc index 4b7c25d..9ca03f9 100644 --- a/content/browser/devtools/protocol/devtools_protocol_client.cc +++ b/content/browser/devtools/protocol/devtools_protocol_client.cc @@ -6,6 +6,7 @@ #include "base/json/json_writer.h" #include "base/strings/stringprintf.h" +#include "content/browser/devtools/protocol/devtools_protocol_delegate.h" namespace content { @@ -30,24 +31,24 @@ const int kStatusServerError = -32000; } // namespace // static -const DevToolsCommandId DevToolsProtocolClient::kNoId = -1; +const int DevToolsCommandId::kNoId = -1; DevToolsProtocolClient::DevToolsProtocolClient( - const RawMessageCallback& raw_message_callback) - : raw_message_callback_(raw_message_callback) { -} + DevToolsProtocolDelegate* notifier) + : notifier_(notifier) {} DevToolsProtocolClient::~DevToolsProtocolClient() { } -void DevToolsProtocolClient::SendRawMessage(const std::string& message) { - raw_message_callback_.Run(message); +void DevToolsProtocolClient::SendRawNotification(const std::string& message) { + notifier_->SendProtocolNotification(message); } -void DevToolsProtocolClient::SendMessage(const base::DictionaryValue& message) { +void DevToolsProtocolClient::SendMessage(int session_id, + const base::DictionaryValue& message) { std::string json_message; base::JSONWriter::Write(message, &json_message); - SendRawMessage(json_message); + notifier_->SendProtocolResponse(session_id, json_message); } void DevToolsProtocolClient::SendNotification( @@ -58,19 +59,21 @@ void DevToolsProtocolClient::SendNotification( if (params) notification.Set(kParamsParam, params.release()); - SendMessage(notification); + std::string json_message; + base::JSONWriter::Write(notification, &json_message); + SendRawNotification(json_message); } void DevToolsProtocolClient::SendSuccess( DevToolsCommandId command_id, scoped_ptr<base::DictionaryValue> params) { base::DictionaryValue response; - response.SetInteger(kIdParam, command_id); + response.SetInteger(kIdParam, command_id.call_id); response.Set(kResultParam, params ? params.release() : new base::DictionaryValue()); - SendMessage(response); + SendMessage(command_id.session_id, response); } bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id, @@ -80,10 +83,10 @@ bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id, return false; } base::DictionaryValue dict; - if (command_id == kNoId) + if (command_id.call_id == DevToolsCommandId::kNoId) dict.Set(kIdParam, base::Value::CreateNullValue()); else - dict.SetInteger(kIdParam, command_id); + dict.SetInteger(kIdParam, command_id.call_id); base::DictionaryValue* error_object = new base::DictionaryValue(); error_object->SetInteger(kErrorCodeParam, response.status()); @@ -91,7 +94,7 @@ bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id, error_object->SetString(kErrorMessageParam, response.message()); dict.Set(kErrorParam, error_object); - SendMessage(dict); + SendMessage(command_id.session_id, dict); return true; } diff --git a/content/browser/devtools/protocol/devtools_protocol_client.h b/content/browser/devtools/protocol/devtools_protocol_client.h index 9297187..780bc74 100644 --- a/content/browser/devtools/protocol/devtools_protocol_client.h +++ b/content/browser/devtools/protocol/devtools_protocol_client.h @@ -10,16 +10,22 @@ namespace content { -using DevToolsCommandId = int; -class DevToolsProtocolHandler; +struct DevToolsCommandId { + static const int kNoId; + + DevToolsCommandId(int call_id, int session_id) + : call_id(call_id), session_id(session_id) {} + + int call_id; + int session_id; +}; + +class DevToolsProtocolDelegate; class DevToolsProtocolDispatcher; +class DevToolsProtocolHandler; class DevToolsProtocolClient { public: - typedef base::Callback<void(const std::string& message)> - RawMessageCallback; - static const DevToolsCommandId kNoId; - struct Response { public: static Response FallThrough(); @@ -46,12 +52,13 @@ class DevToolsProtocolClient { bool SendError(DevToolsCommandId command_id, const Response& response); - // Sends message to client, the caller is presumed to properly + // Sends notification to client, the caller is presumed to properly // format the message. Do not use unless you must. - void SendRawMessage(const std::string& message); + void SendRawNotification(const std::string& message); - explicit DevToolsProtocolClient( - const RawMessageCallback& raw_message_callback); + void SendMessage(int session_id, const base::DictionaryValue& message); + + explicit DevToolsProtocolClient(DevToolsProtocolDelegate* notifier); virtual ~DevToolsProtocolClient(); protected: @@ -63,9 +70,7 @@ class DevToolsProtocolClient { private: friend class DevToolsProtocolDispatcher; - void SendMessage(const base::DictionaryValue& message); - - RawMessageCallback raw_message_callback_; + DevToolsProtocolDelegate* notifier_; DISALLOW_COPY_AND_ASSIGN(DevToolsProtocolClient); }; diff --git a/content/browser/devtools/protocol/devtools_protocol_delegate.h b/content/browser/devtools/protocol/devtools_protocol_delegate.h new file mode 100644 index 0000000..489020b --- /dev/null +++ b/content/browser/devtools/protocol/devtools_protocol_delegate.h @@ -0,0 +1,22 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DELEGATE_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DELEGATE_H_ + +#include "content/common/content_export.h" + +namespace content { + +class CONTENT_EXPORT DevToolsProtocolDelegate { +public: + virtual ~DevToolsProtocolDelegate() { } + virtual void SendProtocolResponse(int session_id, + const std::string& message) = 0; + virtual void SendProtocolNotification(const std::string& message) = 0; +}; + +} // content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DELEGATE_H_ diff --git a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py index 6bce71e..6377be6 100755 --- a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py +++ b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py @@ -74,11 +74,11 @@ ${types}\ class DevToolsProtocolDispatcher { public: - using Notifier = DevToolsProtocolClient::RawMessageCallback; using CommandHandler = - base::Callback<bool(int, scoped_ptr<base::DictionaryValue>)>; + base::Callback<bool(DevToolsCommandId, + scoped_ptr<base::DictionaryValue>)>; - explicit DevToolsProtocolDispatcher(const Notifier& notifier); + explicit DevToolsProtocolDispatcher(DevToolsProtocolDelegate* notifier); ~DevToolsProtocolDispatcher(); CommandHandler FindCommandHandler(const std::string& method); @@ -91,7 +91,7 @@ ${setters}\ ${methods}\ - Notifier notifier_; + DevToolsProtocolDelegate* notifier_; DevToolsProtocolClient client_; CommandHandlers command_handlers_; ${fields}\ @@ -208,7 +208,7 @@ tmpl_client = string.Template("""\ namespace ${domain} { class Client : public DevToolsProtocolClient { public: - explicit Client(const RawMessageCallback& raw_message_callback); + explicit Client(DevToolsProtocolDelegate* notifier); ~Client() override; ${methods}\ @@ -252,7 +252,7 @@ ${includes}\ namespace content { DevToolsProtocolDispatcher::DevToolsProtocolDispatcher( - const Notifier& notifier) + DevToolsProtocolDelegate* notifier) : notifier_(notifier), client_(notifier), ${fields_init} { @@ -405,8 +405,8 @@ tmpl_object_pass = string.Template( tmpl_client_impl = string.Template("""\ namespace ${domain} { -Client::Client(const RawMessageCallback& raw_message_callback) - : DevToolsProtocolClient(raw_message_callback) { +Client::Client(DevToolsProtocolDelegate* notifier) + : DevToolsProtocolClient(notifier) { } Client::~Client() { diff --git a/content/browser/devtools/protocol/input_handler.cc b/content/browser/devtools/protocol/input_handler.cc index 0b4bdcc..c0def4e 100644 --- a/content/browser/devtools/protocol/input_handler.cc +++ b/content/browser/devtools/protocol/input_handler.cc @@ -398,8 +398,8 @@ void InputHandler::SynthesizeRepeatingScroll( DevToolsCommandId command_id) { if (!interaction_marker_name.empty()) { // TODO(alexclarke): Can we move this elsewhere? It doesn't really fit here. - TRACE_EVENT_COPY_ASYNC_BEGIN0("benchmark", - interaction_marker_name.c_str(), command_id); + TRACE_EVENT_COPY_ASYNC_BEGIN0("benchmark", interaction_marker_name.c_str(), + command_id.call_id); } host_->QueueSyntheticGesture( @@ -417,8 +417,8 @@ void InputHandler::OnScrollFinished( DevToolsCommandId command_id, SyntheticGesture::Result result) { if (!interaction_marker_name.empty()) { - TRACE_EVENT_COPY_ASYNC_END0("benchmark", - interaction_marker_name.c_str(), command_id); + TRACE_EVENT_COPY_ASYNC_END0("benchmark", interaction_marker_name.c_str(), + command_id.call_id); } if (repeat_count > 0) { diff --git a/content/browser/devtools/protocol/tracing_handler.cc b/content/browser/devtools/protocol/tracing_handler.cc index 24890db..2fd8e4b 100644 --- a/content/browser/devtools/protocol/tracing_handler.cc +++ b/content/browser/devtools/protocol/tracing_handler.cc @@ -113,7 +113,7 @@ void TracingHandler::OnTraceDataCollected(const std::string& trace_fragment) { message.reserve(message.size() + trace_fragment.size() + messageSuffixSize); message += trace_fragment; message += "] } }"; - client_->SendRawMessage(message); + client_->SendRawNotification(message); } void TracingHandler::OnTraceComplete() { diff --git a/content/browser/devtools/render_frame_devtools_agent_host.cc b/content/browser/devtools/render_frame_devtools_agent_host.cc index 1280168..3b6a207 100644 --- a/content/browser/devtools/render_frame_devtools_agent_host.cc +++ b/content/browser/devtools/render_frame_devtools_agent_host.cc @@ -86,7 +86,9 @@ class RenderFrameDevToolsAgentHost::FrameHostHolder { void Attach(); void Reattach(FrameHostHolder* old); void Detach(); - void DispatchProtocolMessage(int call_id, const std::string& message); + void DispatchProtocolMessage(int session_id, + int call_id, + const std::string& message); void InspectElement(int x, int y); void ProcessChunkedMessageFromAgent(const DevToolsMessageChunk& chunk); void Suspend(); @@ -95,15 +97,17 @@ class RenderFrameDevToolsAgentHost::FrameHostHolder { private: void GrantPolicy(); void RevokePolicy(); - void SendMessageToClient(const std::string& message); + void SendMessageToClient(int session_id, const std::string& message); RenderFrameDevToolsAgentHost* agent_; RenderFrameHostImpl* host_; bool attached_; bool suspended_; DevToolsMessageChunkProcessor chunk_processor_; - std::vector<std::string> pending_messages_; - std::map<int, std::string> sent_messages_; + // <session_id, message> + std::vector<std::pair<int, std::string>> pending_messages_; + // <call_id> -> <session_id, message> + std::map<int, std::pair<int, std::string>> sent_messages_; }; RenderFrameDevToolsAgentHost::FrameHostHolder::FrameHostHolder( @@ -126,7 +130,7 @@ RenderFrameDevToolsAgentHost::FrameHostHolder::~FrameHostHolder() { void RenderFrameDevToolsAgentHost::FrameHostHolder::Attach() { host_->Send(new DevToolsAgentMsg_Attach( - host_->GetRoutingID(), agent_->GetId())); + host_->GetRoutingID(), agent_->GetId(), agent_->session_id())); GrantPolicy(); attached_ = true; } @@ -136,10 +140,13 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::Reattach( if (old) chunk_processor_.set_state_cookie(old->chunk_processor_.state_cookie()); host_->Send(new DevToolsAgentMsg_Reattach( - host_->GetRoutingID(), agent_->GetId(), chunk_processor_.state_cookie())); + host_->GetRoutingID(), agent_->GetId(), agent_->session_id(), + chunk_processor_.state_cookie())); if (old) { - for (const auto& pair : old->sent_messages_) - DispatchProtocolMessage(pair.first, pair.second); + for (const auto& pair : old->sent_messages_) { + DispatchProtocolMessage(pair.second.first, pair.first, + pair.second.second); + } } GrantPolicy(); attached_ = true; @@ -179,10 +186,12 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::RevokePolicy() { } } void RenderFrameDevToolsAgentHost::FrameHostHolder::DispatchProtocolMessage( - int call_id, const std::string& message) { + int session_id, + int call_id, + const std::string& message) { host_->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend( - host_->GetRoutingID(), message)); - sent_messages_[call_id] = message; + host_->GetRoutingID(), session_id, message)); + sent_messages_[call_id] = std::make_pair(session_id, message); } void RenderFrameDevToolsAgentHost::FrameHostHolder::InspectElement( @@ -199,12 +208,13 @@ RenderFrameDevToolsAgentHost::FrameHostHolder::ProcessChunkedMessageFromAgent( } void RenderFrameDevToolsAgentHost::FrameHostHolder::SendMessageToClient( + int session_id, const std::string& message) { sent_messages_.erase(chunk_processor_.last_call_id()); if (suspended_) - pending_messages_.push_back(message); + pending_messages_.push_back(std::make_pair(session_id, message)); else - agent_->SendMessageToClient(message); + agent_->SendMessageToClient(session_id, message); } void RenderFrameDevToolsAgentHost::FrameHostHolder::Suspend() { @@ -213,9 +223,9 @@ void RenderFrameDevToolsAgentHost::FrameHostHolder::Suspend() { void RenderFrameDevToolsAgentHost::FrameHostHolder::Resume() { suspended_ = false; - for (const std::string& message : pending_messages_) - agent_->SendMessageToClient(message); - std::vector<std::string> empty; + for (const auto& pair : pending_messages_) + agent_->SendMessageToClient(pair.first, pair.second); + std::vector<std::pair<int, std::string>> empty; pending_messages_.swap(empty); } @@ -326,10 +336,7 @@ RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost( GetIOContext())), emulation_handler_(nullptr), frame_trace_recorder_(nullptr), - protocol_handler_(new DevToolsProtocolHandler( - this, - base::Bind(&RenderFrameDevToolsAgentHost::SendMessageToClient, - base::Unretained(this)))), + protocol_handler_(new DevToolsProtocolHandler(this)), current_frame_crashed_(false) { DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher(); dispatcher->SetDOMHandler(dom_handler_.get()); @@ -424,13 +431,13 @@ void RenderFrameDevToolsAgentHost::Detach() { bool RenderFrameDevToolsAgentHost::DispatchProtocolMessage( const std::string& message) { int call_id = 0; - if (protocol_handler_->HandleOptionalMessage(message, &call_id)) + if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id)) return true; if (current_) - current_->DispatchProtocolMessage(call_id, message); + current_->DispatchProtocolMessage(session_id(), call_id, message); if (pending_) - pending_->DispatchProtocolMessage(call_id, message); + pending_->DispatchProtocolMessage(session_id(), call_id, message); return true; } diff --git a/content/browser/devtools/worker_devtools_agent_host.cc b/content/browser/devtools/worker_devtools_agent_host.cc index 32cd668..d7be60a 100644 --- a/content/browser/devtools/worker_devtools_agent_host.cc +++ b/content/browser/devtools/worker_devtools_agent_host.cc @@ -21,7 +21,8 @@ void WorkerDevToolsAgentHost::Attach() { AttachToWorker(); } if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) - host->Send(new DevToolsAgentMsg_Attach(worker_id_.second, GetId())); + host->Send( + new DevToolsAgentMsg_Attach(worker_id_.second, GetId(), session_id())); OnAttachedStateChanged(true); DevToolsAgentHostImpl::NotifyCallbacks(this, true); } @@ -45,12 +46,12 @@ bool WorkerDevToolsAgentHost::DispatchProtocolMessage( return true; int call_id; - if (protocol_handler_->HandleOptionalMessage(message, &call_id)) + if (protocol_handler_->HandleOptionalMessage(session_id(), message, &call_id)) return true; if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) { host->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend( - worker_id_.second, message)); + worker_id_.second, session_id(), message)); } return true; } @@ -83,7 +84,8 @@ void WorkerDevToolsAgentHost::WorkerReadyForInspection() { AttachToWorker(); if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first)) { host->Send(new DevToolsAgentMsg_Reattach( - worker_id_.second, GetId(), chunk_processor_.state_cookie())); + worker_id_.second, GetId(), session_id(), + chunk_processor_.state_cookie())); } OnAttachedStateChanged(true); } @@ -101,10 +103,7 @@ void WorkerDevToolsAgentHost::WorkerDestroyed() { if (state_ == WORKER_INSPECTED) { DCHECK(IsAttached()); // Client host is debugging this worker agent host. - base::Callback<void(const std::string&)> raw_message_callback( - base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient, - base::Unretained(this))); - devtools::inspector::Client inspector(raw_message_callback); + devtools::inspector::Client inspector(this); inspector.TargetCrashed( devtools::inspector::TargetCrashedParams::Create()); DetachFromWorker(); @@ -117,15 +116,10 @@ bool WorkerDevToolsAgentHost::IsTerminated() { return state_ == WORKER_TERMINATED; } -WorkerDevToolsAgentHost::WorkerDevToolsAgentHost( - WorkerId worker_id) - : protocol_handler_(new DevToolsProtocolHandler( - this, - base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient, - base::Unretained(this)))), - chunk_processor_( - base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient, - base::Unretained(this))), +WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(WorkerId worker_id) + : protocol_handler_(new DevToolsProtocolHandler(this)), + chunk_processor_(base::Bind(&WorkerDevToolsAgentHost::SendMessageToClient, + base::Unretained(this))), state_(WORKER_UNINSPECTED), worker_id_(worker_id) { WorkerCreated(); |