[Extensions Bindings] Add support for updateArgumentsPreValidate

extensions/renderer/api_signature.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/api_signature.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "gin/arguments.h"
 
 namespace extensions {
 
 namespace {
 
 // A class to help with argument parsing. Note that this uses v8::Locals and
 // const&s because it's an implementation detail of the APISignature; this
 // should *only* be used directly on the stack!
 class ArgumentParser {
  public:
-  ArgumentParser(const std::vector<std::unique_ptr<ArgumentSpec>>& signature,
-                 gin::Arguments* arguments,
+  ArgumentParser(v8::Local<v8::Context> context,
+                 const std::vector<std::unique_ptr<ArgumentSpec>>& signature,
+                 const std::vector<v8::Local<v8::Value>>& arguments,
                  const ArgumentSpec::RefMap& type_refs,
                  std::string* error)
-    : context_(arguments->isolate()->GetCurrentContext()),
+    : context_(context),
       signature_(signature),
       arguments_(arguments),
       type_refs_(type_refs),
       error_(error) {}
 
   // Tries to parse the arguments against the expected signature, populating a
   // resulting list as it goes.
   bool ParseArguments();
 
  protected:
   v8::Isolate* GetIsolate() { return context_->GetIsolate(); }
 
  private:
+  v8::Local<v8::Value> next_argument() {
+    return current_index_ < arguments_.size() ?
+        arguments_[current_index_] : v8::Local<v8::Value>();
+  }
+
+  void consume_argument() {

[jbroman, 2016/12/23 22:37:06]

nit: This doesn't look like a simple getter/setter to me, so I think this ought
to be named ConsumeArgument.

[Devlin, 2016/12/28 19:02:39]

Not entirely sure I agree (it's basically just incrementing the internal member,
and I think incrementers are allowed to be hacker_case since they're largely
setters) - but given it's a private API in a .cc file, I don't feel strongly at
all :)

Done.

+    current_index_ = std::min(arguments_.size(), current_index_ + 1);
+  }
+
   // Attempts to match the next argument to the given |spec|.
   // If the next argument does not match and |spec| is optional, uses a null
   // value.
   // Returns true on success.
   bool ParseArgument(const ArgumentSpec& spec);
 
   // Attempts to parse the callback from the given |spec|. Returns true on
   // success.
   bool ParseCallback(const ArgumentSpec& spec);
 
   // Adds a null value to the parsed arguments.
   virtual void AddNull() = 0;
   // Returns a base::Value to be populated during argument matching.
   virtual std::unique_ptr<base::Value>* GetBuffer() = 0;
   // Adds a new parsed argument.
   virtual void AddParsedArgument(v8::Local<v8::Value> value) = 0;
   // Adds the parsed callback.
   virtual void SetCallback(v8::Local<v8::Function> callback) = 0;
 
   v8::Local<v8::Context> context_;
   const std::vector<std::unique_ptr<ArgumentSpec>>& signature_;
-  gin::Arguments* arguments_;
+  const std::vector<v8::Local<v8::Value>>& arguments_;
   const ArgumentSpec::RefMap& type_refs_;
   std::string* error_;
+  size_t current_index_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentParser);
 };
 
 class V8ArgumentParser : public ArgumentParser {
  public:
-  V8ArgumentParser(const std::vector<std::unique_ptr<ArgumentSpec>>& signature,
-                   gin::Arguments* arguments,
+  V8ArgumentParser(v8::Local<v8::Context> context,
+                   const std::vector<std::unique_ptr<ArgumentSpec>>& signature,
+                   const std::vector<v8::Local<v8::Value>>& arguments,
                    const ArgumentSpec::RefMap& type_refs,
                    std::string* error,
                    std::vector<v8::Local<v8::Value>>* values)
-      : ArgumentParser(signature, arguments, type_refs, error),
+      : ArgumentParser(context, signature, arguments, type_refs, error),
         values_(values) {}
 
  private:
   void AddNull() override { values_->push_back(v8::Null(GetIsolate())); }
   std::unique_ptr<base::Value>* GetBuffer() override { return nullptr; }
   void AddParsedArgument(v8::Local<v8::Value> value) override {
     values_->push_back(value);
   }
   void SetCallback(v8::Local<v8::Function> callback) override {
     values_->push_back(callback);
   }
 
   std::vector<v8::Local<v8::Value>>* values_;
 
   DISALLOW_COPY_AND_ASSIGN(V8ArgumentParser);
 };
 
 class BaseValueArgumentParser : public ArgumentParser {
  public:
   BaseValueArgumentParser(
+      v8::Local<v8::Context> context,
       const std::vector<std::unique_ptr<ArgumentSpec>>& signature,
-      gin::Arguments* arguments,
+      const std::vector<v8::Local<v8::Value>>& arguments,
       const ArgumentSpec::RefMap& type_refs,
       std::string* error,
       base::ListValue* list_value)
-      : ArgumentParser(signature, arguments, type_refs, error),
+      : ArgumentParser(context, signature, arguments, type_refs, error),
         list_value_(list_value) {}
 
   v8::Local<v8::Function> callback() { return callback_; }
 
  private:
   void AddNull() override {
     list_value_->Append(base::Value::CreateNullValue());
   }
   std::unique_ptr<base::Value>* GetBuffer() override { return &last_arg_; }
   void AddParsedArgument(v8::Local<v8::Value> value) override {
@@ skipping 26 matching lines @@
   size_t end_size =
       signature_has_callback ? signature_.size() - 1 : signature_.size();
   for (size_t i = 0; i < end_size; ++i) {
     if (!ParseArgument(*signature_[i]))
       return false;
   }
 
   if (signature_has_callback && !ParseCallback(*signature_.back()))
     return false;
 
-  if (!arguments_->PeekNext().IsEmpty())
+  if (current_index_ != arguments_.size())
     return false;  // Extra arguments aren't allowed.
 
   return true;
 }
 
 bool ArgumentParser::ParseArgument(const ArgumentSpec& spec) {
-  v8::Local<v8::Value> value = arguments_->PeekNext();
+  v8::Local<v8::Value> value = next_argument();
   if (value.IsEmpty() || value->IsNull() || value->IsUndefined()) {
     if (!spec.optional()) {
       *error_ = "Missing required argument: " + spec.name();
       return false;
     }
     // This is safe to call even if |arguments| is at the end (which can happen
     // if n optional arguments are omitted at the end of the signature).
-    arguments_->Skip();
+    consume_argument();
 
     AddNull();
     return true;
   }
 
   if (!spec.ParseArgument(context_, value, type_refs_, GetBuffer(), error_)) {
     if (!spec.optional()) {
       *error_ = "Missing required argument: " + spec.name();
       return false;
     }
 
     AddNull();
     return true;
   }
 
-  arguments_->Skip();
+  consume_argument();
   AddParsedArgument(value);
   return true;
 }
 
 bool ArgumentParser::ParseCallback(const ArgumentSpec& spec) {
-  v8::Local<v8::Value> value = arguments_->PeekNext();
+  v8::Local<v8::Value> value = next_argument();
   if (value.IsEmpty() || value->IsNull() || value->IsUndefined()) {
     if (!spec.optional()) {
       *error_ = "Missing required argument: " + spec.name();
       return false;
     }
-    arguments_->Skip();
+    consume_argument();
     return true;
   }
 
   if (!value->IsFunction()) {
     *error_ = "Argument is wrong type: " + spec.name();
     return false;
   }
 
-  arguments_->Skip();
+  consume_argument();
   SetCallback(value.As<v8::Function>());
   return true;
 }
 
 }  // namespace
 
 APISignature::APISignature(const base::ListValue& specification) {
   signature_.reserve(specification.GetSize());
   for (const auto& value : specification) {
     const base::DictionaryValue* param = nullptr;
     CHECK(value->GetAsDictionary(&param));
     signature_.push_back(base::MakeUnique<ArgumentSpec>(*param));
   }
 }
 
 APISignature::~APISignature() {}
 
-bool APISignature::ParseArgumentsToV8(gin::Arguments* arguments,
-                                      const ArgumentSpec::RefMap& type_refs,
-                                      std::vector<v8::Local<v8::Value>>* v8_out,
-                                      std::string* error) const {
+bool APISignature::ParseArgumentsToV8(
+    v8::Local<v8::Context> context,
+    const std::vector<v8::Local<v8::Value>>& arguments,
+    const ArgumentSpec::RefMap& type_refs,
+    std::vector<v8::Local<v8::Value>>* v8_out,
+    std::string* error) const {
   DCHECK(v8_out);
   std::vector<v8::Local<v8::Value>> v8_values;
-  V8ArgumentParser parser(signature_, arguments, type_refs, error, &v8_values);
+  V8ArgumentParser parser(
+      context, signature_, arguments, type_refs, error, &v8_values);
   if (!parser.ParseArguments())
     return false;
   *v8_out = std::move(v8_values);
   return true;
 }
 
 bool APISignature::ParseArgumentsToJSON(
-    gin::Arguments* arguments,
+    v8::Local<v8::Context> context,
+    const std::vector<v8::Local<v8::Value>>& arguments,
     const ArgumentSpec::RefMap& type_refs,
     std::unique_ptr<base::ListValue>* json_out,
     v8::Local<v8::Function>* callback_out,
     std::string* error) const {
   DCHECK(json_out);
   DCHECK(callback_out);
   std::unique_ptr<base::ListValue> json = base::MakeUnique<base::ListValue>();
   BaseValueArgumentParser parser(
-      signature_, arguments, type_refs, error, json.get());
+      context, signature_, arguments, type_refs, error, json.get());
   if (!parser.ParseArguments())
     return false;
   *json_out = std::move(json);
   *callback_out = parser.callback();
   return true;
 }
 
 }  // namespace extensions