chrome/browser/devtools/devtools_embedder_message_dispatcher.cc

   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.
   4
   5 #include "chrome/browser/devtools/devtools_embedder_message_dispatcher.h"
   6
   7 #include "base/bind.h"
   8 #include "base/values.h"
   9
  10 namespace {
  11
  12 bool GetValue(const base::ListValue& list, int pos, std::string& value) {
  13   return list.GetString(pos, &value);
  14 }
  15
  16 bool GetValue(const base::ListValue& list, int pos, int& value) {
  17   return list.GetInteger(pos, &value);
  18 }
  19
  20 bool GetValue(const base::ListValue& list, int pos, bool& value) {
  21   return list.GetBoolean(pos, &value);
  22 }
  23
  24 bool GetValue(const base::ListValue& list, int pos, gfx::Insets& insets) {
  25   const base::DictionaryValue* dict;
  26   if (!list.GetDictionary(pos, &dict))
  27     return false;
  28   int top = 0;
  29   int left = 0;
  30   int bottom = 0;
  31   int right = 0;
  32   if (!dict->GetInteger("top", &top) ||
  33       !dict->GetInteger("left", &left) ||
  34       !dict->GetInteger("bottom", &bottom) ||
  35       !dict->GetInteger("right", &right))
  36     return false;
  37   insets.Set(top, left, bottom, right);
  38   return true;
  39 }
  40
  41 bool GetValue(const base::ListValue& list, int pos, gfx::Size& size) {
  42   const base::DictionaryValue* dict;
  43   if (!list.GetDictionary(pos, &dict))
  44     return false;
  45   int width = 0;
  46   int height = 0;
  47   if (!dict->GetInteger("width", &width) ||
  48       !dict->GetInteger("height", &height))
  49     return false;
  50   size.SetSize(width, height);
  51   return true;
  52 }
  53
  54 template <typename T>
  55 struct StorageTraits {
  56   typedef T StorageType;
  57 };
  58
  59 template <typename T>
  60 struct StorageTraits<const T&> {
  61   typedef T StorageType;
  62 };
  63
  64 template <class A>
  65 class Argument {
  66  public:
  67   typedef typename StorageTraits<A>::StorageType ValueType;
  68
  69   Argument(const base::ListValue& list, int pos) {
  70     valid_ = GetValue(list, pos, value_);
  71   }
  72
  73   ValueType value() const { return value_; }
  74   bool valid() const { return valid_; }
  75
  76  private:
  77   ValueType value_;
  78   bool valid_;
  79 };
  80
  81 bool ParseAndHandle0(const base::Callback<void(void)>& handler,
  82                      const base::ListValue& list) {
  83   handler.Run();
  84   return true;
  85 }
  86
  87 template <class A1>
  88 bool ParseAndHandle1(const base::Callback<void(A1)>& handler,
  89                      const base::ListValue& list) {
  90   if (list.GetSize() != 1)
  91     return false;
  92   Argument<A1> arg1(list, 0);
  93   if (!arg1.valid())
  94     return false;
  95   handler.Run(arg1.value());
  96   return true;
  97 }
  98
  99 template <class A1, class A2>
 100 bool ParseAndHandle2(const base::Callback<void(A1, A2)>& handler,
 101                      const base::ListValue& list) {
 102   if (list.GetSize() != 2)
 103     return false;
 104   Argument<A1> arg1(list, 0);
 105   if (!arg1.valid())
 106     return false;
 107   Argument<A2> arg2(list, 1);
 108   if (!arg2.valid())
 109     return false;
 110   handler.Run(arg1.value(), arg2.value());
 111   return true;
 112 }
 113
 114 template <class A1, class A2, class A3>
 115 bool ParseAndHandle3(const base::Callback<void(A1, A2, A3)>& handler,
 116                      const base::ListValue& list) {
 117   if (list.GetSize() != 3)
 118     return false;
 119   Argument<A1> arg1(list, 0);
 120   if (!arg1.valid())
 121     return false;
 122   Argument<A2> arg2(list, 1);
 123   if (!arg2.valid())
 124     return false;
 125   Argument<A3> arg3(list, 2);
 126   if (!arg3.valid())
 127     return false;
 128   handler.Run(arg1.value(), arg2.value(), arg3.value());
 129   return true;
 130 }
 131
 132 template <class A1, class A2, class A3, class A4>
 133 bool ParseAndHandle3(const base::Callback<void(A1, A2, A3, A4)>& handler,
 134                      const base::ListValue& list) {
 135   if (list.GetSize() != 4)
 136     return false;
 137   Argument<A1> arg1(list, 0);
 138   if (!arg1.valid())
 139     return false;
 140   Argument<A2> arg2(list, 1);
 141   if (!arg2.valid())
 142     return false;
 143   Argument<A3> arg3(list, 2);
 144   if (!arg3.valid())
 145     return false;
 146   Argument<A4> arg4(list, 3);
 147   if (!arg4.valid())
 148     return false;
 149   handler.Run(arg1.value(), arg2.value(), arg3.value(), arg4.value());
 150   return true;
 151 }
 152
 153 typedef base::Callback<bool(const base::ListValue&)> ListValueParser;
 154
 155 ListValueParser BindToListParser(const base::Callback<void()>& handler) {
 156   return base::Bind(&ParseAndHandle0, handler);
 157 }
 158
 159 template <class A1>
 160 ListValueParser BindToListParser(const base::Callback<void(A1)>& handler) {
 161   return base::Bind(&ParseAndHandle1<A1>, handler);
 162 }
 163
 164 template <class A1, class A2>
 165 ListValueParser BindToListParser(const base::Callback<void(A1,A2)>& handler) {
 166   return base::Bind(&ParseAndHandle2<A1, A2>, handler);
 167 }
 168
 169 template <class A1, class A2, class A3>
 170 ListValueParser BindToListParser(
 171     const base::Callback<void(A1,A2,A3)>& handler) {
 172   return base::Bind(&ParseAndHandle3<A1, A2, A3>, handler);
 173 }
 174
 175 template <class A1, class A2, class A3, class A4>
 176 ListValueParser BindToListParser(
 177     const base::Callback<void(A1,A2,A3,A4)>& handler) {
 178   return base::Bind(&ParseAndHandle3<A1, A2, A3, A4>, handler);
 179 }
 180
 181 }  // namespace
 182
 183 DevToolsEmbedderMessageDispatcher::DevToolsEmbedderMessageDispatcher(
 184     Delegate* delegate) {
 185   RegisterHandler("bringToFront",
 186       BindToListParser(base::Bind(&Delegate::ActivateWindow,
 187                                   base::Unretained(delegate))));
 188   RegisterHandler("closeWindow",
 189       BindToListParser(base::Bind(&Delegate::CloseWindow,
 190                                   base::Unretained(delegate))));
 191   RegisterHandler("setContentsInsets",
 192       BindToListParser(base::Bind(&Delegate::SetContentsInsets,
 193                                   base::Unretained(delegate))));
 194   RegisterHandler("setContentsResizingStrategy",
 195       BindToListParser(base::Bind(&Delegate::SetContentsResizingStrategy,
 196                                   base::Unretained(delegate))));
 197   RegisterHandler("inspectElementCompleted",
 198         BindToListParser(base::Bind(&Delegate::InspectElementCompleted,
 199                                     base::Unretained(delegate))));
 200   RegisterHandler("moveWindowBy",
 201       BindToListParser(base::Bind(&Delegate::MoveWindow,
 202                                   base::Unretained(delegate))));
 203   RegisterHandler("setIsDocked",
 204       BindToListParser(base::Bind(&Delegate::SetIsDocked,
 205                                   base::Unretained(delegate))));
 206   RegisterHandler("openInNewTab",
 207       BindToListParser(base::Bind(&Delegate::OpenInNewTab,
 208                                   base::Unretained(delegate))));
 209   RegisterHandler("save",
 210       BindToListParser(base::Bind(&Delegate::SaveToFile,
 211                                   base::Unretained(delegate))));
 212   RegisterHandler("append",
 213       BindToListParser(base::Bind(&Delegate::AppendToFile,
 214                                   base::Unretained(delegate))));
 215   RegisterHandler("requestFileSystems",
 216       BindToListParser(base::Bind(&Delegate::RequestFileSystems,
 217                                   base::Unretained(delegate))));
 218   RegisterHandler("addFileSystem",
 219       BindToListParser(base::Bind(&Delegate::AddFileSystem,
 220                                   base::Unretained(delegate))));
 221   RegisterHandler("removeFileSystem",
 222       BindToListParser(base::Bind(&Delegate::RemoveFileSystem,
 223                                   base::Unretained(delegate))));
 224   RegisterHandler("upgradeDraggedFileSystemPermissions",
 225                   BindToListParser(
 226                       base::Bind(&Delegate::UpgradeDraggedFileSystemPermissions,
 227                                  base::Unretained(delegate))));
 228   RegisterHandler("indexPath",
 229       BindToListParser(base::Bind(&Delegate::IndexPath,
 230                                   base::Unretained(delegate))));
 231   RegisterHandler("stopIndexing",
 232       BindToListParser(base::Bind(&Delegate::StopIndexing,
 233                                   base::Unretained(delegate))));
 234   RegisterHandler("searchInPath",
 235       BindToListParser(base::Bind(&Delegate::SearchInPath,
 236                                   base::Unretained(delegate))));
 237   RegisterHandler("zoomIn",
 238       BindToListParser(base::Bind(&Delegate::ZoomIn,
 239                                   base::Unretained(delegate))));
 240   RegisterHandler("zoomOut",
 241       BindToListParser(base::Bind(&Delegate::ZoomOut,
 242                                   base::Unretained(delegate))));
 243   RegisterHandler("resetZoom",
 244       BindToListParser(base::Bind(&Delegate::ResetZoom,
 245                                   base::Unretained(delegate))));
 246 }
 247
 248 DevToolsEmbedderMessageDispatcher::~DevToolsEmbedderMessageDispatcher() {}
 249
 250 std::string DevToolsEmbedderMessageDispatcher::Dispatch(
 251     const std::string& method, base::ListValue* params) {
 252   HandlerMap::iterator it = handlers_.find(method);
 253   if (it == handlers_.end())
 254     return "Unsupported frontend host method: " + method;
 255
 256   if (!it->second.Run(*params))
 257     return "Invalid frontend host message parameters: " + method;
 258   return "";
 259 }
 260
 261 void DevToolsEmbedderMessageDispatcher::RegisterHandler(
 262     const std::string& method, const Handler& handler) {
 263   handlers_[method] = handler;
 264 }