Introduce MockResourceConverter to modularize testing of V8VarConverter

content/renderer/pepper/v8_var_converter_unittest.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/pepper/v8_var_converter.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
+#include "content/renderer/pepper/resource_converter.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/test_globals.h"
 #include "ppapi/shared_impl/unittest_utils.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 using ppapi::ArrayBufferVar;
 using ppapi::ArrayVar;
 using ppapi::DictionaryVar;
 using ppapi::PpapiGlobals;
 using ppapi::ProxyLock;
 using ppapi::ScopedPPVar;
 using ppapi::StringVar;
 using ppapi::TestGlobals;
 using ppapi::TestEqual;
 using ppapi::VarTracker;
 
 namespace content {
 
 namespace {
 
+class MockResourceConverter : public content::ResourceConverter {
+ public:
+  virtual ~MockResourceConverter() {}
+  virtual void ShutDown(const base::Callback<void(bool)>& callback) OVERRIDE {
+    callback.Run(true);
+  }
+};
+
 // Maps PP_Var IDs to the V8 value handle they correspond to.
 typedef base::hash_map<int64_t, v8::Handle<v8::Value> > VarHandleMap;
 
 bool Equals(const PP_Var& var,
             v8::Handle<v8::Value> val,
             VarHandleMap* visited_ids) {
   if (ppapi::VarTracker::IsVarTypeRefcounted(var.type)) {
     VarHandleMap::iterator it = visited_ids->find(var.value.as_id);
     if (it != visited_ids->end())
       return it->second == val;
@@ skipping 79 matching lines @@
 }
 
 class V8VarConverterTest : public testing::Test {
  public:
   V8VarConverterTest()
       : isolate_(v8::Isolate::GetCurrent()),
         conversion_success_(false),
         conversion_event_(true, false),
         callback_thread_("callback_thread") {
     callback_thread_.Start();
+    converter_.reset(new V8VarConverter(
+        callback_thread_.message_loop_proxy(),
+        scoped_ptr<ResourceConverter>(new MockResourceConverter).Pass()));
   }
   virtual ~V8VarConverterTest() {}
 
   // testing::Test implementation.
   virtual void SetUp() {
     ProxyLock::Acquire();
     v8::HandleScope handle_scope(isolate_);
     v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
     context_.Reset(isolate_, v8::Context::New(isolate_, NULL, global));
   }
   virtual void TearDown() {
     context_.Dispose();
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }
 
  protected:
   bool FromV8ValueSync(v8::Handle<v8::Value> val,
                        v8::Handle<v8::Context> context,
                        PP_Var* result) {
-    V8VarConverter::FromV8Value(val, context, base::Bind(
-        &V8VarConverterTest::FromV8ValueComplete, base::Unretained(this)),
-        callback_thread_.message_loop_proxy());
+    converter_->FromV8Value(val, context, base::Bind(
+        &V8VarConverterTest::FromV8ValueComplete, base::Unretained(this)));
     conversion_event_.Wait();
     conversion_event_.Reset();
     if (conversion_success_)
       *result = conversion_result_;
     return conversion_success_;
   }
 
   void FromV8ValueComplete(const ScopedPPVar& scoped_var, bool success) {
     conversion_success_ = success;
     if (success) {
       ScopedPPVar var = scoped_var;
       conversion_result_ = var.Release();
     }
     conversion_event_.Signal();
   }
 
   bool RoundTrip(const PP_Var& var, PP_Var* result) {
     v8::HandleScope handle_scope(isolate_);
     v8::Context::Scope context_scope(isolate_, context_);
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, context_);
     v8::Handle<v8::Value> v8_result;
-    if (!V8VarConverter::ToV8Value(var, context, &v8_result))
+    if (!converter_->ToV8Value(var, context, &v8_result))
       return false;
     if (!Equals(var, v8_result))
       return false;
     if (!FromV8ValueSync(v8_result, context, result))
       return false;
     return true;
   }
 
   // Assumes a ref for var.
   bool RoundTripAndCompare(const PP_Var& var) {
     ScopedPPVar expected(ScopedPPVar::PassRef(), var);
     PP_Var actual_var;
     if (!RoundTrip(expected.get(), &actual_var))
       return false;
     ScopedPPVar actual(ScopedPPVar::PassRef(), actual_var);
     return TestEqual(expected.get(), actual.get());
   }
 
   v8::Isolate* isolate_;
 
   // Context for the JavaScript in the test.
   v8::Persistent<v8::Context> context_;
 
+  scoped_ptr<V8VarConverter> converter_;
+
  private:
   TestGlobals globals_;
 
   PP_Var conversion_result_;
   bool conversion_success_;
   base::WaitableEvent conversion_event_;
   base::Thread callback_thread_;
 };
 
 }  // namespace
@@ skipping 98 matching lines @@
     scoped_refptr<ArrayVar> array(new ArrayVar);
     ScopedPPVar release_array(ScopedPPVar::PassRef(), array->GetPPVar());
 
     dictionary->SetWithStringKey("1", release_array.get());
     array->Set(0, release_dictionary.get());
 
     v8::Handle<v8::Value> v8_result;
 
     // Array <-> dictionary cycle.
     dictionary->SetWithStringKey("1", release_array.get());
-    ASSERT_FALSE(V8VarConverter::ToV8Value(release_dictionary.get(),
-                                           context, &v8_result));
+    ASSERT_FALSE(converter_->ToV8Value(release_dictionary.get(),
+                                       context, &v8_result));
     // Break the cycle.
     // TODO(raymes): We need some better machinery for releasing vars with
     // cycles. Remove the code below once we have that.
     dictionary->DeleteWithStringKey("1");
 
     // Array with self reference.
     array->Set(0, release_array.get());
-    ASSERT_FALSE(V8VarConverter::ToV8Value(release_array.get(),
-                                           context, &v8_result));
+    ASSERT_FALSE(converter_->ToV8Value(release_array.get(),
+                                       context, &v8_result));
     // Break the self reference.
     array->Set(0, PP_MakeUndefined());
   }
 
   // V8->Var conversion.
   {
     v8::Handle<v8::Object> object = v8::Object::New();
     v8::Handle<v8::Array> array = v8::Array::New();
 
     PP_Var var_result;
@@ skipping 59 matching lines @@
     ScopedPPVar oops(ScopedPPVar::PassRef(), StringVar::StringToPPVar("oops"));
     expected->SetWithStringKey("undefined", oops.get());
     ScopedPPVar release_expected(
         ScopedPPVar::PassRef(), expected->GetPPVar());
 
     ASSERT_TRUE(TestEqual(release_expected.get(), release_actual.get()));
   }
 }
 
 }  // namespace content