Introduce MockResourceConverter to modularize testing of V8VarConverter

content/renderer/pepper/v8_var_converter.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 "content/renderer/pepper/v8_var_converter.h"
 
 #include <map>
 #include <stack>
 #include <string>
 
@@ skipping 46 matching lines @@
   }
 };
 #elif defined(COMPILER_MSVC)
 inline size_t hash_value(const HashedHandle& handle) {
   return handle.hash();
 }
 #endif
 }  // namespace BASE_HASH_NAMESPACE
 
 namespace content {
-namespace V8VarConverter {
 
 namespace {
 
 // Maps PP_Var IDs to the V8 value handle they correspond to.
 typedef base::hash_map<int64_t, v8::Handle<v8::Value> > VarHandleMap;
 typedef base::hash_set<int64_t> ParentVarSet;
 
 // Maps V8 value handles to the PP_Var they correspond to.
 typedef base::hash_map<HashedHandle, ScopedPPVar> HandleVarMap;
 typedef base::hash_set<HashedHandle> ParentHandleSet;
@@ skipping 150 matching lines @@
   }
   return true;
 }
 
 bool CanHaveChildren(PP_Var var) {
   return var.type == PP_VARTYPE_ARRAY || var.type == PP_VARTYPE_DICTIONARY;
 }
 
 }  // namespace
 
+V8VarConverter::V8VarConverter()
+    : message_loop_proxy_(base::MessageLoopProxy::current()),
+      resource_converter_(new ResourceConverterImpl()) {
+}
+
+V8VarConverter::V8VarConverter(
+    const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
+    scoped_ptr<ResourceConverter> resource_converter)
+    : message_loop_proxy_(message_loop_proxy),
+      resource_converter_(resource_converter.release()) {
+}
+
+V8VarConverter::~V8VarConverter() {
+}
+
 // To/FromV8Value use a stack-based DFS search to traverse V8/Var graph. Each
 // iteration, the top node on the stack examined. If the node has not been
 // visited yet (i.e. sentinel == false) then it is added to the list of parents
 // which contains all of the nodes on the path from the start node to the
 // current node. Each of the current nodes children are examined. If they appear
 // in the list of parents it means we have a cycle and we return NULL.
 // Otherwise, if they can have children, we add them to the stack. If the
 // node at the top of the stack has already been visited, then we pop it off the
 // stack and erase it from the list of parents.
 // static
-bool ToV8Value(const PP_Var& var,
-               v8::Handle<v8::Context> context,
-               v8::Handle<v8::Value>* result) {
+bool V8VarConverter::ToV8Value(const PP_Var& var,
+                               v8::Handle<v8::Context> context,
+                               v8::Handle<v8::Value>* result) {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope;
 
   VarHandleMap visited_ids;
   ParentVarSet parent_ids;
 
   std::stack<StackEntry<PP_Var> > stack;
   stack.push(StackEntry<PP_Var>(var));
   v8::Handle<v8::Value> root;
   bool is_root = true;
@@ skipping 80 matching lines @@
           return false;
         }
       }
     }
   }
 
   *result = handle_scope.Close(root);
   return true;
 }
 
