diff options
Diffstat (limited to 'content/browser/devtools/protocol')
21 files changed, 567 insertions, 276 deletions
diff --git a/content/browser/devtools/protocol/devtools_protocol_browsertest.cc b/content/browser/devtools/protocol/devtools_protocol_browsertest.cc new file mode 100644 index 0000000..31ccdbe --- /dev/null +++ b/content/browser/devtools/protocol/devtools_protocol_browsertest.cc @@ -0,0 +1,152 @@ +// Copyright 2013 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. + +#include "base/base64.h" +#include "base/command_line.h" +#include "base/json/json_reader.h" +#include "base/json/json_writer.h" +#include "content/public/browser/devtools_agent_host.h" +#include "content/public/browser/web_contents.h" +#include "content/public/test/browser_test_utils.h" +#include "content/public/test/content_browser_test.h" +#include "content/shell/browser/shell.h" +#include "third_party/skia/include/core/SkBitmap.h" +#include "ui/compositor/compositor_switches.h" +#include "ui/gfx/codec/png_codec.h" + +namespace content { + +namespace { + +const char kIdParam[] = "id"; +const char kMethodParam[] = "method"; +const char kParamsParam[] = "params"; + +} + +class DevToolsProtocolTest : public ContentBrowserTest, + public DevToolsAgentHostClient { + protected: + void SendCommand(const std::string& method, + scoped_ptr<base::DictionaryValue> params) { + base::DictionaryValue command; + command.SetInteger(kIdParam, 1); + command.SetString(kMethodParam, method); + if (params) + command.Set(kParamsParam, params.release()); + + std::string json_command; + base::JSONWriter::Write(&command, &json_command); + agent_host_->DispatchProtocolMessage(json_command); + base::MessageLoop::current()->Run(); + } + + bool HasValue(const std::string& path) { + base::Value* value = 0; + return result_->Get(path, &value); + } + + bool HasListItem(const std::string& path_to_list, + const std::string& name, + const std::string& value) { + base::ListValue* list; + if (!result_->GetList(path_to_list, &list)) + return false; + + for (size_t i = 0; i != list->GetSize(); i++) { + base::DictionaryValue* item; + if (!list->GetDictionary(i, &item)) + return false; + std::string id; + if (!item->GetString(name, &id)) + return false; + if (id == value) + return true; + } + return false; + } + + scoped_ptr<base::DictionaryValue> result_; + scoped_refptr<DevToolsAgentHost> agent_host_; + + private: + void SetUpOnMainThread() override { + agent_host_ = DevToolsAgentHost::GetOrCreateFor(shell()->web_contents()); + agent_host_->AttachClient(this); + } + + void TearDownOnMainThread() override { + agent_host_->DetachClient(); + agent_host_ = NULL; + } + + void DispatchProtocolMessage(DevToolsAgentHost* agent_host, + const std::string& message) override { + scoped_ptr<base::DictionaryValue> root( + static_cast<base::DictionaryValue*>(base::JSONReader::Read(message))); + base::DictionaryValue* result; + EXPECT_TRUE(root->GetDictionary("result", &result)); + result_.reset(result->DeepCopy()); + base::MessageLoop::current()->QuitNow(); + } + + void AgentHostClosed(DevToolsAgentHost* agent_host, bool replaced) override { + EXPECT_TRUE(false); + } +}; + +IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, QueryUsageAndQuota) { + scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue); + params->SetString("securityOrigin", "http://example.com"); + SendCommand("Page.queryUsageAndQuota", params.Pass()); + + EXPECT_TRUE(HasValue("quota.persistent")); + EXPECT_TRUE(HasValue("quota.temporary")); + EXPECT_TRUE(HasListItem("usage.temporary", "id", "appcache")); + EXPECT_TRUE(HasListItem("usage.temporary", "id", "database")); + EXPECT_TRUE(HasListItem("usage.temporary", "id", "indexeddatabase")); + EXPECT_TRUE(HasListItem("usage.temporary", "id", "filesystem")); + EXPECT_TRUE(HasListItem("usage.persistent", "id", "filesystem")); +} + +class CaptureScreenshotTest : public DevToolsProtocolTest { + private: +#if !defined(OS_ANDROID) + void SetUpCommandLine(base::CommandLine* command_line) override { + command_line->AppendSwitch(switches::kEnablePixelOutputInTests); + } +#endif +}; + +// Does not link on Android +#if defined(OS_ANDROID) +#define MAYBE_CaptureScreenshot DISABLED_CaptureScreenshot +#elif defined(OS_MACOSX) // Fails on 10.9. http://crbug.com/430620 +#define MAYBE_CaptureScreenshot DISABLED_CaptureScreenshot +#elif defined(MEMORY_SANITIZER) +// Also fails under MSAN. http://crbug.com/423583 +#define MAYBE_CaptureScreenshot DISABLED_CaptureScreenshot +#else +#define MAYBE_CaptureScreenshot CaptureScreenshot +#endif +IN_PROC_BROWSER_TEST_F(CaptureScreenshotTest, MAYBE_CaptureScreenshot) { + shell()->LoadURL(GURL("about:blank")); + EXPECT_TRUE(content::ExecuteScript( + shell()->web_contents()->GetRenderViewHost(), + "document.body.style.background = '#123456'")); + SendCommand("Page.captureScreenshot", nullptr); + std::string base64; + EXPECT_TRUE(result_->GetString("data", &base64)); + std::string png; + EXPECT_TRUE(base::Base64Decode(base64, &png)); + SkBitmap bitmap; + gfx::PNGCodec::Decode(reinterpret_cast<const unsigned char*>(png.data()), + png.size(), &bitmap); + SkColor color(bitmap.getColor(0, 0)); + EXPECT_TRUE(std::abs(0x12-(int)SkColorGetR(color)) <= 1); + EXPECT_TRUE(std::abs(0x34-(int)SkColorGetG(color)) <= 1); + EXPECT_TRUE(std::abs(0x56-(int)SkColorGetB(color)) <= 1); +} + +} // namespace content diff --git a/content/browser/devtools/protocol/devtools_protocol_client.cc b/content/browser/devtools/protocol/devtools_protocol_client.cc index e959da9..28af8e5 100644 --- a/content/browser/devtools/protocol/devtools_protocol_client.cc +++ b/content/browser/devtools/protocol/devtools_protocol_client.cc @@ -4,8 +4,34 @@ #include "content/browser/devtools/protocol/devtools_protocol_client.h" +#include "base/json/json_writer.h" +#include "base/strings/stringprintf.h" + namespace content { +namespace { + +const char kIdParam[] = "id"; +const char kMethodParam[] = "method"; +const char kParamsParam[] = "params"; +const char kResultParam[] = "result"; +const char kErrorParam[] = "error"; +const char kErrorCodeParam[] = "code"; +const char kErrorMessageParam[] = "message"; + +// Special values. +const int kStatusOk = -1; +const int kStatusFallThrough = -2; +// JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object +const int kStatusInvalidParams = -32602; +const int kStatusInternalError = -32603; +const int kStatusServerError = -32000; + +} // namespace + +// static +const DevToolsCommandId DevToolsProtocolClient::kNoId = -1; + DevToolsProtocolClient::DevToolsProtocolClient( const RawMessageCallback& raw_message_callback) : raw_message_callback_(raw_message_callback) { @@ -14,77 +40,83 @@ DevToolsProtocolClient::DevToolsProtocolClient( DevToolsProtocolClient::~DevToolsProtocolClient() { } +void DevToolsProtocolClient::SendRawMessage(const std::string& message) { + raw_message_callback_.Run(message); +} + +void DevToolsProtocolClient::SendMessage(const base::DictionaryValue& message) { + std::string json_message; + base::JSONWriter::Write(&message, &json_message); + SendRawMessage(json_message); +} + void DevToolsProtocolClient::SendNotification( const std::string& method, scoped_ptr<base::DictionaryValue> params) { - scoped_refptr<DevToolsProtocol::Notification> notification = - new DevToolsProtocol::Notification(method, params.release()); - SendRawMessage(notification->Serialize()); -} + base::DictionaryValue notification; + notification.SetString(kMethodParam, method); + if (params) + notification.Set(kParamsParam, params.release()); -void DevToolsProtocolClient::SendAsyncResponse( - scoped_refptr<DevToolsProtocol::Response> response) { - SendRawMessage(response->Serialize()); + SendMessage(notification); } -void DevToolsProtocolClient::SendRawMessage(const std::string& message) { - raw_message_callback_.Run(message); -} +void DevToolsProtocolClient::SendSuccess( + DevToolsCommandId command_id, + scoped_ptr<base::DictionaryValue> params) { + base::DictionaryValue response; + response.SetInteger(kIdParam, command_id); -void DevToolsProtocolClient::SendInvalidParamsResponse( - scoped_refptr<DevToolsProtocol::Command> command, - const std::string& message) { - SendAsyncResponse(command->InvalidParamResponse(message)); -} + response.Set(kResultParam, + params ? params.release() : new base::DictionaryValue()); -void DevToolsProtocolClient::SendInternalErrorResponse( - scoped_refptr<DevToolsProtocol::Command> command, - const std::string& message) { - SendAsyncResponse(command->InternalErrorResponse(message)); + SendMessage(response); } -void DevToolsProtocolClient::SendServerErrorResponse( - scoped_refptr<DevToolsProtocol::Command> command, - const std::string& message) { - SendAsyncResponse(command->ServerErrorResponse(message)); +bool DevToolsProtocolClient::SendError(DevToolsCommandId command_id, + const Response& response) { + if (response.status() == kStatusOk || + response.status() == kStatusFallThrough) { + return false; + } + base::DictionaryValue dict; + if (command_id != kNoId) + dict.SetInteger(kIdParam, command_id); + + base::DictionaryValue* error_object = new base::DictionaryValue(); + error_object->SetInteger(kErrorCodeParam, response.status()); + if (!response.message().empty()) + error_object->SetString(kErrorMessageParam, response.message()); + + dict.Set(kErrorParam, error_object); + SendMessage(dict); + return true; } typedef DevToolsProtocolClient::Response Response; Response Response::FallThrough() { - Response response; - response.status_ = ResponseStatus::RESPONSE_STATUS_FALLTHROUGH; - return response; + return Response(kStatusFallThrough); } Response Response::OK() { - Response response; - response.status_ = ResponseStatus::RESPONSE_STATUS_OK; - return response; + return Response(kStatusOk); } -Response Response::InvalidParams(const std::string& message) { - Response response; - response.status_ = ResponseStatus::RESPONSE_STATUS_INVALID_PARAMS; - response.message_ = message; - return response; +Response Response::InvalidParams(const std::string& param) { + return Response(kStatusInvalidParams, + base::StringPrintf("Missing or invalid '%s' parameter", param.c_str())); } Response Response::InternalError(const std::string& message) { - Response response; - response.status_ = ResponseStatus::RESPONSE_STATUS_INTERNAL_ERROR; - response.message_ = message; - return response; + return Response(kStatusInternalError, message); } Response Response::ServerError(const std::string& message) { - Response response; - response.status_ = ResponseStatus::RESPONSE_STATUS_SERVER_ERROR; - response.message_ = message; - return response; + return Response(kStatusServerError, message); } -DevToolsProtocolClient::ResponseStatus Response::status() const { +int Response::status() const { return status_; } @@ -92,7 +124,17 @@ const std::string& Response::message() const { return message_; } -Response::Response() { +bool Response::IsFallThrough() const { + return status_ == kStatusFallThrough; +} + +Response::Response(int status) + : status_(status) { +} + +Response::Response(int status, const std::string& message) + : status_(status), + message_(message) { } } // namespace content diff --git a/content/browser/devtools/protocol/devtools_protocol_client.h b/content/browser/devtools/protocol/devtools_protocol_client.h index 19f8fdf..9297187 100644 --- a/content/browser/devtools/protocol/devtools_protocol_client.h +++ b/content/browser/devtools/protocol/devtools_protocol_client.h @@ -5,68 +5,67 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_CLIENT_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_CLIENT_H_ -#include "content/browser/devtools/devtools_protocol.h" +#include "base/callback.h" +#include "base/values.h" namespace content { +using DevToolsCommandId = int; +class DevToolsProtocolHandler; +class DevToolsProtocolDispatcher; + class DevToolsProtocolClient { public: typedef base::Callback<void(const std::string& message)> RawMessageCallback; - - enum ResponseStatus { - RESPONSE_STATUS_FALLTHROUGH, - RESPONSE_STATUS_OK, - RESPONSE_STATUS_INVALID_PARAMS, - RESPONSE_STATUS_INTERNAL_ERROR, - RESPONSE_STATUS_SERVER_ERROR, - }; + static const DevToolsCommandId kNoId; struct Response { public: static Response FallThrough(); static Response OK(); - static Response InvalidParams(const std::string& message); + static Response InvalidParams(const std::string& param); static Response InternalError(const std::string& message); static Response ServerError(const std::string& message); - ResponseStatus status() const; + int status() const; const std::string& message() const; + bool IsFallThrough() const; + private: - Response(); + friend class DevToolsProtocolHandler; + + explicit Response(int status); + Response(int status, const std::string& message); - ResponseStatus status_; + int status_; std::string message_; }; - void SendInvalidParamsResponse( - scoped_refptr<DevToolsProtocol::Command> command, - const std::string& message); - void SendInternalErrorResponse( - scoped_refptr<DevToolsProtocol::Command> command, - const std::string& message); - void SendServerErrorResponse( - scoped_refptr<DevToolsProtocol::Command> command, - const std::string& message); + bool SendError(DevToolsCommandId command_id, + const Response& response); // Sends message to client, the caller is presumed to properly // format the message. Do not use unless you must. void SendRawMessage(const std::string& message); - protected: - DevToolsProtocolClient(const RawMessageCallback& raw_message_callback); - + explicit DevToolsProtocolClient( + const RawMessageCallback& raw_message_callback); virtual ~DevToolsProtocolClient(); + protected: + void SendSuccess(DevToolsCommandId command_id, + scoped_ptr<base::DictionaryValue> params); void SendNotification(const std::string& method, scoped_ptr<base::DictionaryValue> params); - void SendAsyncResponse(scoped_refptr<DevToolsProtocol::Response> response); - private: - RawMessageCallback raw_message_callback_; + friend class DevToolsProtocolDispatcher; + + void SendMessage(const base::DictionaryValue& message); + RawMessageCallback raw_message_callback_; DISALLOW_COPY_AND_ASSIGN(DevToolsProtocolClient); }; diff --git a/content/browser/devtools/protocol/devtools_protocol_handler.cc b/content/browser/devtools/protocol/devtools_protocol_handler.cc new file mode 100644 index 0000000..c9a38f2 --- /dev/null +++ b/content/browser/devtools/protocol/devtools_protocol_handler.cc @@ -0,0 +1,94 @@ +// Copyright 2014 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. + +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" + +#include "base/bind.h" +#include "base/json/json_reader.h" + +namespace content { + +namespace { + +const char kIdParam[] = "id"; +const char kMethodParam[] = "method"; +const char kParamsParam[] = "params"; + +// JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object +const int kStatusParseError = -32700; +const int kStatusInvalidRequest = -32600; +const int kStatusNoSuchMethod = -32601; + +scoped_ptr<base::DictionaryValue> TakeDictionary(base::DictionaryValue* dict, + const std::string& key) { + scoped_ptr<base::Value> value; + dict->Remove(key, &value); + base::DictionaryValue* result = nullptr; + if (value) + value.release()->GetAsDictionary(&result); + return make_scoped_ptr(result); +} + +} // namespace + +DevToolsProtocolHandler::DevToolsProtocolHandler(bool handle_generic_errors, + const Notifier& notifier) + : client_(notifier), + handle_generic_errors_(handle_generic_errors), + dispatcher_(notifier) { +} + +DevToolsProtocolHandler::~DevToolsProtocolHandler() { +} + +scoped_ptr<base::DictionaryValue> +DevToolsProtocolHandler::ParseCommand(const std::string& message) { + std::string parse_error; + scoped_ptr<base::Value> value( + base::JSONReader::ReadAndReturnError(message, 0, nullptr, &parse_error)); + + if (!value) { + if (handle_generic_errors_) { + client_.SendError(DevToolsProtocolClient::kNoId, + Response(kStatusParseError, parse_error)); + } + return nullptr; + } + if (!value->IsType(base::Value::TYPE_DICTIONARY)) { + if (handle_generic_errors_) { + client_.SendError(DevToolsProtocolClient::kNoId, + Response(kStatusInvalidRequest, "Not a dictionary")); + } + return nullptr; + } + return make_scoped_ptr(static_cast<base::DictionaryValue*>(value.release())); +} + +bool DevToolsProtocolHandler::HandleCommand( + scoped_ptr<base::DictionaryValue> command) { + int id = DevToolsProtocolClient::kNoId; + std::string method; + bool ok = command->GetInteger(kIdParam, &id) && id >= 0; + ok = ok && command->GetString(kMethodParam, &method); + if (!ok) { + if (handle_generic_errors_) { + client_.SendError(id, Response(kStatusInvalidRequest, "Invalid request")); + return true; + } + return false; + } + DevToolsProtocolDispatcher::CommandHandler command_handler( + dispatcher_.FindCommandHandler(method)); + if (command_handler.is_null()) { + if (handle_generic_errors_) { + client_.SendError(id, Response(kStatusNoSuchMethod, "No such method")); + return true; + } + return false; + + } + return command_handler.Run(id, TakeDictionary(command.get(), kParamsParam)); +} + +} // namespace content diff --git a/content/browser/devtools/protocol/devtools_protocol_handler.h b/content/browser/devtools/protocol/devtools_protocol_handler.h new file mode 100644 index 0000000..e0be9d4 --- /dev/null +++ b/content/browser/devtools/protocol/devtools_protocol_handler.h @@ -0,0 +1,34 @@ +// Copyright 2014 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_HANDLER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_H_ + +#include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h" + +namespace content { + +class DevToolsProtocolHandler { + public: + using Response = DevToolsProtocolClient::Response; + using Notifier = base::Callback<void(const std::string& message)>; + + DevToolsProtocolHandler(bool handle_generic_errors, + const Notifier& notifier); + virtual ~DevToolsProtocolHandler(); + + scoped_ptr<base::DictionaryValue> ParseCommand(const std::string& message); + bool HandleCommand(scoped_ptr<base::DictionaryValue> command); + + DevToolsProtocolDispatcher* dispatcher() { return &dispatcher_; } + + private: + DevToolsProtocolClient client_; + bool handle_generic_errors_; + DevToolsProtocolDispatcher dispatcher_; +}; + +} // namespace content + +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_H_ diff --git a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py index e35f2f9..d3dd9c1 100755 --- a/content/browser/devtools/protocol/devtools_protocol_handler_generator.py +++ b/content/browser/devtools/protocol/devtools_protocol_handler_generator.py @@ -26,15 +26,14 @@ header = """\ template_h = string.Template(header + """\ -#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_ -#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_ +#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_ +#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_ -#include "content/browser/devtools/devtools_protocol.h" #include "content/browser/devtools/protocol/devtools_protocol_client.h" namespace content { -class DevToolsProtocolHandlerImpl; +class DevToolsProtocolDispatcher; namespace devtools { @@ -73,25 +72,34 @@ ${types}\ } // namespace devtools -class DevToolsProtocolHandlerImpl : public DevToolsProtocol::Handler { +class DevToolsProtocolDispatcher { public: - typedef DevToolsProtocolClient::Response Response; - typedef DevToolsProtocolClient::ResponseStatus ResponseStatus; + using Notifier = DevToolsProtocolClient::RawMessageCallback; + using CommandHandler = + base::Callback<bool(int, scoped_ptr<base::DictionaryValue>)>; - DevToolsProtocolHandlerImpl(); - virtual ~DevToolsProtocolHandlerImpl(); + explicit DevToolsProtocolDispatcher(const Notifier& notifier); + ~DevToolsProtocolDispatcher(); + + CommandHandler FindCommandHandler(const std::string& method); ${setters}\ private: + using Response = DevToolsProtocolClient::Response; + using CommandHandlers = std::map<std::string, CommandHandler>; + ${methods}\ + Notifier notifier_; + DevToolsProtocolClient client_; + CommandHandlers command_handlers_; ${fields}\ }; } // namespace content -#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_ +#endif // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_ """) tmpl_typedef = string.Template("""\ @@ -192,7 +200,7 @@ tmpl_client = string.Template("""\ namespace ${domain} { class Client : public DevToolsProtocolClient { public: - Client(const RawMessageCallback& raw_message_callback); + explicit Client(const RawMessageCallback& raw_message_callback); virtual ~Client(); ${methods}\ @@ -207,7 +215,7 @@ tmpl_event = string.Template("""\ tmpl_response = string.Template("""\ void Send${Command}Response( - scoped_refptr<DevToolsProtocol::Command> command, + DevToolsCommandId command_id, scoped_refptr<${Command}Response> params); """) @@ -217,9 +225,9 @@ tmpl_setter = string.Template("""\ """) tmpl_callback = string.Template("""\ - scoped_refptr<DevToolsProtocol::Response> - On${Domain}${Command}( - scoped_refptr<DevToolsProtocol::Command> command); + bool On${Domain}${Command}( + DevToolsCommandId command_id, + scoped_ptr<base::DictionaryValue> params); """) tmpl_field = string.Template("""\ @@ -228,7 +236,7 @@ tmpl_field = string.Template("""\ template_cc = string.Template(header + """\ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" #include "base/bind.h" #include "base/strings/string_number_conversions.h" @@ -236,42 +244,22 @@ ${includes}\ namespace content { -DevToolsProtocolHandlerImpl::DevToolsProtocolHandlerImpl() - : ${fields_init} { +DevToolsProtocolDispatcher::DevToolsProtocolDispatcher( + const Notifier& notifier) + : notifier_(notifier), + client_(notifier), + ${fields_init} { } -DevToolsProtocolHandlerImpl::~DevToolsProtocolHandlerImpl() { +DevToolsProtocolDispatcher::~DevToolsProtocolDispatcher() { } -namespace { - -typedef DevToolsProtocolClient::ResponseStatus ResponseStatus; - -bool CreateCommonResponse( - scoped_refptr<DevToolsProtocol::Command> command, - const DevToolsProtocolClient::Response& response, - scoped_refptr<DevToolsProtocol::Response>* protocol_response) { - switch (response.status()) { - case ResponseStatus::RESPONSE_STATUS_FALLTHROUGH: - *protocol_response = nullptr; - break; - case ResponseStatus::RESPONSE_STATUS_OK: - return false; - case ResponseStatus::RESPONSE_STATUS_INVALID_PARAMS: - *protocol_response = command->InvalidParamResponse(response.message()); - break; - case ResponseStatus::RESPONSE_STATUS_INTERNAL_ERROR: - *protocol_response = command->InternalErrorResponse(response.message()); - break; - case ResponseStatus::RESPONSE_STATUS_SERVER_ERROR: - *protocol_response = command->ServerErrorResponse(response.message()); - break; - } - return true; +DevToolsProtocolDispatcher::CommandHandler +DevToolsProtocolDispatcher::FindCommandHandler(const std::string& method) { + CommandHandlers::iterator it = command_handlers_.find(method); + return it == command_handlers_.end() ? CommandHandler() : it->second; } -} // namespace - ${methods}\ namespace devtools { @@ -306,7 +294,7 @@ tmpl_include = string.Template("""\ tmpl_field_init = string.Template("${domain}_handler_(nullptr)") tmpl_setter_impl = string.Template("""\ -void DevToolsProtocolHandlerImpl::Set${Domain}Handler( +void DevToolsProtocolDispatcher::Set${Domain}Handler( devtools::${domain}::${Domain}Handler* ${domain}_handler) { DCHECK(!${domain}_handler_); ${domain}_handler_ = ${domain}_handler; @@ -315,32 +303,32 @@ ${initializations}\ """) tmpl_register = string.Template("""\ - RegisterCommandHandler( - "${Domain}.${command}", + command_handlers_["${Domain}.${command}"] = base::Bind( - &DevToolsProtocolHandlerImpl::On${Domain}${Command}, - base::Unretained(this))); + &DevToolsProtocolDispatcher::On${Domain}${Command}, + base::Unretained(this)); """) tmpl_init_client = string.Template("""\ ${domain}_handler_->SetClient(make_scoped_ptr( - new devtools::${domain}::Client( - base::Bind(&DevToolsProtocolHandlerImpl::SendRawMessage, - base::Unretained(this))))); + new devtools::${domain}::Client(notifier_))); """) tmpl_callback_impl = string.Template("""\ -scoped_refptr<DevToolsProtocol::Response> -DevToolsProtocolHandlerImpl::On${Domain}${Command}( - scoped_refptr<DevToolsProtocol::Command> command) { +bool DevToolsProtocolDispatcher::On${Domain}${Command}( + DevToolsCommandId command_id, + scoped_ptr<base::DictionaryValue> params) { ${prep}\ Response response = ${domain}_handler_->${Command}(${args}); - scoped_refptr<DevToolsProtocol::Response> protocol_response; - if (CreateCommonResponse(command, response, &protocol_response)) - return protocol_response; - base::DictionaryValue* result = new base::DictionaryValue(); + scoped_ptr<base::DictionaryValue> protocol_response; + if (client_.SendError(command_id, response)) + return true; + if (response.IsFallThrough()) + return false; + scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue()); ${wrap}\ - return command->SuccessResponse(result); + client_.SendSuccess(command_id, result.Pass()); + return true; } """) @@ -349,34 +337,39 @@ tmpl_wrap = string.Template("""\ """) tmpl_callback_async_impl = string.Template("""\ -scoped_refptr<DevToolsProtocol::Response> -DevToolsProtocolHandlerImpl::On${Domain}${Command}( - scoped_refptr<DevToolsProtocol::Command> command) { +bool DevToolsProtocolDispatcher::On${Domain}${Command}( + DevToolsCommandId command_id, + scoped_ptr<base::DictionaryValue> params) { ${prep}\ - return ${domain}_handler_->${Command}(${args}); + Response response = ${domain}_handler_->${Command}(${args}); + if (client_.SendError(command_id, response)) + return true; + return !response.IsFallThrough(); } """) -params_prep = """\ - base::DictionaryValue* params = command->params(); -""" - tmpl_prep_req = string.Template("""\ ${param_type} in_${param}${init}; - if (!params || !params->Get${Type}("${proto_param}", &in_${param})) - return command->InvalidParamResponse("${proto_param}"); + if (!params || !params->Get${Type}("${proto_param}", &in_${param})) { + client_.SendError(command_id, Response::InvalidParams("${proto_param}")); + return true; + } """) tmpl_prep_req_list = string.Template("""\ base::ListValue* list_${param} = nullptr; - if (!params || !params->GetList("${proto_param}", &list_${param})) - return command->InvalidParamResponse("${proto_param}"); + if (!params || !params->GetList("${proto_param}", &list_${param})) { + client_.SendError(command_id, Response::InvalidParams("${proto_param}")); + return true; + } std::vector<${item_type}> in_${param}; for (base::ListValue::const_iterator it = list_${param}->begin(); it != list_${param}->end(); ++it) { ${item_type} item${item_init}; - if (!(*it)->GetAs${ItemType}(&item)) - return command->InvalidParamResponse("${proto_param}"); + if (!(*it)->GetAs${ItemType}(&item)) { + client_.SendError(command_id, Response::InvalidParams("${proto_param}")); + return true; + } in_${param}.push_back(item); } """) @@ -422,9 +415,9 @@ void Client::${Command}( tmpl_response_impl = string.Template("""\ void Client::Send${Command}Response( - scoped_refptr<DevToolsProtocol::Command> command, + DevToolsCommandId command_id, scoped_refptr<${Command}Response> params) { - SendAsyncResponse(command->SuccessResponse(params->ToValue().release())); + SendSuccess(command_id, params->ToValue().Pass()); } """) @@ -641,8 +634,6 @@ for json_domain in all_domains: param_map["proto_param"] = json_param["name"] param_map["param"] = Uncamelcase(json_param["name"]) ResolveType(json_param, param_map) - if len(prep) == 0: - prep.append(params_prep) if json_param.get("optional"): if param_map["Type"] in ["List", "Dictionary"]: # TODO(vkuzkokov) Implement transformation of base::ListValue @@ -665,7 +656,7 @@ for json_domain in all_domains: # TODO(vkuzkokov) Pass async callback instance similar to how # InspectorBackendDispatcher does it. This, however, can work # only if Blink and Chrome are in the same repo. - args.append("command") + args.insert(0, "command_id") handler_method_impls.append( tmpl_callback_async_impl.substitute(command_map, prep = "".join(prep), diff --git a/content/browser/devtools/protocol/dom_handler.h b/content/browser/devtools/protocol/dom_handler.h index d2b20e2..206bb7a 100644 --- a/content/browser/devtools/protocol/dom_handler.h +++ b/content/browser/devtools/protocol/dom_handler.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DOM_HANDLER_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DOM_HANDLER_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" namespace content { diff --git a/content/browser/devtools/protocol/input_handler.h b/content/browser/devtools/protocol/input_handler.h index 1a85b2a..edb7183 100644 --- a/content/browser/devtools/protocol/input_handler.h +++ b/content/browser/devtools/protocol/input_handler.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INPUT_HANDLER_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INPUT_HANDLER_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" namespace content { diff --git a/content/browser/devtools/protocol/inspector_handler.h b/content/browser/devtools/protocol/inspector_handler.h index 8c215e0..4045e29 100644 --- a/content/browser/devtools/protocol/inspector_handler.h +++ b/content/browser/devtools/protocol/inspector_handler.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INSPECTOR_HANDLER_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_INSPECTOR_HANDLER_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" namespace content { namespace devtools { diff --git a/content/browser/devtools/protocol/network_handler.h b/content/browser/devtools/protocol/network_handler.h index c045a86..9e811d3 100644 --- a/content/browser/devtools/protocol/network_handler.h +++ b/content/browser/devtools/protocol/network_handler.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_NETWORK_HANDLER_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_NETWORK_HANDLER_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" namespace content { diff --git a/content/browser/devtools/protocol/page_handler.cc b/content/browser/devtools/protocol/page_handler.cc index fd456b4..ba8da7f 100644 --- a/content/browser/devtools/protocol/page_handler.cc +++ b/content/browser/devtools/protocol/page_handler.cc @@ -324,15 +324,14 @@ Response PageHandler::SetTouchEmulationEnabled( return Response::FallThrough(); } -scoped_refptr<DevToolsProtocol::Response> PageHandler::CaptureScreenshot( - scoped_refptr<DevToolsProtocol::Command> command) { +Response PageHandler::CaptureScreenshot(DevToolsCommandId command_id) { if (!host_ || !host_->GetView()) - return command->InternalErrorResponse("Could not connect to view"); + return Response::InternalError("Could not connect to view"); host_->GetSnapshotFromBrowser( base::Bind(&PageHandler::ScreenshotCaptured, - weak_factory_.GetWeakPtr(), command)); - return command->AsyncResponsePromise(); + weak_factory_.GetWeakPtr(), command_id)); + return Response::OK(); } Response PageHandler::CanScreencast(bool* result) { @@ -422,11 +421,10 @@ Response PageHandler::HandleJavaScriptDialog(bool accept, return Response::InternalError("Could not handle JavaScript dialog"); } -scoped_refptr<DevToolsProtocol::Response> PageHandler::QueryUsageAndQuota( - const std::string& security_origin, - scoped_refptr<DevToolsProtocol::Command> command) { +Response PageHandler::QueryUsageAndQuota(DevToolsCommandId command_id, + const std::string& security_origin) { if (!host_) - return command->InternalErrorResponse("Could not connect to view"); + return Response::InternalError("Could not connect to view"); scoped_refptr<storage::QuotaManager> quota_manager = host_->GetProcess()->GetStoragePartition()->GetQuotaManager(); @@ -439,9 +437,8 @@ scoped_refptr<DevToolsProtocol::Response> PageHandler::QueryUsageAndQuota( GURL(security_origin), base::Bind(&PageHandler::QueryUsageAndQuotaCompleted, weak_factory_.GetWeakPtr(), - command))); - - return command->AsyncResponsePromise(); + command_id))); + return Response::OK(); } Response PageHandler::SetColorPickerEnabled(bool enabled) { @@ -580,13 +577,12 @@ void PageHandler::ScreencastFrameEncoded( ->set_frame_number(++screencast_frame_sent_)); } -void PageHandler::ScreenshotCaptured( - scoped_refptr<DevToolsProtocol::Command> command, - const unsigned char* png_data, - size_t png_size) { +void PageHandler::ScreenshotCaptured(DevToolsCommandId command_id, + const unsigned char* png_data, + size_t png_size) { if (!png_data || !png_size) { - client_->SendInternalErrorResponse(command, - "Unable to capture screenshot"); + client_->SendError(command_id, + Response::InternalError("Unable to capture screenshot")); return; } @@ -595,7 +591,7 @@ void PageHandler::ScreenshotCaptured( base::StringPiece(reinterpret_cast<const char*>(png_data), png_size), &base_64_data); - client_->SendCaptureScreenshotResponse(command, + client_->SendCaptureScreenshotResponse(command_id, CaptureScreenshotResponse::Create()->set_data(base_64_data)); } @@ -606,9 +602,9 @@ void PageHandler::OnColorPicked(int r, int g, int b, int a) { } void PageHandler::QueryUsageAndQuotaCompleted( - scoped_refptr<DevToolsProtocol::Command> command, + DevToolsCommandId command_id, scoped_refptr<QueryUsageAndQuotaResponse> response_data) { - client_->SendQueryUsageAndQuotaResponse(command, response_data); + client_->SendQueryUsageAndQuotaResponse(command_id, response_data); } } // namespace page diff --git a/content/browser/devtools/protocol/page_handler.h b/content/browser/devtools/protocol/page_handler.h index 90dad5d..68e19ef 100644 --- a/content/browser/devtools/protocol/page_handler.h +++ b/content/browser/devtools/protocol/page_handler.h @@ -10,7 +10,7 @@ #include "base/memory/weak_ptr.h" #include "base/time/time.h" #include "cc/output/compositor_frame_metadata.h" -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" #include "content/public/browser/readback_types.h" class SkBitmap; @@ -64,8 +64,7 @@ class PageHandler { Response SetTouchEmulationEnabled(bool enabled, const std::string* configuration); - scoped_refptr<DevToolsProtocol::Response> CaptureScreenshot( - scoped_refptr<DevToolsProtocol::Command> command); + Response CaptureScreenshot(DevToolsCommandId command_id); Response CanScreencast(bool* result); Response CanEmulate(bool* result); @@ -79,9 +78,8 @@ class PageHandler { Response HandleJavaScriptDialog(bool accept, const std::string* prompt_text); - scoped_refptr<DevToolsProtocol::Response> QueryUsageAndQuota( - const std::string& security_origin, - scoped_refptr<DevToolsProtocol::Command> command); + Response QueryUsageAndQuota(DevToolsCommandId command_id, + const std::string& security_origin); Response SetColorPickerEnabled(bool enabled); @@ -98,14 +96,14 @@ class PageHandler { const std::string& data); void ScreenshotCaptured( - scoped_refptr<DevToolsProtocol::Command> command, + DevToolsCommandId command_id, const unsigned char* png_data, size_t png_size); void OnColorPicked(int r, int g, int b, int a); void QueryUsageAndQuotaCompleted( - scoped_refptr<DevToolsProtocol::Command> command, + DevToolsCommandId command_id, scoped_refptr<QueryUsageAndQuotaResponse> response); bool enabled_; diff --git a/content/browser/devtools/protocol/power_handler.h b/content/browser/devtools/protocol/power_handler.h index f0892c7..cd7e8da 100644 --- a/content/browser/devtools/protocol/power_handler.h +++ b/content/browser/devtools/protocol/power_handler.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_POWER_HANDLER_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_POWER_HANDLER_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" #include "content/browser/power_profiler/power_profiler_observer.h" namespace content { diff --git a/content/browser/devtools/protocol/system_info_handler.h b/content/browser/devtools/protocol/system_info_handler.h index ed5936e0..2e8366f 100644 --- a/content/browser/devtools/protocol/system_info_handler.h +++ b/content/browser/devtools/protocol/system_info_handler.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_SYSTEM_INFO_HANDLER_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_SYSTEM_INFO_HANDLER_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" namespace content { namespace devtools { diff --git a/content/browser/devtools/protocol/tethering_handler.cc b/content/browser/devtools/protocol/tethering_handler.cc index 5029f873..0f00194 100644 --- a/content/browser/devtools/protocol/tethering_handler.cc +++ b/content/browser/devtools/protocol/tethering_handler.cc @@ -26,6 +26,8 @@ const int kBufferSize = 16 * 1024; const int kMinTetheringPort = 1024; const int kMaxTetheringPort = 32767; +using Response = DevToolsProtocolClient::Response; + class SocketPump { public: SocketPump(DevToolsHttpHandlerDelegate* delegate, @@ -237,12 +239,12 @@ class TetheringHandler::TetheringImpl { DevToolsHttpHandlerDelegate* delegate); ~TetheringImpl(); - void Bind(scoped_refptr<DevToolsProtocol::Command> command, uint16 port); - void Unbind(scoped_refptr<DevToolsProtocol::Command> command, uint16 port); + void Bind(DevToolsCommandId command_id, uint16 port); + void Unbind(DevToolsCommandId command_id, uint16 port); void Accepted(uint16 port, const std::string& name); private: - void SendInternalError(scoped_refptr<DevToolsProtocol::Command> command, + void SendInternalError(DevToolsCommandId command_id, const std::string& message); base::WeakPtr<TetheringHandler> handler_; @@ -265,9 +267,9 @@ TetheringHandler::TetheringImpl::~TetheringImpl() { } void TetheringHandler::TetheringImpl::Bind( - scoped_refptr<DevToolsProtocol::Command> command, uint16 port) { + DevToolsCommandId command_id, uint16 port) { if (bound_sockets_.find(port) != bound_sockets_.end()) { - SendInternalError(command, "Port already bound"); + SendInternalError(command_id, "Port already bound"); return; } @@ -275,7 +277,7 @@ void TetheringHandler::TetheringImpl::Bind( &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this)); scoped_ptr<BoundSocket> bound_socket(new BoundSocket(callback, delegate_)); if (!bound_socket->Listen(port)) { - SendInternalError(command, "Could not bind port"); + SendInternalError(command_id, "Could not bind port"); return; } @@ -283,15 +285,15 @@ void TetheringHandler::TetheringImpl::Bind( BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, - base::Bind(&TetheringHandler::SendBindSuccess, handler_, command)); + base::Bind(&TetheringHandler::SendBindSuccess, handler_, command_id)); } void TetheringHandler::TetheringImpl::Unbind( - scoped_refptr<DevToolsProtocol::Command> command, uint16 port) { + DevToolsCommandId command_id, uint16 port) { BoundSockets::iterator it = bound_sockets_.find(port); if (it == bound_sockets_.end()) { - SendInternalError(command, "Port is not bound"); + SendInternalError(command_id, "Port is not bound"); return; } @@ -300,7 +302,7 @@ void TetheringHandler::TetheringImpl::Unbind( BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, - base::Bind(&TetheringHandler::SendUnbindSuccess, handler_, command)); + base::Bind(&TetheringHandler::SendUnbindSuccess, handler_, command_id)); } void TetheringHandler::TetheringImpl::Accepted( @@ -312,13 +314,13 @@ void TetheringHandler::TetheringImpl::Accepted( } void TetheringHandler::TetheringImpl::SendInternalError( - scoped_refptr<DevToolsProtocol::Command> command, + DevToolsCommandId command_id, const std::string& message) { BrowserThread::PostTask( BrowserThread::UI, FROM_HERE, base::Bind(&TetheringHandler::SendInternalError, handler_, - command, message)); + command_id, message)); } @@ -362,51 +364,44 @@ bool TetheringHandler::Activate() { return true; } -scoped_refptr<DevToolsProtocol::Response> TetheringHandler::Bind( - uint16 port, scoped_refptr<DevToolsProtocol::Command> command) { +Response TetheringHandler::Bind(DevToolsCommandId command_id, int port) { if (port < kMinTetheringPort || port > kMaxTetheringPort) - return command->InvalidParamResponse("port"); + return Response::InvalidParams("port"); + + if (!Activate()) + return Response::ServerError("Tethering is used by another connection"); - if (!Activate()) { - return command->ServerErrorResponse( - "Tethering is used by another connection"); - } DCHECK(impl_); message_loop_proxy_->PostTask( FROM_HERE, base::Bind(&TetheringImpl::Bind, base::Unretained(impl_), - command, port)); - return command->AsyncResponsePromise(); + command_id, port)); + return Response::OK(); } -scoped_refptr<DevToolsProtocol::Response> TetheringHandler::Unbind( - uint16 port, scoped_refptr<DevToolsProtocol::Command> command) { - if (!Activate()) { - return command->ServerErrorResponse( - "Tethering is used by another connection"); - } +Response TetheringHandler::Unbind(DevToolsCommandId command_id, int port) { + if (!Activate()) + return Response::ServerError("Tethering is used by another connection"); + DCHECK(impl_); message_loop_proxy_->PostTask( FROM_HERE, base::Bind(&TetheringImpl::Unbind, base::Unretained(impl_), - command, port)); - return command->AsyncResponsePromise(); + command_id, port)); + return Response::OK(); } -void TetheringHandler::SendBindSuccess( - scoped_refptr<DevToolsProtocol::Command> command) { - client_->SendBindResponse(command, BindResponse::Create()); +void TetheringHandler::SendBindSuccess(DevToolsCommandId command_id) { + client_->SendBindResponse(command_id, BindResponse::Create()); } -void TetheringHandler::SendUnbindSuccess( - scoped_refptr<DevToolsProtocol::Command> command) { - client_->SendUnbindResponse(command, UnbindResponse::Create()); +void TetheringHandler::SendUnbindSuccess(DevToolsCommandId command_id) { + client_->SendUnbindResponse(command_id, UnbindResponse::Create()); } -void TetheringHandler::SendInternalError( - scoped_refptr<DevToolsProtocol::Command> command, - const std::string& message) { - client_->SendInternalErrorResponse(command, message); +void TetheringHandler::SendInternalError(DevToolsCommandId command_id, + const std::string& message) { + client_->SendError(command_id, Response::InternalError(message)); } } // namespace tethering diff --git a/content/browser/devtools/protocol/tethering_handler.h b/content/browser/devtools/protocol/tethering_handler.h index 89467c9..a98da1e 100644 --- a/content/browser/devtools/protocol/tethering_handler.h +++ b/content/browser/devtools/protocol/tethering_handler.h @@ -7,7 +7,7 @@ #include "base/memory/weak_ptr.h" #include "base/message_loop/message_loop_proxy.h" -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" namespace content { @@ -19,16 +19,16 @@ namespace tethering { // This class implements reversed tethering handler. class TetheringHandler { public: + using Response = DevToolsProtocolClient::Response; + TetheringHandler(DevToolsHttpHandlerDelegate* delegate, scoped_refptr<base::MessageLoopProxy> message_loop_proxy); ~TetheringHandler(); void SetClient(scoped_ptr<Client> client); - scoped_refptr<DevToolsProtocol::Response> Bind( - uint16 port, scoped_refptr<DevToolsProtocol::Command> command); - scoped_refptr<DevToolsProtocol::Response> Unbind( - uint16 port, scoped_refptr<DevToolsProtocol::Command> command); + Response Bind(DevToolsCommandId command_id, int port); + Response Unbind(DevToolsCommandId command_id, int port); private: class TetheringImpl; @@ -36,9 +36,9 @@ class TetheringHandler { void Accepted(uint16 port, const std::string& name); bool Activate(); - void SendBindSuccess(scoped_refptr<DevToolsProtocol::Command> command); - void SendUnbindSuccess(scoped_refptr<DevToolsProtocol::Command> command); - void SendInternalError(scoped_refptr<DevToolsProtocol::Command> command, + void SendBindSuccess(DevToolsCommandId command_id); + void SendUnbindSuccess(DevToolsCommandId command_id); + void SendInternalError(DevToolsCommandId command_id, const std::string& message); scoped_ptr<Client> client_; diff --git a/content/browser/devtools/protocol/tracing_handler.cc b/content/browser/devtools/protocol/tracing_handler.cc index 29d1641..74446ca 100644 --- a/content/browser/devtools/protocol/tracing_handler.cc +++ b/content/browser/devtools/protocol/tracing_handler.cc @@ -83,15 +83,14 @@ void TracingHandler::OnTraceComplete() { client_->TracingComplete(TracingCompleteParams::Create()); } -scoped_refptr<DevToolsProtocol::Response> TracingHandler::Start( - const std::string* categories, - const std::string* options_str, - const double* buffer_usage_reporting_interval, - scoped_refptr<DevToolsProtocol::Command> command) { +Response TracingHandler::Start(DevToolsCommandId command_id, + const std::string* categories, + const std::string* options_str, + const double* buffer_usage_reporting_interval) { if (is_recording_) - return command->InternalErrorResponse("Tracing is already started"); - is_recording_ = true; + return Response::InternalError("Tracing is already started"); + is_recording_ = true; base::debug::TraceOptions options = TraceOptionsFromString(options_str); base::debug::CategoryFilter filter(categories ? *categories : std::string()); if (buffer_usage_reporting_interval) @@ -104,7 +103,7 @@ scoped_refptr<DevToolsProtocol::Response> TracingHandler::Start( filter, options, TracingController::EnableRecordingDoneCallback()); - return nullptr; + return Response::FallThrough(); } TracingController::GetInstance()->EnableRecording( @@ -112,34 +111,30 @@ scoped_refptr<DevToolsProtocol::Response> TracingHandler::Start( options, base::Bind(&TracingHandler::OnRecordingEnabled, weak_factory_.GetWeakPtr(), - command)); - return command->AsyncResponsePromise(); + command_id)); + return Response::OK(); } -scoped_refptr<DevToolsProtocol::Response> TracingHandler::End( - scoped_refptr<DevToolsProtocol::Command> command) { +Response TracingHandler::End(DevToolsCommandId command_id) { if (!is_recording_) - return command->InternalErrorResponse("Tracing is not started"); + return Response::InternalError("Tracing is not started"); + DisableRecording(false); // If inspected target is a render process Tracing.end will be handled by // tracing agent in the renderer. - if (target_ == Renderer) - return nullptr; - return command->SuccessResponse(nullptr); + return target_ == Renderer ? Response::FallThrough() : Response::OK(); } -scoped_refptr<DevToolsProtocol::Response> TracingHandler::GetCategories( - scoped_refptr<DevToolsProtocol::Command> command) { +Response TracingHandler::GetCategories(DevToolsCommandId command_id) { TracingController::GetInstance()->GetCategories( base::Bind(&TracingHandler::OnCategoriesReceived, weak_factory_.GetWeakPtr(), - command)); - return command->AsyncResponsePromise(); + command_id)); + return Response::OK(); } -void TracingHandler::OnRecordingEnabled( - scoped_refptr<DevToolsProtocol::Command> command) { - client_->SendStartResponse(command, StartResponse::Create()); +void TracingHandler::OnRecordingEnabled(DevToolsCommandId command_id) { + client_->SendStartResponse(command_id, StartResponse::Create()); } void TracingHandler::OnBufferUsage(float percent_full, @@ -153,12 +148,12 @@ void TracingHandler::OnBufferUsage(float percent_full, } void TracingHandler::OnCategoriesReceived( - scoped_refptr<DevToolsProtocol::Command> command, + DevToolsCommandId command_id, const std::set<std::string>& category_set) { std::vector<std::string> categories; for (const std::string& category : category_set) categories.push_back(category); - client_->SendGetCategoriesResponse(command, + client_->SendGetCategoriesResponse(command_id, GetCategoriesResponse::Create()->set_categories(categories)); } diff --git a/content/browser/devtools/protocol/tracing_handler.h b/content/browser/devtools/protocol/tracing_handler.h index 29da1d6..9a7efb3 100644 --- a/content/browser/devtools/protocol/tracing_handler.h +++ b/content/browser/devtools/protocol/tracing_handler.h @@ -10,7 +10,7 @@ #include "base/debug/trace_event.h" #include "base/memory/weak_ptr.h" -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" #include "content/public/browser/tracing_controller.h" namespace base { @@ -36,22 +36,18 @@ class TracingHandler { void OnTraceDataCollected(const std::string& trace_fragment); void OnTraceComplete(); - scoped_refptr<DevToolsProtocol::Response> Start( - const std::string* categories, - const std::string* options, - const double* buffer_usage_reporting_interval, - scoped_refptr<DevToolsProtocol::Command> command); - - scoped_refptr<DevToolsProtocol::Response> End( - scoped_refptr<DevToolsProtocol::Command> command); - scoped_refptr<DevToolsProtocol::Response> GetCategories( - scoped_refptr<DevToolsProtocol::Command> command); + Response Start(DevToolsCommandId command_id, + const std::string* categories, + const std::string* options, + const double* buffer_usage_reporting_interval); + Response End(DevToolsCommandId command_id); + Response GetCategories(DevToolsCommandId command); private: - void OnRecordingEnabled(scoped_refptr<DevToolsProtocol::Command> command); + void OnRecordingEnabled(DevToolsCommandId command_id); void OnBufferUsage(float percent_full, size_t approximate_event_count); - void OnCategoriesReceived(scoped_refptr<DevToolsProtocol::Command> command, + void OnCategoriesReceived(DevToolsCommandId command_id, const std::set<std::string>& category_set); base::debug::TraceOptions TraceOptionsFromString(const std::string* options); diff --git a/content/browser/devtools/protocol/usage_and_quota_query.h b/content/browser/devtools/protocol/usage_and_quota_query.h index 3a62e35..c3d7d87 100644 --- a/content/browser/devtools/protocol/usage_and_quota_query.h +++ b/content/browser/devtools/protocol/usage_and_quota_query.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_QUOTA_AND_USAGE_QUERY_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_QUOTA_AND_USAGE_QUERY_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" #include "storage/browser/quota/quota_manager.h" namespace content { diff --git a/content/browser/devtools/protocol/worker_handler.cc b/content/browser/devtools/protocol/worker_handler.cc index fd8fc09..9baee17 100644 --- a/content/browser/devtools/protocol/worker_handler.cc +++ b/content/browser/devtools/protocol/worker_handler.cc @@ -9,7 +9,6 @@ namespace devtools { namespace worker { typedef DevToolsProtocolClient::Response Response; -typedef DevToolsProtocolClient::ResponseStatus ResponseStatus; WorkerHandler::WorkerHandler() { } diff --git a/content/browser/devtools/protocol/worker_handler.h b/content/browser/devtools/protocol/worker_handler.h index 1c1faaf..b4ff38f 100644 --- a/content/browser/devtools/protocol/worker_handler.h +++ b/content/browser/devtools/protocol/worker_handler.h @@ -5,7 +5,7 @@ #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_WORKER_HANDLER_H_ #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_WORKER_HANDLER_H_ -#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h" +#include "content/browser/devtools/protocol/devtools_protocol_handler.h" namespace content { namespace devtools { |