[Extensions Bindings] Add support for maximum integers

extensions/renderer/argument_spec.cc

 // Copyright 2016 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 "extensions/renderer/argument_spec.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "extensions/renderer/api_type_reference_map.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
 
 namespace extensions {
 
 namespace {
 
 template <class T>
 bool ParseFundamentalValueHelper(v8::Local<v8::Value> arg,
                                  v8::Local<v8::Context> context,
                                  const base::Optional<int>& minimum,
+                                 const base::Optional<int>& maximum,
                                  std::unique_ptr<base::Value>* out_value) {
   T val;
   if (!gin::Converter<T>::FromV8(context->GetIsolate(), arg, &val))
     return false;
-  if (minimum && val < minimum.value())
+  if (minimum && val < *minimum)
+    return false;
+  if (maximum && val > *maximum)
     return false;
   if (out_value)
     *out_value = base::MakeUnique<base::Value>(val);
   return true;
 }
 
 }  // namespace
 
 ArgumentSpec::ArgumentSpec(const base::Value& value)
     : type_(ArgumentType::INTEGER), optional_(false) {
@@ skipping 47 matching lines @@
     type_ = ArgumentType::ANY;
   else if (type_string == "function")
     type_ = ArgumentType::FUNCTION;
   else
     NOTREACHED();
 
   int min = 0;
   if (dict->GetInteger("minimum", &min))
     minimum_ = min;
 
+  int max = 0;
+  if (dict->GetInteger("maximum", &max))
+    maximum_ = max;
+
   int min_length = 0;
   if (dict->GetInteger("minLength", &min_length) ||
       dict->GetInteger("minItems", &min_length)) {
     DCHECK_GE(min_length, 0);
     min_length_ = min_length;
   }
 
   int max_length = 0;
   if (dict->GetInteger("maxLength", &max_length) ||
       dict->GetInteger("maxItems", &max_length)) {
@@ skipping 129 matching lines @@
 
 bool ArgumentSpec::ParseArgumentToFundamental(
     v8::Local<v8::Context> context,
     v8::Local<v8::Value> value,
     std::unique_ptr<base::Value>* out_value,
     std::string* error) const {
   DCHECK(IsFundamentalType());
   switch (type_) {
     case ArgumentType::INTEGER:
       return ParseFundamentalValueHelper<int32_t>(value, context, minimum_,
-                                                  out_value);
+                                                  maximum_, out_value);
     case ArgumentType::DOUBLE:
       return ParseFundamentalValueHelper<double>(value, context, minimum_,
-                                                 out_value);
+                                                 maximum_, out_value);
     case ArgumentType::STRING: {
       if (!value->IsString())
         return false;
 
       v8::Local<v8::String> v8_string = value.As<v8::String>();
       size_t length = static_cast<size_t>(v8_string->Length());
       if (min_length_ && length < *min_length_) {
         *error = "Less than min length";
         return false;
       }
@@ skipping 218 matching lines @@
       return false;
     }
     if (type_ == ArgumentType::BINARY)
       DCHECK_EQ(base::Value::Type::BINARY, converted->GetType());
     *out_value = std::move(converted);
   }
   return true;
 }
 
 }  // namespace extensions