-void FromV8Value(
+void V8VarConverter::FromV8Value(
     v8::Handle<v8::Value> val,
     v8::Handle<v8::Context> context,
-    const base::Callback<void(const ScopedPPVar&, bool)>& callback,
-    const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy) {
+    const base::Callback<void(const ScopedPPVar&, bool)>& callback) {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope;
 
   HandleVarMap visited_handles;
   ParentHandleSet parent_handles;
 
-  ResourceConverter resource_converter;
-
   std::stack<StackEntry<v8::Handle<v8::Value> > > stack;
   stack.push(StackEntry<v8::Handle<v8::Value> >(val));
   ScopedPPVar root;
   bool is_root = true;
 
   while (!stack.empty()) {
     v8::Handle<v8::Value> current_v8 = stack.top().val;
     PP_Var current_var;
 
     if (stack.top().sentinel) {
       stack.pop();
       if (current_v8->IsObject())
         parent_handles.erase(HashedHandle(current_v8->ToObject()));
       continue;
     } else {
       stack.top().sentinel = true;
     }
 
     bool did_create = false;
     if (!GetOrCreateVar(current_v8, &current_var, &did_create,
                         &visited_handles, &parent_handles,
-                        &resource_converter)) {
-      message_loop_proxy->PostTask(FROM_HERE,
+                        resource_converter_.get())) {
+      message_loop_proxy_->PostTask(FROM_HERE,
           base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
       return;
     }
 
     if (is_root) {
       is_root = false;
       root = current_var;
     }
 
     // Add child nodes to the stack.
     if (current_var.type == PP_VARTYPE_ARRAY) {
       DCHECK(current_v8->IsArray());
       v8::Handle<v8::Array> v8_array = current_v8.As<v8::Array>();
       parent_handles.insert(HashedHandle(v8_array));
 
       ArrayVar* array_var = ArrayVar::FromPPVar(current_var);
       if (!array_var) {
         NOTREACHED();
-        message_loop_proxy->PostTask(FROM_HERE,
+        message_loop_proxy_->PostTask(FROM_HERE,
             base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
         return;
       }
 
       for (uint32 i = 0; i < v8_array->Length(); ++i) {
         v8::TryCatch try_catch;
         v8::Handle<v8::Value> child_v8 = v8_array->Get(i);
         if (try_catch.HasCaught()) {
-          message_loop_proxy->PostTask(FROM_HERE,
+          message_loop_proxy_->PostTask(FROM_HERE,
               base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
           return;
         }
 
         if (!v8_array->HasRealIndexedProperty(i))
           continue;
 
         PP_Var child_var;
         if (!GetOrCreateVar(child_v8, &child_var, &did_create,
                             &visited_handles, &parent_handles,
-                            &resource_converter)) {
-          message_loop_proxy->PostTask(FROM_HERE,
+                            resource_converter_.get())) {
+          message_loop_proxy_->PostTask(FROM_HERE,
               base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
           return;
         }
         if (did_create && child_v8->IsObject())
           stack.push(child_v8);
 
         array_var->Set(i, child_var);
       }
     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
       DCHECK(current_v8->IsObject());
       v8::Handle<v8::Object> v8_object = current_v8->ToObject();
       parent_handles.insert(HashedHandle(v8_object));
 
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
-        message_loop_proxy->PostTask(FROM_HERE,
+        message_loop_proxy_->PostTask(FROM_HERE,
             base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
         return;
       }
 
       v8::Handle<v8::Array> property_names(v8_object->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) << "\" "
                           "is neither a string nor a number";
-          message_loop_proxy->PostTask(FROM_HERE,
+          message_loop_proxy_->PostTask(FROM_HERE,
               base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
           return;
         }
 
         // Skip all callbacks: crbug.com/139933
         if (v8_object->HasRealNamedCallbackProperty(key->ToString()))
           continue;
 
         v8::String::Utf8Value name_utf8(key->ToString());
 
         v8::TryCatch try_catch;
         v8::Handle<v8::Value> child_v8 = v8_object->Get(key);
         if (try_catch.HasCaught()) {
-          message_loop_proxy->PostTask(FROM_HERE,
+          message_loop_proxy_->PostTask(FROM_HERE,
               base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
           return;
         }
 
         PP_Var child_var;
         if (!GetOrCreateVar(child_v8, &child_var, &did_create,
                             &visited_handles, &parent_handles,
-                            &resource_converter)) {
-          message_loop_proxy->PostTask(FROM_HERE,
+                            resource_converter_.get())) {
+          message_loop_proxy_->PostTask(FROM_HERE,
               base::Bind(callback, ScopedPPVar(PP_MakeUndefined()), false));
           return;
         }
         if (did_create && child_v8->IsObject())
           stack.push(child_v8);
 
         bool success = dict_var->SetWithStringKey(
             std::string(*name_utf8, name_utf8.length()), child_var);
         DCHECK(success);
       }
     }
   }
-  resource_converter.ShutDown(base::Bind(callback, root), message_loop_proxy);
+  resource_converter_->ShutDown(base::Bind(callback, root));
 }
 
-void FromV8Value(
-    v8::Handle<v8::Value> val,
-    v8::Handle<v8::Context> context,
-    const base::Callback<void(const ScopedPPVar&, bool)>& callback) {
-  FromV8Value(val, context, callback, base::MessageLoopProxy::current());
-}
-
-}  // namespace V8VarConverter
 }  // namespace content