[Extensions Bindings] Add a GetStringPropertyFromObject test method

extensions/renderer/api_event_handler_unittest.cc

 // Copyright 2016 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/api_event_handler.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 247 matching lines @@
         FunctionFromString(context, kAddListenerFunction);
     v8::Local<v8::Value> argv[] = {event, listener_function};
     RunFunction(add_listener_function, context, arraysize(argv), argv);
   }
 
   const char kArguments[] = "['foo',1,{'prop1':'bar'}]";
   std::unique_ptr<base::ListValue> event_args = ListValueFromString(kArguments);
   ASSERT_TRUE(event_args);
   handler.FireEventInContext(kEventName, context, *event_args);
 
-  std::unique_ptr<base::Value> result =
-      GetBaseValuePropertyFromObject(context->Global(), context, "eventArgs");
-  ASSERT_TRUE(result);
-  EXPECT_EQ(ReplaceSingleQuotes(kArguments), ValueToString(*result));
+  EXPECT_EQ(
+      ReplaceSingleQuotes(kArguments),
+      GetStringPropertyFromObject(context->Global(), context, "eventArgs"));
 }
 
 // Test dispatching events to multiple contexts.
 TEST_F(APIEventHandlerTest, MultipleContexts) {
   v8::HandleScope handle_scope(isolate());
 
   v8::Local<v8::Context> context_a = ContextLocal();
   v8::Local<v8::Context> context_b = v8::Context::New(isolate());
   gin::ContextHolder holder_b(isolate());
   holder_b.SetContext(context_b);
@@ skipping 39 matching lines @@
   EXPECT_EQ(1u, handler.GetNumEventListenersForTesting(kEventName, context_b));
 
   // Dispatch the event in context_a - the listener in context_b should not be
   // notified.
   std::unique_ptr<base::ListValue> arguments_a =
       ListValueFromString("['result_a:']");
   ASSERT_TRUE(arguments_a);
 
   handler.FireEventInContext(kEventName, context_a, *arguments_a);
   {
-    std::unique_ptr<base::Value> result_a = GetBaseValuePropertyFromObject(
-        context_a->Global(), context_a, "eventArgs");
-    ASSERT_TRUE(result_a);
-    EXPECT_EQ("\"result_a:alpha\"", ValueToString(*result_a));
+    EXPECT_EQ("\"result_a:alpha\"",
+              GetStringPropertyFromObject(context_a->Global(), context_a,
+                                          "eventArgs"));
   }
   {
-    v8::Local<v8::Value> result_b =
-        GetPropertyFromObject(context_b->Global(), context_b, "eventArgs");
-    ASSERT_FALSE(result_b.IsEmpty());
-    EXPECT_TRUE(result_b->IsUndefined());
+    EXPECT_EQ("undefined", GetStringPropertyFromObject(context_b->Global(),
+                                                       context_b, "eventArgs"));
   }
 
   // Dispatch the event in context_b - the listener in context_a should not be
   // notified.
   std::unique_ptr<base::ListValue> arguments_b =
       ListValueFromString("['result_b:']");
   ASSERT_TRUE(arguments_b);
   handler.FireEventInContext(kEventName, context_b, *arguments_b);
   {
-    std::unique_ptr<base::Value> result_a = GetBaseValuePropertyFromObject(
-        context_a->Global(), context_a, "eventArgs");
-    ASSERT_TRUE(result_a);
-    EXPECT_EQ("\"result_a:alpha\"", ValueToString(*result_a));
+    EXPECT_EQ("\"result_a:alpha\"",
+              GetStringPropertyFromObject(context_a->Global(), context_a,
+                                          "eventArgs"));
   }
   {
-    std::unique_ptr<base::Value> result_b = GetBaseValuePropertyFromObject(
-        context_b->Global(), context_b, "eventArgs");
-    ASSERT_TRUE(result_b);
-    EXPECT_EQ("\"result_b:beta\"", ValueToString(*result_b));
+    EXPECT_EQ("\"result_b:beta\"",
+              GetStringPropertyFromObject(context_b->Global(), context_b,
+                                          "eventArgs"));
   }
 }
 
 TEST_F(APIEventHandlerTest, DifferentCallingMethods) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   const char kEventName[] = "alpha";
   APIEventHandler handler(base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> event =
@@ skipping 38 matching lines @@
       "})";
   {
     v8::Local<v8::Value> args[] = {event};
     RunFunction(FunctionFromString(context, kAddListenerOnEventWithCapture),
                 context, 1, args);
   }
   EXPECT_EQ(2u, handler.GetNumEventListenersForTesting(kEventName, context));
 }
 
 }  // namespace extensions