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#ifndef GIN_ARGUMENTS_H_
6#define GIN_ARGUMENTS_H_
7
8#include "base/basictypes.h"
9#include "gin/converter.h"
10#include "gin/gin_export.h"
11
12namespace gin {
13
14// Arguments is a wrapper around v8::FunctionCallbackInfo that integrates
15// with Converter to make it easier to marshall arguments and return values
16// between V8 and C++.
17class GIN_EXPORT Arguments {
18 public:
19  Arguments();
20  explicit Arguments(const v8::FunctionCallbackInfo<v8::Value>& info);
21  ~Arguments();
22
23  template<typename T>
24  bool GetHolder(T* out) {
25    return ConvertFromV8(isolate_, info_->Holder(), out);
26  }
27
28  template<typename T>
29  bool GetData(T* out) {
30    return ConvertFromV8(isolate_, info_->Data(), out);
31  }
32
33  template<typename T>
34  bool GetNext(T* out) {
35    if (next_ >= info_->Length()) {
36      insufficient_arguments_ = true;
37      return false;
38    }
39    v8::Handle<v8::Value> val = (*info_)[next_++];
40    return ConvertFromV8(isolate_, val, out);
41  }
42
43  template<typename T>
44  bool GetRemaining(std::vector<T>* out) {
45    if (next_ >= info_->Length()) {
46      insufficient_arguments_ = true;
47      return false;
48    }
49    int remaining = info_->Length() - next_;
50    out->resize(remaining);
51    for (int i = 0; i < remaining; ++i) {
52      v8::Handle<v8::Value> val = (*info_)[next_++];
53      if (!ConvertFromV8(isolate_, val, &out->at(i)))
54        return false;
55    }
56    return true;
57  }
58
59  bool Skip() {
60    if (next_ >= info_->Length())
61      return false;
62    next_++;
63    return true;
64  }
65
66  int Length() const {
67    return info_->Length();
68  }
69
70  template<typename T>
71  void Return(T val) {
72    info_->GetReturnValue().Set(ConvertToV8(isolate_, val));
73  }
74
75  v8::Handle<v8::Value> PeekNext() const;
76
77  void ThrowError() const;
78  void ThrowTypeError(const std::string& message) const;
79
80  v8::Isolate* isolate() const { return isolate_; }
81
82  // Allows the function handler to distinguish between normal invocation
83  // and object construction.
84  bool IsConstructCall() const;
85
86 private:
87  v8::Isolate* isolate_;
88  const v8::FunctionCallbackInfo<v8::Value>* info_;
89  int next_;
90  bool insufficient_arguments_;
91};
92
93}  // namespace gin
94
95#endif  // GIN_ARGUMENTS_H_
96