[DevTools] Use special resizing strategy instead of insets.

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::ListValue& list, int pos, int& value) {
   return list.GetInteger(pos, &value);
 }
 
 bool GetValue(const base::ListValue& list, int pos, bool& value) {
   return list.GetBoolean(pos, &value);
 }
 
+bool GetValue(const base::ListValue& list, int pos,

[pfeldman, 2014/01/31 11:28:30]

I'd rather define traits for Insets and Size

[dgozman, 2014/01/31 13:33:13]

Done.

+    DevToolsContentsResizingStrategy& strategy) {
+  const base::DictionaryValue* dict;
+  if (!list.GetDictionary(pos, &dict))
+    return false;
+  const base::DictionaryValue* insets;
+  if (!dict->GetDictionary("insets", &insets))
+    return false;
+  int top = 0;
+  int left = 0;
+  int bottom = 0;
+  int right = 0;
+  if (!insets->GetInteger("top", &top) ||
+      !insets->GetInteger("left", &left) ||
+      !insets->GetInteger("bottom", &bottom) ||
+      !insets->GetInteger("right", &right))
+    return false;
+  strategy.insets.Set(top, left, bottom, right);
+  const base::DictionaryValue* min_size;
+  if (!dict->GetDictionary("min_size", &min_size))
+    return false;
+  int width = 0;
+  int height = 0;
+  if (!min_size->GetInteger("width", &width) ||
+      !min_size->GetInteger("height", &height))
+    return false;
+  strategy.min_size.SetSize(width, height);
+  return true;
+}
+
 template <typename T>
 struct StorageTraits {
   typedef T StorageType;
 };
 
 template <typename T>
 struct StorageTraits<const T&> {
   typedef T StorageType;
 };
 
@@ skipping 120 matching lines @@
     Delegate* delegate) {
   RegisterHandler("bringToFront",
       BindToListParser(base::Bind(&Delegate::ActivateWindow,
                                   base::Unretained(delegate))));
   RegisterHandler("closeWindow",
       BindToListParser(base::Bind(&Delegate::CloseWindow,
                                   base::Unretained(delegate))));
   RegisterHandler("setContentsInsets",
       BindToListParser(base::Bind(&Delegate::SetContentsInsets,
                                   base::Unretained(delegate))));
+  RegisterHandler("setContentsResizingStrategy",
+      BindToListParser(base::Bind(&Delegate::SetContentsResizingStrategy,
+                                  base::Unretained(delegate))));
   RegisterHandler("moveWindowBy",
       BindToListParser(base::Bind(&Delegate::MoveWindow,
                                   base::Unretained(delegate))));
   RegisterHandler("setIsDocked",
       BindToListParser(base::Bind(&Delegate::SetIsDocked,
                                   base::Unretained(delegate))));
   RegisterHandler("openInNewTab",
       BindToListParser(base::Bind(&Delegate::OpenInNewTab,
                                   base::Unretained(delegate))));
   RegisterHandler("save",
@@ skipping 36 matching lines @@
 
   if (!it->second.Run(*params))
     return "Invalid frontend host message parameters: " + method;
   return "";
 }
 
 void DevToolsEmbedderMessageDispatcher::RegisterHandler(
     const std::string& method, const Handler& handler) {
   handlers_[method] = handler;
 }