[DevTools] DevToolsEmbedderMessageDispatcher: variadic implementation of RegisterHandler

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 {
 
-bool GetValue(const base::ListValue& list, int pos, std::string& value) {
-  return list.GetString(pos, &value);
+bool GetValue(const base::Value* value, std::string* result) {
+  return value->GetAsString(result);
 }
 
-bool GetValue(const base::ListValue& list, int pos, int& value) {
-  return list.GetInteger(pos, &value);
+bool GetValue(const base::Value* value, int* result) {
+  return value->GetAsInteger(result);
 }
 
-bool GetValue(const base::ListValue& list, int pos, bool& value) {
-  return list.GetBoolean(pos, &value);
+bool GetValue(const base::Value* value, bool* result) {
+  return value->GetAsBoolean(result);
 }
 
-bool GetValue(const base::ListValue& list, int pos, gfx::Rect& rect) {
+bool GetValue(const base::Value* value, gfx::Rect* rect) {
   const base::DictionaryValue* dict;
-  if (!list.GetDictionary(pos, &dict))
+  if (!value->GetAsDictionary(&dict))
     return false;
   int x = 0;
   int y = 0;
   int width = 0;
   int height = 0;
   if (!dict->GetInteger("x", &x) ||
       !dict->GetInteger("y", &y) ||
       !dict->GetInteger("width", &width) ||
       !dict->GetInteger("height", &height))
     return false;
-  rect.SetRect(x, y, width, height);
+  rect->SetRect(x, y, width, height);
   return true;
 }
 
 template <typename T>
 struct StorageTraits {
-  typedef T StorageType;
+  using StorageType = T;
 };
 
 template <typename T>
 struct StorageTraits<const T&> {
-  typedef T StorageType;
+  using StorageType = T;
 };
 
-template <class A>
-class Argument {
- public:
-  typedef typename StorageTraits<A>::StorageType ValueType;
-
-  Argument(const base::ListValue& list, int pos) {
-    valid_ = GetValue(list, pos, value_);
+template <typename... Ts>
+struct Tuple {

[Tom Sepez, 2015/01/29 17:33:04]

nit: worry about confusion with base::Tuple or any of the other tuples that may
exist somewhere, although it is in anonymous namespace.  Your call.

[vkuzkokov, 2015/01/29 17:49:28]

Renamed to ParamTuple.

+  bool Parse(const base::ListValue& list,
+             const base::ListValue::const_iterator& it) {
+    return it == list.end();
   }
 
-  ValueType value() const { return value_; }
-  bool valid() const { return valid_; }
-
- private:
-  ValueType value_;
-  bool valid_;
+  template <typename H, typename... As>
+  void Apply(const H& handler, As... args) {
+    handler.Run(args...);
+  }
 };
 
-bool ParseAndHandle0(const base::Callback<void(void)>& handler,
-                     const base::ListValue& list) {
-  if (list.GetSize() != 0)
+template <typename T, typename... Ts>
+struct Tuple<T, Ts...> {
+  bool Parse(const base::ListValue& list,
+             const base::ListValue::const_iterator& it) {
+    if (it == list.end())
       return false;
-  handler.Run();
+    if (!GetValue(*it, &head))
+      return false;
+    return 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);

[dgozman, 2015/01/29 10:43:44]

Doesn't this reverse the arguments order?

[vkuzkokov, 2015/01/29 16:11:32]

No. |args| is arguments that are already calculated, and |head| is head of what
remains. Think of |handler| and |args| as |handler.bind(args...)| but without
associated overhead.

+  }
+
+  typename StorageTraits<T>::StorageType head;
+  Tuple<Ts...> tail;
+};
+
+template<typename... As>
+bool ParseAndHandle(const base::Callback<void(As...)>& handler,
+                    const base::ListValue& list) {
+  Tuple<As...> tuple;
+  if (!tuple.Parse(list, list.begin()))
+    return false;
+  tuple.Apply(handler);
   return true;
 }
 
-template <class A1>
-bool ParseAndHandle1(const base::Callback<void(A1)>& handler,
-                     const base::ListValue& list) {
-  if (list.GetSize() != 1)
-    return false;
-  Argument<A1> arg1(list, 0);
-  if (!arg1.valid())
-    return false;
-  handler.Run(arg1.value());
-  return true;
-}
-
-template <class A1, class A2>
-bool ParseAndHandle2(const base::Callback<void(A1, A2)>& handler,
-                     const base::ListValue& list) {
-  if (list.GetSize() != 2)
-    return false;
-  Argument<A1> arg1(list, 0);
-  if (!arg1.valid())
-    return false;
-  Argument<A2> arg2(list, 1);
-  if (!arg2.valid())
-    return false;
-  handler.Run(arg1.value(), arg2.value());
-  return true;
-}
-
-template <class A1, class A2, class A3>
-bool ParseAndHandle3(const base::Callback<void(A1, A2, A3)>& handler,
-                     const base::ListValue& list) {
-  if (list.GetSize() != 3)
-    return false;
-  Argument<A1> arg1(list, 0);
-  if (!arg1.valid())
-    return false;
-  Argument<A2> arg2(list, 1);
-  if (!arg2.valid())
-    return false;
-  Argument<A3> arg3(list, 2);
-  if (!arg3.valid())
-    return false;
-  handler.Run(arg1.value(), arg2.value(), arg3.value());
-  return true;
-}
-
-template <class A1, class A2, class A3, class A4>
-bool ParseAndHandle4(const base::Callback<void(A1, A2, A3, A4)>& handler,
-                     const base::ListValue& list) {
-  if (list.GetSize() != 4)
-    return false;
-  Argument<A1> arg1(list, 0);
-  if (!arg1.valid())
-    return false;
-  Argument<A2> arg2(list, 1);
-  if (!arg2.valid())
-    return false;
-  Argument<A3> arg3(list, 2);
-  if (!arg3.valid())
-    return false;
-  Argument<A4> arg4(list, 3);
-  if (!arg4.valid())
-    return false;
-  handler.Run(arg1.value(), arg2.value(), arg3.value(), arg4.value());
-  return true;
-}
-
 } // 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.
  */
@@ skipping 14 matching lines @@
     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;
   }
 
-  template<class T>
+  template<typename T, typename... As>
   void RegisterHandler(const std::string& method,
-                       void (T::*handler)(), T* delegate) {
-    handlers_[method] = base::Bind(&ParseAndHandle0,
+                       void (T::*handler)(As...), T* delegate) {
+    handlers_[method] = base::Bind(&ParseAndHandle<As...>,
                                    base::Bind(handler,
                                               base::Unretained(delegate)));
   }
-
-  template<class T, class A1>
-  void RegisterHandler(const std::string& method,
-                       void (T::*handler)(A1), T* delegate) {
-    handlers_[method] = base::Bind(ParseAndHandle1<A1>,
-                                   base::Bind(handler,
-                                              base::Unretained(delegate)));
-  }
-
-  template<class T, class A1, class A2>
-  void RegisterHandler(const std::string& method,
-                       void (T::*handler)(A1, A2), T* delegate) {
-    handlers_[method] = base::Bind(ParseAndHandle2<A1, A2>,
-                                   base::Bind(handler,
-                                              base::Unretained(delegate)));
-  }
-
-  template<class T, class A1, class A2, class A3>
-  void RegisterHandler(const std::string& method,
-                       void (T::*handler)(A1, A2, A3), T* delegate) {
-    handlers_[method] = base::Bind(ParseAndHandle3<A1, A2, A3>,
-                                   base::Bind(handler,
-                                              base::Unretained(delegate)));
-  }
-
-  template<class T, class A1, class A2, class A3, class A4>
-  void RegisterHandler(const std::string& method,
-                       void (T::*handler)(A1, A2, A3, A4), T* delegate) {
-    handlers_[method] = base::Bind(ParseAndHandle4<A1, A2, A3, A4>,
-                                   base::Bind(handler,
-                                              base::Unretained(delegate)));
-  }
 
  private:
   typedef std::map<std::string, Handler> HandlerMap;
   HandlerMap handlers_;
 };
 
 
 DevToolsEmbedderMessageDispatcher*
     DevToolsEmbedderMessageDispatcher::createForDevToolsFrontend(
         Delegate* delegate) {
@@ skipping 31 matching lines @@
   d->RegisterHandler("setDeviceCountUpdatesEnabled",
                      &Delegate::SetDeviceCountUpdatesEnabled, delegate);
   d->RegisterHandler("setDevicesUpdatesEnabled",
                      &Delegate::SetDevicesUpdatesEnabled, delegate);
   d->RegisterHandler("sendMessageToBrowser",
                      &Delegate::SendMessageToBrowser, delegate);
   d->RegisterHandler("recordActionUMA",
                      &Delegate::RecordActionUMA, delegate);
   return d;
 }