Change V8VarConverter::FromV8Value to complete synchronously if possible

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"
@@ skipping 25 matching lines @@
 using ppapi::ScopedPPVar;
 using ppapi::StringVar;
 using ppapi::TestGlobals;
 using ppapi::TestEqual;
 using ppapi::VarTracker;
 
 namespace content {
 
 namespace {
 
+void FromV8ValueComplete(const ScopedPPVar& scoped_var,
+                         bool success) {
+  NOTREACHED();
+}
+
 class MockResourceConverter : public content::ResourceConverter {
  public:
   virtual ~MockResourceConverter() {}
+  virtual void Reset() OVERRIDE {}
+  virtual bool NeedsFlush() OVERRIDE { return false; }
   virtual void Flush(const base::Callback<void(bool)>& callback) OVERRIDE {
-    callback.Run(true);
+    NOTREACHED();
   }
   virtual bool FromV8Value(v8::Handle<v8::Object> val,
                            v8::Handle<v8::Context> context,
                            PP_Var* result,
                            bool* was_resource) OVERRIDE {
     *was_resource = false;
     return true;
   }
   virtual bool ToV8Value(const PP_Var& var,
                          v8::Handle<v8::Context> context,
@@ skipping 88 matching lines @@
 }
 
 bool Equals(const PP_Var& var, v8::Handle<v8::Value> val) {
   VarHandleMap var_handle_map;
   return Equals(var, val, &var_handle_map);
 }
 
 class V8VarConverterTest : public testing::Test {
  public:
   V8VarConverterTest()
-      : isolate_(v8::Isolate::GetCurrent()), conversion_success_(false) {
+      : isolate_(v8::Isolate::GetCurrent()) {
     PP_Instance dummy = 1234;
     converter_.reset(new V8VarConverter(
         dummy,
         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(isolate_);
     context_.Reset(isolate_, v8::Context::New(isolate_, NULL, global));
   }
   virtual void TearDown() {
     context_.Reset();
     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) {
-    base::RunLoop loop;
-    converter_->FromV8Value(val,
-                            context,
-                            base::Bind(&V8VarConverterTest::FromV8ValueComplete,
-                                       base::Unretained(this),
-                                       loop.QuitClosure()));
-    loop.Run();
-    if (conversion_success_)
-      *result = conversion_result_;
-    return conversion_success_;
-  }
+    V8VarConverter::VarResult conversion_result =
+        converter_->FromV8Value(val,
+                                context,
+                                base::Bind(&FromV8ValueComplete));
+    DCHECK(conversion_result.completed_synchronously);
+    if (conversion_result.success)
+      *result = conversion_result.var.Release();
 
-  void FromV8ValueComplete(base::Closure quit_closure,
-                           const ScopedPPVar& scoped_var,
-                           bool success) {
-    conversion_success_ = success;
-    if (success) {
-      ScopedPPVar var = scoped_var;
-      conversion_result_ = var.Release();
-    }
-    quit_closure.Run();
+    return conversion_result.success;
   }
 
   bool RoundTrip(const PP_Var& var, PP_Var* result) {
     v8::HandleScope handle_scope(isolate_);
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, context_);
     v8::Context::Scope context_scope(context);
     v8::Handle<v8::Value> v8_result;
     if (!converter_->ToV8Value(var, context, &v8_result))
       return false;
@@ skipping 17 matching lines @@
   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::MessageLoop message_loop_;
 };
 
 }  // namespace
 
 TEST_F(V8VarConverterTest, SimpleRoundTripTest) {
   EXPECT_TRUE(RoundTripAndCompare(PP_MakeUndefined()));
   EXPECT_TRUE(RoundTripAndCompare(PP_MakeNull()));
   EXPECT_TRUE(RoundTripAndCompare(PP_MakeInt32(100)));
   EXPECT_TRUE(RoundTripAndCompare(PP_MakeBool(PP_TRUE)));
@@ skipping 188 matching lines @@
     expected->SetWithStringKey("null", quux.get());
     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(), true));
   }
 }
 
 }  // namespace content