Enabling AdInjectionBrowserTest after Activity Log refactoring.

extensions/renderer/activity_log_converter_strategy.cc

 // Copyright 2014 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 "extensions/renderer/activity_log_converter_strategy.h"
 
 #include "base/logging.h"
 #include "base/values.h"
-#include "extensions/common/ad_injection_constants.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 namespace {
 
-typedef ActivityLogConverterStrategy::FromV8ValueCallback FromV8ValueCallback;
-
-namespace constants = ad_injection_constants;
-namespace keys = constants::keys;
-
-const char kFirstChildProperty[] = "firstElementChild";
-const char kNextElementSiblingProperty[] = "nextElementSibling";
-
-scoped_ptr<base::DictionaryValue> ParseV8Object(
-    v8::Isolate* isolate,
-    v8::Object* object,
-    const FromV8ValueCallback& callback);
-
-// Get a property from a V8 object without entering javascript. We use this
-// in order to examine the objects, while ensuring that we don't cause any
-// change in the running program.
-v8::Local<v8::Value> SafeGetProperty(v8::Isolate* isolate,
-                                     v8::Object* object,
-                                     const char* key) {
-  v8::TryCatch try_catch;
-  v8::Isolate::DisallowJavascriptExecutionScope scope(
-      isolate, v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE);
-  v8::Local<v8::String> key_string = v8::String::NewFromUtf8(isolate, key);
-  v8::Local<v8::Value> value = object->Get(key_string);
-  if (try_catch.HasCaught() || value.IsEmpty() || value->IsUndefined() ||
-      value->IsNull()) {
-    return v8::Local<v8::Value>();
-  }
-  return value;
-}
-
-// Append a property to the given |dict| from the given |object| if the
-// property exists on |object| and can be accessed safely (i.e., without
-// triggering any javascript execution).
-void MaybeAppendV8Property(v8::Isolate* isolate,
-                           v8::Object* object,
-                           const char* property_name,
-                           base::DictionaryValue* dict,
-                           const FromV8ValueCallback& callback) {
-  v8::Handle<v8::Value> value = SafeGetProperty(isolate, object, property_name);
-  if (!value.IsEmpty()) {
-    scoped_ptr<base::Value> parsed_value(callback.Run(value, isolate));
-    if (parsed_value.get())
-      dict->Set(property_name, parsed_value.release());
-  }
-}
-
-// Parse the children of a V8 |object| and return them as a list. This will
-// return an empty scoped_ptr if no children are present, or if the children
-// cannot be read safely (without triggering javascript).
-scoped_ptr<base::ListValue> MaybeParseV8Children(
-    v8::Isolate* isolate,
-    v8::Object* object,
-    const FromV8ValueCallback& callback) {
-  scoped_ptr<base::ListValue> parsed_children(new base::ListValue());
-  v8::Local<v8::Value> child_value =
-      SafeGetProperty(isolate, object, kFirstChildProperty);
-  size_t checked_children = 0u;
-  while (!child_value.IsEmpty() &&
-         child_value->IsObject() &&
-         checked_children < constants::kMaximumChildrenToCheck) {
-    ++checked_children;
-    v8::Handle<v8::Object> child_object = child_value->ToObject();
-    scoped_ptr<base::Value> parsed_child(
-        callback.Run(child_object, isolate));
-    if (parsed_child.get())
-      parsed_children->Append(parsed_child.release());
-    child_value =
-        SafeGetProperty(isolate, *child_object, kNextElementSiblingProperty);
-  }
-
-  return parsed_children->GetSize() > 0 ? parsed_children.Pass()
-                                        : scoped_ptr<base::ListValue>();
-}
-
-// Parse a V8 |object| into a DictionaryValue. This will examine the object
-// for a few important properties, including:
-// - href
-// - src
-// - children
-// These properties are necessary to analyze whether or not the object contains
-// ads, which may have been injected.
-scoped_ptr<base::DictionaryValue> ParseV8Object(
-    v8::Isolate* isolate,
-    v8::Object* object,
-    const FromV8ValueCallback& callback) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-
-  dict->SetString(keys::kType,
-                  *v8::String::Utf8Value(object->GetConstructorName()));
-
-  MaybeAppendV8Property(isolate, object, keys::kHref, dict.get(), callback);
-  MaybeAppendV8Property(isolate, object, keys::kSrc, dict.get(), callback);
-
-  scoped_ptr<base::ListValue> maybe_children =
-      MaybeParseV8Children(isolate, object, callback);
-  if (maybe_children.get())
-    dict->Set(keys::kChildren, maybe_children.release());
-
-  return dict.Pass();
-}
-
 // Summarize a V8 value. This performs a shallow conversion in all cases, and
 // returns only a string with a description of the value (e.g.,
 // "[HTMLElement]").
 scoped_ptr<base::Value> SummarizeV8Value(v8::Isolate* isolate,
                                          v8::Handle<v8::Object> object) {
   v8::TryCatch try_catch;
   v8::Isolate::DisallowJavascriptExecutionScope scope(
       isolate, v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE);
   v8::Local<v8::String> name = v8::String::NewFromUtf8(isolate, "[");
   if (object->IsFunction()) {
@@ skipping 15 matching lines @@
     return scoped_ptr<base::Value>(
         new base::StringValue("[JS Execution Exception]"));
   }
 
   return scoped_ptr<base::Value>(
       new base::StringValue(std::string(*v8::String::Utf8Value(name))));
 }
 
 }  // namespace
 
-ActivityLogConverterStrategy::ActivityLogConverterStrategy()
-    : enable_detailed_parsing_(false) {}
+ActivityLogConverterStrategy::ActivityLogConverterStrategy() {}
 
 ActivityLogConverterStrategy::~ActivityLogConverterStrategy() {}
 
 bool ActivityLogConverterStrategy::FromV8Object(
     v8::Handle<v8::Object> value,
     base::Value** out,
     v8::Isolate* isolate,
     const FromV8ValueCallback& callback) const {
   return FromV8Internal(value, out, isolate, callback);
 }
 
 bool ActivityLogConverterStrategy::FromV8Array(
     v8::Handle<v8::Array> value,
     base::Value** out,
     v8::Isolate* isolate,
     const FromV8ValueCallback& callback) const {
   return FromV8Internal(value, out, isolate, callback);
 }
 
 bool ActivityLogConverterStrategy::FromV8Internal(
     v8::Handle<v8::Object> value,
     base::Value** out,
     v8::Isolate* isolate,
     const FromV8ValueCallback& callback) const {
   scoped_ptr<base::Value> parsed_value;
-  if (enable_detailed_parsing_)
-    parsed_value = ParseV8Object(isolate, *value, callback);
-  if (!parsed_value.get())
-    parsed_value = SummarizeV8Value(isolate, value);
+  parsed_value = SummarizeV8Value(isolate, value);
   *out = parsed_value.release();
 
   return true;
 }
 
 }  // namespace extensions