| // Copyright 2013 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/devtools/devtools_embedder_message_dispatcher.h" |
| |
| #include <memory> |
| |
| #include "base/functional/bind.h" |
| #include "base/logging.h" |
| #include "base/types/optional_util.h" |
| #include "base/values.h" |
| #include "chrome/browser/devtools/devtools_dispatch_http_request_params.h" |
| #include "chrome/browser/devtools/devtools_settings.h" |
| #include "chrome/browser/devtools/features.h" |
| #include "chrome/browser/devtools/visual_logging.h" |
| |
| namespace { |
| |
| using DispatchCallback = DevToolsEmbedderMessageDispatcher::DispatchCallback; |
| |
| bool GetValue(const base::Value& value, |
| DevToolsDispatchHttpRequestParams& params) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| auto parsed_params = DevToolsDispatchHttpRequestParams::FromDict(*dict); |
| if (!parsed_params) { |
| return false; |
| } |
| params = std::move(*parsed_params); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, std::string& result) { |
| const std::string* str = value.GetIfString(); |
| if (!str) { |
| return false; |
| } |
| result = *str; |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, int& result) { |
| return base::OptionalUnwrapTo(value.GetIfInt(), result); |
| } |
| |
| bool GetValue(const base::Value& value, double& result) { |
| return base::OptionalUnwrapTo(value.GetIfDouble(), result); |
| } |
| |
| bool GetValue(const base::Value& value, bool& result) { |
| return base::OptionalUnwrapTo(value.GetIfBool(), result); |
| } |
| |
| bool GetValue(const base::Value& value, gfx::Rect& rect) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| std::optional<int> x = dict->FindInt("x"); |
| std::optional<int> y = dict->FindInt("y"); |
| std::optional<int> width = dict->FindInt("width"); |
| std::optional<int> height = dict->FindInt("height"); |
| if (!x.has_value() || !y.has_value() || !width.has_value() || |
| !height.has_value()) { |
| return false; |
| } |
| |
| rect.SetRect(x.value(), y.value(), width.value(), height.value()); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, RegisterOptions& options) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| const bool synced = dict->FindBool("synced").value_or(false); |
| options.sync_mode = synced ? RegisterOptions::SyncMode::kSync |
| : RegisterOptions::SyncMode::kDontSync; |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, ImpressionEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| const base::ListValue* impressions = dict->FindList("impressions"); |
| if (!impressions) { |
| return false; |
| } |
| for (const auto& impression : *impressions) { |
| const base::DictValue* impression_dict = impression.GetIfDict(); |
| if (!impression_dict) { |
| return false; |
| } |
| std::optional<double> id = impression_dict->FindDouble("id"); |
| std::optional<int> type = impression_dict->FindInt("type"); |
| if (!id || !type) { |
| return false; |
| } |
| |
| auto& back = event.impressions.emplace_back( |
| VisualElementImpression{static_cast<int64_t>(*id), *type}); |
| |
| base::OptionalUnwrapTo(impression_dict->FindDouble("parent"), back.parent); |
| base::OptionalUnwrapTo(impression_dict->FindInt("context"), back.context); |
| base::OptionalUnwrapTo(impression_dict->FindInt("width"), back.width); |
| base::OptionalUnwrapTo(impression_dict->FindInt("height"), back.height); |
| } |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, ResizeEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| if (!base::OptionalUnwrapTo(dict->FindDouble("veid"), event.veid)) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindInt("width"), event.width); |
| base::OptionalUnwrapTo(dict->FindInt("height"), event.height); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, ClickEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| if (!base::OptionalUnwrapTo(dict->FindDouble("veid"), event.veid)) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindInt("mouseButton"), event.mouse_button); |
| base::OptionalUnwrapTo(dict->FindInt("doubleClick"), event.double_click); |
| base::OptionalUnwrapTo(dict->FindInt("context"), event.context); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, HoverEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| if (!base::OptionalUnwrapTo(dict->FindDouble("veid"), event.veid)) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindInt("time"), event.time); |
| base::OptionalUnwrapTo(dict->FindInt("context"), event.context); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, DragEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| if (!base::OptionalUnwrapTo(dict->FindDouble("veid"), event.veid)) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindInt("distance"), event.distance); |
| base::OptionalUnwrapTo(dict->FindInt("context"), event.context); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, ChangeEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| if (!base::OptionalUnwrapTo(dict->FindDouble("veid"), event.veid)) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindInt("context"), event.context); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, KeyDownEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindDouble("veid"), event.veid); |
| base::OptionalUnwrapTo(dict->FindInt("context"), event.context); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, SettingAccessEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindInt("name"), event.name); |
| base::OptionalUnwrapTo(dict->FindInt("numeric_value"), event.numeric_value); |
| base::OptionalUnwrapTo(dict->FindInt("string_value"), event.string_value); |
| return true; |
| } |
| |
| bool GetValue(const base::Value& value, FunctionCallEvent& event) { |
| const base::DictValue* dict = value.GetIfDict(); |
| if (!dict) { |
| return false; |
| } |
| |
| base::OptionalUnwrapTo(dict->FindInt("name"), event.name); |
| base::OptionalUnwrapTo(dict->FindInt("context"), event.context); |
| return true; |
| } |
| |
| template <typename T> |
| struct StorageTraits { |
| using StorageType = T; |
| }; |
| |
| template <typename T> |
| struct StorageTraits<const T&> { |
| using StorageType = T; |
| }; |
| |
| template <typename... Ts> |
| struct ParamTuple { |
| bool Parse(base::ListValue::const_iterator it) { return true; } |
| |
| template <typename H, typename... As> |
| void Apply(const H& handler, As... args) { |
| handler.Run(std::forward<As>(args)...); |
| } |
| }; |
| |
| template <typename T, typename... Ts> |
| struct ParamTuple<T, Ts...> { |
| bool Parse(base::ListValue::const_iterator it) { |
| return GetValue(*it, head) && tail.Parse(it + 1); |
| } |
| |
| template <typename H, typename... As> |
| void Apply(const H& handler, As... args) { |
| tail.template Apply<H, As..., T>(handler, std::forward<As>(args)..., head); |
| } |
| |
| typename StorageTraits<T>::StorageType head; |
| ParamTuple<Ts...> tail; |
| }; |
| |
| template <typename... As> |
| bool ParseAndHandle(const base::RepeatingCallback<void(As...)>& handler, |
| const std::string& method, |
| DispatchCallback callback, |
| const base::ListValue& list) { |
| ParamTuple<As...> tuple; |
| if (list.size() != sizeof...(As) || !tuple.Parse(list.begin())) { |
| LOG(ERROR) << "Failed to parse arguments for " << method |
| << " call: " << list.DebugString(); |
| return false; |
| } |
| tuple.Apply(handler); |
| return true; |
| } |
| |
| template <typename... As> |
| bool ParseAndHandleWithCallback( |
| const base::RepeatingCallback<void(DispatchCallback, As...)>& handler, |
| const std::string& method, |
| DispatchCallback callback, |
| const base::ListValue& list) { |
| ParamTuple<As...> tuple; |
| if (list.size() != sizeof...(As) || !tuple.Parse(list.begin())) { |
| LOG(ERROR) << "Failed to parse arguments for " << method |
| << " call: " << list.DebugString(); |
| return false; |
| } |
| tuple.Apply(handler, std::move(callback)); |
| return true; |
| } |
| |
| } // namespace |
| |
| /** |
| * Dispatcher for messages sent from the frontend running in an |
| * isolated renderer (devtools:// or chrome://inspect) to the embedder |
| * in the browser. |
| * |
| * The messages are sent via InspectorFrontendHost.sendMessageToEmbedder or |
| * chrome.send method accordingly. |
| */ |
| class DispatcherImpl : public DevToolsEmbedderMessageDispatcher { |
| public: |
| ~DispatcherImpl() override = default; |
| |
| bool Dispatch(DispatchCallback callback, |
| const std::string& method, |
| const base::ListValue& params) override { |
| auto it = handlers_.find(method); |
| return it != handlers_.end() && it->second.Run(std::move(callback), params); |
| } |
| |
| template<typename... As> |
| void RegisterHandler(const std::string& method, |
| void (Delegate::*handler)(As...), |
| Delegate* delegate) { |
| handlers_[method] = base::BindRepeating( |
| &ParseAndHandle<As...>, |
| base::BindRepeating(handler, base::Unretained(delegate)), method); |
| } |
| |
| template <typename... As> |
| void RegisterHandlerWithCallback(const std::string& method, |
| void (Delegate::*handler)(DispatchCallback, |
| As...), |
| Delegate* delegate) { |
| handlers_[method] = base::BindRepeating( |
| &ParseAndHandleWithCallback<As...>, |
| base::BindRepeating(handler, base::Unretained(delegate)), method); |
| } |
| |
| private: |
| using Handler = |
| base::RepeatingCallback<bool(DispatchCallback, const base::ListValue&)>; |
| using HandlerMap = std::map<std::string, Handler>; |
| HandlerMap handlers_; |
| }; |
| |
| // static |
| std::unique_ptr<DevToolsEmbedderMessageDispatcher> |
| DevToolsEmbedderMessageDispatcher::CreateForDevToolsFrontend( |
| Delegate* delegate) { |
| auto d = std::make_unique<DispatcherImpl>(); |
| |
| d->RegisterHandler("bringToFront", &Delegate::ActivateWindow, delegate); |
| d->RegisterHandler("closeWindow", &Delegate::CloseWindow, delegate); |
| d->RegisterHandler("loadCompleted", &Delegate::LoadCompleted, delegate); |
| d->RegisterHandler("setInspectedPageBounds", |
| &Delegate::SetInspectedPageBounds, delegate); |
| d->RegisterHandler("inspectElementCompleted", |
| &Delegate::InspectElementCompleted, delegate); |
| d->RegisterHandler("inspectedURLChanged", |
| &Delegate::InspectedURLChanged, delegate); |
| d->RegisterHandlerWithCallback("setIsDocked", |
| &Delegate::SetIsDocked, delegate); |
| d->RegisterHandler("openInNewTab", &Delegate::OpenInNewTab, delegate); |
| d->RegisterHandler("openSearchResultsInNewTab", |
| &Delegate::OpenSearchResultsInNewTab, delegate); |
| d->RegisterHandler("showItemInFolder", &Delegate::ShowItemInFolder, delegate); |
| d->RegisterHandler("save", &Delegate::SaveToFile, delegate); |
| d->RegisterHandler("append", &Delegate::AppendToFile, delegate); |
| d->RegisterHandler("requestFileSystems", |
| &Delegate::RequestFileSystems, delegate); |
| d->RegisterHandler("addFileSystem", &Delegate::AddFileSystem, delegate); |
| d->RegisterHandler("removeFileSystem", &Delegate::RemoveFileSystem, delegate); |
| d->RegisterHandler("upgradeDraggedFileSystemPermissions", |
| &Delegate::UpgradeDraggedFileSystemPermissions, delegate); |
| d->RegisterHandlerWithCallback("connectAutomaticFileSystem", |
| &Delegate::ConnectAutomaticFileSystem, |
| delegate); |
| d->RegisterHandler("disconnectAutomaticFileSystem", |
| &Delegate::DisconnectAutomaticFileSystem, delegate); |
| d->RegisterHandler("indexPath", &Delegate::IndexPath, delegate); |
| d->RegisterHandlerWithCallback("loadNetworkResource", |
| &Delegate::LoadNetworkResource, delegate); |
| d->RegisterHandler("stopIndexing", &Delegate::StopIndexing, delegate); |
| d->RegisterHandler("searchInPath", &Delegate::SearchInPath, delegate); |
| d->RegisterHandler("setWhitelistedShortcuts", |
| &Delegate::SetWhitelistedShortcuts, delegate); |
| d->RegisterHandler("setEyeDropperActive", &Delegate::SetEyeDropperActive, |
| delegate); |
| d->RegisterHandler("showCertificateViewer", |
| &Delegate::ShowCertificateViewer, delegate); |
| d->RegisterHandler("zoomIn", &Delegate::ZoomIn, delegate); |
| d->RegisterHandler("zoomOut", &Delegate::ZoomOut, delegate); |
| d->RegisterHandler("resetZoom", &Delegate::ResetZoom, delegate); |
| d->RegisterHandler("setDevicesDiscoveryConfig", |
| &Delegate::SetDevicesDiscoveryConfig, delegate); |
| d->RegisterHandler("setDevicesUpdatesEnabled", |
| &Delegate::SetDevicesUpdatesEnabled, delegate); |
| d->RegisterHandler("openRemotePage", &Delegate::OpenRemotePage, delegate); |
| d->RegisterHandler("openNodeFrontend", &Delegate::OpenNodeFrontend, delegate); |
| d->RegisterHandler("dispatchProtocolMessage", |
| &Delegate::DispatchProtocolMessageFromDevToolsFrontend, |
| delegate); |
| d->RegisterHandler("recordCountHistogram", &Delegate::RecordCountHistogram, |
| delegate); |
| d->RegisterHandler("recordEnumeratedHistogram", |
| &Delegate::RecordEnumeratedHistogram, delegate); |
| d->RegisterHandler("recordPerformanceHistogram", |
| &Delegate::RecordPerformanceHistogram, delegate); |
| d->RegisterHandler("recordPerformanceHistogramMedium", |
| &Delegate::RecordPerformanceHistogramMedium, delegate); |
| d->RegisterHandler("recordUserMetricsAction", |
| &Delegate::RecordUserMetricsAction, delegate); |
| d->RegisterHandler("recordNewBadgeUsage", &Delegate::RecordNewBadgeUsage, |
| delegate); |
| d->RegisterHandler("setChromeFlag", &Delegate::SetChromeFlag, delegate); |
| d->RegisterHandler("recordImpression", &Delegate::RecordImpression, delegate); |
| d->RegisterHandler("recordResize", &Delegate::RecordResize, delegate); |
| d->RegisterHandler("recordClick", &Delegate::RecordClick, delegate); |
| d->RegisterHandler("recordHover", &Delegate::RecordHover, delegate); |
| d->RegisterHandler("recordDrag", &Delegate::RecordDrag, delegate); |
| d->RegisterHandler("recordChange", &Delegate::RecordChange, delegate); |
| d->RegisterHandler("recordKeyDown", &Delegate::RecordKeyDown, delegate); |
| d->RegisterHandler("recordSettingAccess", &Delegate::RecordSettingAccess, |
| delegate); |
| d->RegisterHandler("recordFunctionCall", &Delegate::RecordFunctionCall, |
| delegate); |
| d->RegisterHandler("registerPreference", &Delegate::RegisterPreference, |
| delegate); |
| d->RegisterHandlerWithCallback("getPreferences", |
| &Delegate::GetPreferences, delegate); |
| d->RegisterHandlerWithCallback("getPreference", &Delegate::GetPreference, |
| delegate); |
| d->RegisterHandler("setPreference", |
| &Delegate::SetPreference, delegate); |
| d->RegisterHandler("removePreference", |
| &Delegate::RemovePreference, delegate); |
| d->RegisterHandler("clearPreferences", |
| &Delegate::ClearPreferences, delegate); |
| d->RegisterHandlerWithCallback("getSyncInformation", |
| &Delegate::GetSyncInformation, delegate); |
| d->RegisterHandlerWithCallback("getHostConfig", &Delegate::GetHostConfig, |
| delegate); |
| d->RegisterHandlerWithCallback("reattach", |
| &Delegate::Reattach, delegate); |
| d->RegisterHandler("readyForTest", |
| &Delegate::ReadyForTest, delegate); |
| d->RegisterHandler("connectionReady", &Delegate::ConnectionReady, delegate); |
| d->RegisterHandler("setOpenNewWindowForPopups", |
| &Delegate::SetOpenNewWindowForPopups, delegate); |
| d->RegisterHandler("registerExtensionsAPI", &Delegate::RegisterExtensionsAPI, |
| delegate); |
| d->RegisterHandlerWithCallback("showSurvey", &Delegate::ShowSurvey, delegate); |
| d->RegisterHandlerWithCallback("canShowSurvey", &Delegate::CanShowSurvey, |
| delegate); |
| |
| d->RegisterHandlerWithCallback("doAidaConversation", |
| &Delegate::DoAidaConversation, delegate); |
| d->RegisterHandlerWithCallback("aidaCodeComplete", |
| &Delegate::AidaCodeComplete, delegate); |
| d->RegisterHandlerWithCallback("registerAidaClientEvent", |
| &Delegate::RegisterAidaClientEvent, delegate); |
| d->RegisterHandlerWithCallback("dispatchHttpRequest", |
| &Delegate::DispatchHttpRequest, delegate); |
| d->RegisterHandler("requestRestart", &Delegate::RequestRestart, delegate); |
| return d; |
| } |
