V8ValueConverter for the activity logger that does not invoke interceptors and

chrome/renderer/extensions/activity_log_converter_strategy.cc

+// Copyright (c) 2013 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 "chrome/renderer/extensions/activity_log_converter_strategy.h"
+#include "base/values.h"
+
+namespace extensions {
+
+bool ActivityLogConverterStrategy::ToV8Value(const base::Value* value,
+                                             v8::Handle<v8::Value>* out) const {
+  return false; // Default V8ValueConverter behavior.
+}
+
+bool ActivityLogConverterStrategy::FromV8Value(v8::Handle<v8::Value> value,
+                                               base::Value** out) const {
+  if (!value->IsObject())
+    return false; // Default V8ValueConverter behavior.
+
+  // Handle JSObject.
+  // We cannot use value->Get(key/index) as there may be an accessor installed
+  // on the key/index. If that is the case, we will execute the getter function
+  // which may interfere with the JS execution environment in the way unexpected
+  // by a developer. Moreover, executing getter functions may lead to logging
+  // events unrelated to extension execution which are caused by the converter.
+  // One way to solve this problem is to make the converter to check if a getter
+  // installed on a property with the HasRealNamedProperty() and
+  // HasRealIndexedProperty() V8 API calls, and return NULL for such properties.
+  // This behavior must be regulated by a flag.
+
+  // We may want to convert and log certain properties of DOM elements. The way
+  // to do it is to obtain WebKit's DOM element from the JS object that wraps
+  // this element and access relevant properties on WebKit's DOM element. If we
+  // access these properties via JS wrapper object, an extension may disguise
+  // the real values by setting getter methods.
+
+  v8::Handle<v8::String> name = v8::String::New("[");
+
+  if (value->IsFunction()) {
+    name =  v8::String::Concat(name, v8::String::New("Function"));
+    v8::Handle<v8::Value> fname =
+        v8::Handle<v8::Function>::Cast(value)->GetName();
+    if (fname->IsString() && v8::Handle<v8::String>::Cast(fname)->Length()) {
+      name = v8::String::Concat(name, v8::String::New(" "));
+      name = v8::String::Concat(name, v8::Handle<v8::String>::Cast(fname));
+      name = v8::String::Concat(name, v8::String::New("()"));
+    }
+  } else {
+    name = v8::String::Concat(name, value->ToObject()->GetConstructorName());
+  }
+
+  name = v8::String::Concat(name, v8::String::New("]"));
+  v8::String::Utf8Value utf8(name);
+  *out = new base::StringValue(std::string(*utf8, utf8.length()));
+  return true;
+}
+
+}  // namespace extensions
+