V8ValueConverter for the activity logger that does not invoke interceptors and

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/float_util.h"
 #include "base/logging.h"
@@ skipping 68 matching lines @@
 
 V8ValueConverter* V8ValueConverter::create() {
   return new V8ValueConverterImpl();
 }
 
 V8ValueConverterImpl::V8ValueConverterImpl()
     : date_allowed_(false),
       reg_exp_allowed_(false),
       function_allowed_(false),
       strip_null_from_objects_(false),
-      avoid_identity_hash_for_testing_(false) {}
+      avoid_identity_hash_for_testing_(false),
+      strategy_(NULL) {}
 
 void V8ValueConverterImpl::SetDateAllowed(bool val) {
   date_allowed_ = val;
 }
 
 void V8ValueConverterImpl::SetRegExpAllowed(bool val) {
   reg_exp_allowed_ = val;
 }
 
 void V8ValueConverterImpl::SetFunctionAllowed(bool val) {
   function_allowed_ = val;
 }
 
 void V8ValueConverterImpl::SetStripNullFromObjects(bool val) {
   strip_null_from_objects_ = val;
 }
 
+void V8ValueConverterImpl::SetStrategy(Strategy* strategy) {
+  strategy_ = strategy;
+}
+
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
     const base::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 {
@@ skipping 178 matching lines @@
   if (!state->UpdateAndCheckUniqueness(val))
     return base::Value::CreateNullValue();
 
   scoped_ptr<v8::Context::Scope> scope;
   // If val was created in a different context than our current one, change to
   // that context, but change back after val is converted.
   if (!val->CreationContext().IsEmpty() &&
       val->CreationContext() != v8::Context::GetCurrent())
     scope.reset(new v8::Context::Scope(val->CreationContext()));
 
+  if (strategy_) {
+    Value* out = NULL;
+    if (strategy_->FromV8Array(val, &out))
+      return out;
+  }
+
   base::ListValue* result = new base::ListValue();
 
   // Only fields with integer keys are carried over to the ListValue.
   for (uint32 i = 0; i < val->Length(); ++i) {
     v8::TryCatch try_catch;
     v8::Handle<v8::Value> child_v8 = val->Get(i);
     if (try_catch.HasCaught()) {
       LOG(ERROR) << "Getter for index " << i << " threw an exception.";
       child_v8 = v8::Null();
     }
@@ skipping 35 matching lines @@
     return base::BinaryValue::CreateWithCopiedBuffer(data, length);
   else
     return NULL;
 }
 
 base::Value* V8ValueConverterImpl::FromV8Object(
     v8::Handle<v8::Object> val,
     FromV8ValueState* state) const {
   if (!state->UpdateAndCheckUniqueness(val))
     return base::Value::CreateNullValue();
+
   scoped_ptr<v8::Context::Scope> scope;
   // If val was created in a different context than our current one, change to
   // that context, but change back after val is converted.
   if (!val->CreationContext().IsEmpty() &&
       val->CreationContext() != v8::Context::GetCurrent())
     scope.reset(new v8::Context::Scope(val->CreationContext()));
 
+  if (strategy_) {
+    Value* out = NULL;
+    if (strategy_->FromV8Object(val, &out))
+      return out;
+  }
+
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   v8::Handle<v8::Array> property_names(val->GetOwnPropertyNames());
 
   for (uint32 i = 0; i < property_names->Length(); ++i) {
     v8::Handle<v8::Value> key(property_names->Get(i));
 
     // Extend this test to cover more types as necessary and if sensible.
     if (!key->IsString() &&
         !key->IsNumber()) {
       NOTREACHED() << "Key \"" << *v8::String::AsciiValue(key) << "\" "
@@ skipping 42 matching lines @@
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     child.release());
   }
 
   return result.release();
 }
 
 }  // namespace content