Enable extension APIs for content scripts.

content/renderer/v8_value_converter_impl.cc

 // Copyright (c) 2011 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"
 #include "base/values.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
 V8ValueConverter* V8ValueConverter::create() {
   return new V8ValueConverterImpl();
 }
 
 }
 
 V8ValueConverterImpl::V8ValueConverterImpl()
     : allow_undefined_(false),
       allow_date_(false),
       allow_regexp_(false) {
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
-    Value* value, v8::Handle<v8::Context> context) const {
+    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(
     v8::Handle<v8::Value> val,
     v8::Handle<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope;
   return FromV8ValueImpl(val);
 }
 
-v8::Handle<v8::Value> V8ValueConverterImpl::ToV8ValueImpl(Value* value) const {
+v8::Handle<v8::Value> V8ValueConverterImpl::ToV8ValueImpl(
+     const Value* value) const {
   CHECK(value);
   switch (value->GetType()) {
     case Value::TYPE_NULL:
       return v8::Null();
 
     case Value::TYPE_BOOLEAN: {
       bool val = false;
       CHECK(value->GetAsBoolean(&val));
       return v8::Boolean::New(val);
     }
@@ skipping 10 matching lines @@
       return v8::Number::New(val);
     }
 
     case Value::TYPE_STRING: {
       std::string val;
       CHECK(value->GetAsString(&val));
       return v8::String::New(val.c_str(), val.length());
     }
 
     case Value::TYPE_LIST:
-      return ToV8Array(static_cast<ListValue*>(value));
+      return ToV8Array(static_cast<const ListValue*>(value));
 
     case Value::TYPE_DICTIONARY:
-      return ToV8Object(static_cast<DictionaryValue*>(value));
+      return ToV8Object(static_cast<const DictionaryValue*>(value));
 
     default:
       LOG(ERROR) << "Unexpected value type: " << value->GetType();
       return v8::Null();
   }
 }
 
-v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Array(ListValue* val) const {
+v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Array(
+    const ListValue* val) const {
   v8::Handle<v8::Array> result(v8::Array::New(val->GetSize()));
 
   for (size_t i = 0; i < val->GetSize(); ++i) {
     Value* child = NULL;
     CHECK(val->Get(i, &child));
 
     v8::Handle<v8::Value> child_v8 = ToV8ValueImpl(child);
     CHECK(!child_v8.IsEmpty());
 
     v8::TryCatch try_catch;
     result->Set(static_cast<uint32>(i), child_v8);
     if (try_catch.HasCaught())
       LOG(ERROR) << "Setter for index " << i << " threw an exception.";
   }
 
   return result;
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Object(
-    DictionaryValue* val) const {
+    const DictionaryValue* val) const {
   v8::Handle<v8::Object> result(v8::Object::New());
 
   for (DictionaryValue::key_iterator iter = val->begin_keys();
        iter != val->end_keys(); ++iter) {
     Value* child = NULL;
     CHECK(val->GetWithoutPathExpansion(*iter, &child));
 
     const std::string& key = *iter;
     v8::Handle<v8::Value> child_v8 = ToV8ValueImpl(child);
     CHECK(!child_v8.IsEmpty());
@@ skipping 99 matching lines @@
     }
 
     Value* child = FromV8ValueImpl(child_v8);
     CHECK(child);
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     child);
   }
   return result;
 }