[DevTools] Remote JSON requests from javascript (Chromium side)

chrome/browser/devtools/devtools_embedder_message_dispatcher.cc

 // 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 "chrome/browser/devtools/devtools_embedder_message_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 
 namespace {
@@ skipping 47 matching lines @@
   template <typename H, typename... As>
   void Apply(const H& handler, As... args) {
     handler.Run(args...);
   }
 };
 
 template <typename T, typename... Ts>
 struct ParamTuple<T, Ts...> {
   bool Parse(const base::ListValue& list,
              const base::ListValue::const_iterator& it) {
-    if (it == list.end())
-      return false;
-    if (!GetValue(*it, &head))
-      return false;
-    return tail.Parse(list, it + 1);
+    return it != list.end() && GetValue(*it, &head) && tail.Parse(list, it + 1);
   }
 
   template <typename H, typename... As>
   void Apply(const H& handler, As... args) {
     tail.template Apply<H, As..., T>(handler, args..., head);
   }
 
   typename StorageTraits<T>::StorageType head;
   ParamTuple<Ts...> tail;
 };
 
 template<typename... As>
-bool ParseAndHandle(const base::Callback<void(As...)>& handler,
+void ParseAndHandle(const base::Callback<void(int, As...)>& handler,
+                    int request_id,
                     const base::ListValue& list) {
   ParamTuple<As...> tuple;
-  if (!tuple.Parse(list, list.begin()))
-    return false;
-  tuple.Apply(handler);
-  return true;
+  if (tuple.Parse(list, list.begin()))
+    tuple.Apply(handler, request_id);
 }
 
 } // namespace
 
 /**
  * Dispatcher for messages sent from the frontend running in an
  * isolated renderer (chrome-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 {}
 
-  bool Dispatch(const std::string& method,
-                const base::ListValue* params,
-                std::string* error) override {
+  void Dispatch(int request_id,
+                const std::string& method,
+                const base::ListValue* params) override {
     HandlerMap::iterator it = handlers_.find(method);
-    if (it == handlers_.end())
-      return false;
-
-    if (it->second.Run(*params))
-      return true;
-
-    if (error)
-      *error = "Invalid frontend host message parameters: " + method;
-    return false;
-  }
-
-  typedef base::Callback<bool(const base::ListValue&)> Handler;
-  void RegisterHandler(const std::string& method, const Handler& handler) {
-    handlers_[method] = handler;
+    if (it != handlers_.end())
+      it->second.Run(request_id, *params);
   }
 
   template<typename T, typename... As>
   void RegisterHandler(const std::string& method,
-                       void (T::*handler)(As...), T* delegate) {
+                       void (T::*handler)(int, As...), T* delegate) {
     handlers_[method] = base::Bind(&ParseAndHandle<As...>,
                                    base::Bind(handler,
                                               base::Unretained(delegate)));
   }
 
  private:
-  typedef std::map<std::string, Handler> HandlerMap;
+  using Handler = base::Callback<void(int, const base::ListValue&)>;
+  using HandlerMap = std::map<std::string, Handler>;
   HandlerMap handlers_;
 };
 
-
+// static
 DevToolsEmbedderMessageDispatcher*
-    DevToolsEmbedderMessageDispatcher::createForDevToolsFrontend(
-        Delegate* delegate) {
+DevToolsEmbedderMessageDispatcher::CreateForDevToolsFrontend(
+    Delegate* delegate) {
   DispatcherImpl* d = new 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",
@@ skipping 17 matching lines @@
   d->RegisterHandler("zoomOut", &Delegate::ZoomOut, delegate);
   d->RegisterHandler("resetZoom", &Delegate::ResetZoom, delegate);
   d->RegisterHandler("openUrlOnRemoteDeviceAndInspect",
                      &Delegate::OpenUrlOnRemoteDeviceAndInspect, delegate);
   d->RegisterHandler("setDeviceCountUpdatesEnabled",
                      &Delegate::SetDeviceCountUpdatesEnabled, delegate);
   d->RegisterHandler("setDevicesUpdatesEnabled",
                      &Delegate::SetDevicesUpdatesEnabled, delegate);
   d->RegisterHandler("sendMessageToBrowser",
                      &Delegate::SendMessageToBrowser, delegate);
-  d->RegisterHandler("recordActionUMA",
-                     &Delegate::RecordActionUMA, delegate);
+  d->RegisterHandler("recordActionUMA", &Delegate::RecordActionUMA, delegate);
+  d->RegisterHandler("sendJsonRequest", &Delegate::SendJsonRequest, delegate);
   return d;
 }