Support optional arguments in SendRequestNatives::StartRequest

content/renderer/v8_value_converter_impl.cc

 // Copyright (c) 2012 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 "content/renderer/v8_value_converter_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 11 matching lines @@
 
 namespace content {
 
 V8ValueConverter* V8ValueConverter::create() {
   return new V8ValueConverterImpl();
 }
 
 }
 
 V8ValueConverterImpl::V8ValueConverterImpl()
-    : allow_undefined_(false),
-      allow_date_(false),
-      allow_regexp_(false) {
+    : undefined_allowed_(false),
+      date_allowed_(false),
+      regexp_allowed_(false) {
+}
+
+bool V8ValueConverterImpl::GetUndefinedAllowed() const {
+  return undefined_allowed_;
+}
+
+void V8ValueConverterImpl::SetUndefinedAllowed(bool val) {
+  undefined_allowed_ = val;
+}
+
+bool V8ValueConverterImpl::GetDateAllowed() const {
+  return date_allowed_;
+}
+
+void V8ValueConverterImpl::SetDateAllowed(bool val) {
+  date_allowed_ = val;
+}
+
+bool V8ValueConverterImpl::GetRegexpAllowed() const {
+  return regexp_allowed_;
+}
+
+void V8ValueConverterImpl::SetRegexpAllowed(bool val) {
+  regexp_allowed_ = val;
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
     const Value* value, v8::Handle<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope;
   return handle_scope.Close(ToV8ValueImpl(value));
 }
 
 Value* V8ValueConverterImpl::FromV8Value(
@@ skipping 115 matching lines @@
     return Value::CreateIntegerValue(val->ToInt32()->Value());
 
   if (val->IsNumber())
     return Value::CreateDoubleValue(val->ToNumber()->Value());
 
   if (val->IsString()) {
     v8::String::Utf8Value utf8(val->ToString());
     return Value::CreateStringValue(std::string(*utf8, utf8.length()));
   }
 
-  if (allow_undefined_ && val->IsUndefined())
+  if (undefined_allowed_ && val->IsUndefined())
     return Value::CreateNullValue();
 
-  if (allow_date_ && val->IsDate()) {
+  if (date_allowed_ && val->IsDate()) {
     v8::Date* date = v8::Date::Cast(*val);
     return Value::CreateDoubleValue(date->NumberValue() / 1000.0);
   }
 
-  if (allow_regexp_ && val->IsRegExp()) {
+  if (regexp_allowed_ && val->IsRegExp()) {
     return Value::CreateStringValue(
         *v8::String::Utf8Value(val->ToString()));
   }
 
   // v8::Value doesn't have a ToArray() method for some reason.
   if (val->IsArray())
     return FromV8Array(val.As<v8::Array>());
 
   if (val->IsObject()) {
     BinaryValue* binary_value = FromV8Buffer(val);
@@ skipping 78 matching lines @@
     }
 
     Value* child = FromV8ValueImpl(child_v8);
     CHECK(child);
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     child);
   }
   return result;
 }