1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "chrome/browser/devtools/devtools_embedder_message_dispatcher.h"
8 #include "base/values.h"
12 bool GetValue(const base::ListValue& list, int pos, std::string& value) {
13 return list.GetString(pos, &value);
16 bool GetValue(const base::ListValue& list, int pos, int& value) {
17 return list.GetInteger(pos, &value);
20 bool GetValue(const base::ListValue& list, int pos, bool& value) {
21 return list.GetBoolean(pos, &value);
24 bool GetValue(const base::ListValue& list, int pos, gfx::Rect& rect) {
25 const base::DictionaryValue* dict;
26 if (!list.GetDictionary(pos, &dict))
32 if (!dict->GetInteger("x", &x) ||
33 !dict->GetInteger("y", &y) ||
34 !dict->GetInteger("width", &width) ||
35 !dict->GetInteger("height", &height))
37 rect.SetRect(x, y, width, height);
42 struct StorageTraits {
43 typedef T StorageType;
47 struct StorageTraits<const T&> {
48 typedef T StorageType;
54 typedef typename StorageTraits<A>::StorageType ValueType;
56 Argument(const base::ListValue& list, int pos) {
57 valid_ = GetValue(list, pos, value_);
60 ValueType value() const { return value_; }
61 bool valid() const { return valid_; }
68 bool ParseAndHandle0(const base::Callback<void(void)>& handler,
69 const base::ListValue& list) {
70 if (list.GetSize() != 0)
77 bool ParseAndHandle1(const base::Callback<void(A1)>& handler,
78 const base::ListValue& list) {
79 if (list.GetSize() != 1)
81 Argument<A1> arg1(list, 0);
84 handler.Run(arg1.value());
88 template <class A1, class A2>
89 bool ParseAndHandle2(const base::Callback<void(A1, A2)>& handler,
90 const base::ListValue& list) {
91 if (list.GetSize() != 2)
93 Argument<A1> arg1(list, 0);
96 Argument<A2> arg2(list, 1);
99 handler.Run(arg1.value(), arg2.value());
103 template <class A1, class A2, class A3>
104 bool ParseAndHandle3(const base::Callback<void(A1, A2, A3)>& handler,
105 const base::ListValue& list) {
106 if (list.GetSize() != 3)
108 Argument<A1> arg1(list, 0);
111 Argument<A2> arg2(list, 1);
114 Argument<A3> arg3(list, 2);
117 handler.Run(arg1.value(), arg2.value(), arg3.value());
121 template <class A1, class A2, class A3, class A4>
122 bool ParseAndHandle4(const base::Callback<void(A1, A2, A3, A4)>& handler,
123 const base::ListValue& list) {
124 if (list.GetSize() != 4)
126 Argument<A1> arg1(list, 0);
129 Argument<A2> arg2(list, 1);
132 Argument<A3> arg3(list, 2);
135 Argument<A4> arg4(list, 3);
138 handler.Run(arg1.value(), arg2.value(), arg3.value(), arg4.value());
145 * Dispatcher for messages sent from the frontend running in an
146 * isolated renderer (chrome-devtools:// or chrome://inspect) to the embedder
149 * The messages are sent via InspectorFrontendHost.sendMessageToEmbedder or
150 * chrome.send method accordingly.
152 class DispatcherImpl : public DevToolsEmbedderMessageDispatcher {
154 ~DispatcherImpl() override {}
156 bool Dispatch(const std::string& method,
157 const base::ListValue* params,
158 std::string* error) override {
159 HandlerMap::iterator it = handlers_.find(method);
160 if (it == handlers_.end())
163 if (it->second.Run(*params))
167 *error = "Invalid frontend host message parameters: " + method;
171 typedef base::Callback<bool(const base::ListValue&)> Handler;
172 void RegisterHandler(const std::string& method, const Handler& handler) {
173 handlers_[method] = handler;
177 void RegisterHandler(const std::string& method,
178 void (T::*handler)(), T* delegate) {
179 handlers_[method] = base::Bind(&ParseAndHandle0,
181 base::Unretained(delegate)));
184 template<class T, class A1>
185 void RegisterHandler(const std::string& method,
186 void (T::*handler)(A1), T* delegate) {
187 handlers_[method] = base::Bind(ParseAndHandle1<A1>,
189 base::Unretained(delegate)));
192 template<class T, class A1, class A2>
193 void RegisterHandler(const std::string& method,
194 void (T::*handler)(A1, A2), T* delegate) {
195 handlers_[method] = base::Bind(ParseAndHandle2<A1, A2>,
197 base::Unretained(delegate)));
200 template<class T, class A1, class A2, class A3>
201 void RegisterHandler(const std::string& method,
202 void (T::*handler)(A1, A2, A3), T* delegate) {
203 handlers_[method] = base::Bind(ParseAndHandle3<A1, A2, A3>,
205 base::Unretained(delegate)));
208 template<class T, class A1, class A2, class A3, class A4>
209 void RegisterHandler(const std::string& method,
210 void (T::*handler)(A1, A2, A3, A4), T* delegate) {
211 handlers_[method] = base::Bind(ParseAndHandle4<A1, A2, A3, A4>,
213 base::Unretained(delegate)));
217 typedef std::map<std::string, Handler> HandlerMap;
218 HandlerMap handlers_;
222 DevToolsEmbedderMessageDispatcher*
223 DevToolsEmbedderMessageDispatcher::createForDevToolsFrontend(
224 Delegate* delegate) {
225 DispatcherImpl* d = new DispatcherImpl();
227 d->RegisterHandler("bringToFront", &Delegate::ActivateWindow, delegate);
228 d->RegisterHandler("closeWindow", &Delegate::CloseWindow, delegate);
229 d->RegisterHandler("loadCompleted", &Delegate::LoadCompleted, delegate);
230 d->RegisterHandler("setInspectedPageBounds",
231 &Delegate::SetInspectedPageBounds, delegate);
232 d->RegisterHandler("inspectElementCompleted",
233 &Delegate::InspectElementCompleted, delegate);
234 d->RegisterHandler("inspectedURLChanged",
235 &Delegate::InspectedURLChanged, delegate);
236 d->RegisterHandler("moveWindowBy", &Delegate::MoveWindow, delegate);
237 d->RegisterHandler("setIsDocked", &Delegate::SetIsDocked, delegate);
238 d->RegisterHandler("openInNewTab", &Delegate::OpenInNewTab, delegate);
239 d->RegisterHandler("save", &Delegate::SaveToFile, delegate);
240 d->RegisterHandler("append", &Delegate::AppendToFile, delegate);
241 d->RegisterHandler("requestFileSystems",
242 &Delegate::RequestFileSystems, delegate);
243 d->RegisterHandler("addFileSystem", &Delegate::AddFileSystem, delegate);
244 d->RegisterHandler("removeFileSystem", &Delegate::RemoveFileSystem, delegate);
245 d->RegisterHandler("upgradeDraggedFileSystemPermissions",
246 &Delegate::UpgradeDraggedFileSystemPermissions, delegate);
247 d->RegisterHandler("indexPath", &Delegate::IndexPath, delegate);
248 d->RegisterHandler("stopIndexing", &Delegate::StopIndexing, delegate);
249 d->RegisterHandler("searchInPath", &Delegate::SearchInPath, delegate);
250 d->RegisterHandler("setWhitelistedShortcuts",
251 &Delegate::SetWhitelistedShortcuts, delegate);
252 d->RegisterHandler("zoomIn", &Delegate::ZoomIn, delegate);
253 d->RegisterHandler("zoomOut", &Delegate::ZoomOut, delegate);
254 d->RegisterHandler("resetZoom", &Delegate::ResetZoom, delegate);
255 d->RegisterHandler("openUrlOnRemoteDeviceAndInspect",
256 &Delegate::OpenUrlOnRemoteDeviceAndInspect, delegate);
257 d->RegisterHandler("setDeviceCountUpdatesEnabled",
258 &Delegate::SetDeviceCountUpdatesEnabled, delegate);
259 d->RegisterHandler("setDevicesUpdatesEnabled",
260 &Delegate::SetDevicesUpdatesEnabled, delegate);
261 d->RegisterHandler("sendMessageToBrowser",
262 &Delegate::SendMessageToBrowser, delegate);