Cleanup headless templates and message_dispatcher.h.

headless/public/domains/types_unittest.cc

Index: headless/public/domains/types_unittest.cc
diff --git a/headless/public/domains/types_unittest.cc b/headless/public/domains/types_unittest.cc
index 7d33c2b5db7af7765f31b284b0d6ce4ead7698a3..4f8e4f5908f3f185f2083f12636d06deadeec8ed 100644
--- a/headless/public/domains/types_unittest.cc
+++ b/headless/public/domains/types_unittest.cc
@@ -8,6 +8,7 @@
 #include "headless/public/devtools/domains/dom.h"
 #include "headless/public/devtools/domains/memory.h"
 #include "headless/public/devtools/domains/page.h"
+#include "headless/public/util/error_reporter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace headless {
@@ -15,18 +16,18 @@ namespace headless {
 TEST(TypesTest, IntegerProperty) {
   std::unique_ptr<page::NavigateToHistoryEntryParams> object(
       page::NavigateToHistoryEntryParams::Builder().SetEntryId(123).Build());
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
   EXPECT_EQ(123, object->GetEntryId());
 
   std::unique_ptr<page::NavigateToHistoryEntryParams> clone(object->Clone());
-  EXPECT_TRUE(clone);
+  ASSERT_TRUE(clone);
   EXPECT_EQ(123, clone->GetEntryId());
 }
 
 TEST(TypesTest, IntegerPropertyParseError) {
-  const char* json = "{\"entryId\": \"foo\"}";
+  const char json[] = "{\"entryId\": \"foo\"}";
   std::unique_ptr<base::Value> object = base::JSONReader::Read(json);
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
 
 #if DCHECK_IS_ON()
   ErrorReporter errors;
@@ -40,19 +41,19 @@ TEST(TypesTest, BooleanProperty) {
       memory::SetPressureNotificationsSuppressedParams::Builder()
           .SetSuppressed(true)
           .Build());
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
   EXPECT_TRUE(object->GetSuppressed());
 
   std::unique_ptr<memory::SetPressureNotificationsSuppressedParams> clone(
       object->Clone());
-  EXPECT_TRUE(clone);
+  ASSERT_TRUE(clone);
   EXPECT_TRUE(clone->GetSuppressed());
 }
 
 TEST(TypesTest, BooleanPropertyParseError) {
-  const char* json = "{\"suppressed\": \"foo\"}";
+  const char json[] = "{\"suppressed\": \"foo\"}";
   std::unique_ptr<base::Value> object = base::JSONReader::Read(json);
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
 
 #if DCHECK_IS_ON()
   ErrorReporter errors;
@@ -65,18 +66,18 @@ TEST(TypesTest, BooleanPropertyParseError) {
 TEST(TypesTest, DoubleProperty) {
   std::unique_ptr<page::SetGeolocationOverrideParams> object(
       page::SetGeolocationOverrideParams::Builder().SetLatitude(3.14).Build());
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
   EXPECT_EQ(3.14, object->GetLatitude());
 
   std::unique_ptr<page::SetGeolocationOverrideParams> clone(object->Clone());
-  EXPECT_TRUE(clone);
+  ASSERT_TRUE(clone);
   EXPECT_EQ(3.14, clone->GetLatitude());
 }
 
 TEST(TypesTest, DoublePropertyParseError) {
-  const char* json = "{\"latitude\": \"foo\"}";
+  const char json[] = "{\"latitude\": \"foo\"}";
   std::unique_ptr<base::Value> object = base::JSONReader::Read(json);
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
 
 #if DCHECK_IS_ON()
   ErrorReporter errors;
@@ -88,18 +89,18 @@ TEST(TypesTest, DoublePropertyParseError) {
 TEST(TypesTest, StringProperty) {
   std::unique_ptr<page::NavigateParams> object(
       page::NavigateParams::Builder().SetUrl("url").Build());
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
   EXPECT_EQ("url", object->GetUrl());
 
   std::unique_ptr<page::NavigateParams> clone(object->Clone());
-  EXPECT_TRUE(clone);
+  ASSERT_TRUE(clone);
   EXPECT_EQ("url", clone->GetUrl());
 }
 
 TEST(TypesTest, StringPropertyParseError) {
-  const char* json = "{\"url\": false}";
+  const char json[] = "{\"url\": false}";
   std::unique_ptr<base::Value> object = base::JSONReader::Read(json);
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
 
 #if DCHECK_IS_ON()
   ErrorReporter errors;
@@ -113,18 +114,18 @@ TEST(TypesTest, EnumProperty) {
       runtime::RemoteObject::Builder()
           .SetType(runtime::RemoteObjectType::UNDEFINED)
           .Build());
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
   EXPECT_EQ(runtime::RemoteObjectType::UNDEFINED, object->GetType());
 
   std::unique_ptr<runtime::RemoteObject> clone(object->Clone());
-  EXPECT_TRUE(clone);
+  ASSERT_TRUE(clone);
   EXPECT_EQ(runtime::RemoteObjectType::UNDEFINED, clone->GetType());
 }
 
 TEST(TypesTest, EnumPropertyParseError) {
-  const char* json = "{\"type\": false}";
+  const char json[] = "{\"type\": false}";
   std::unique_ptr<base::Value> object = base::JSONReader::Read(json);
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
 
 #if DCHECK_IS_ON()
   ErrorReporter errors;
@@ -141,24 +142,28 @@ TEST(TypesTest, ArrayProperty) {
 
   std::unique_ptr<dom::QuerySelectorAllResult> object(
       dom::QuerySelectorAllResult::Builder().SetNodeIds(values).Build());
-  EXPECT_TRUE(object);
-  EXPECT_EQ(3u, object->GetNodeIds()->size());
-  EXPECT_EQ(1, object->GetNodeIds()->at(0));
-  EXPECT_EQ(2, object->GetNodeIds()->at(1));
-  EXPECT_EQ(3, object->GetNodeIds()->at(2));
+  ASSERT_TRUE(object);
+  ASSERT_TRUE(object->GetNodeIds());
+  const auto& object_node_ids = *object->GetNodeIds();
+  ASSERT_EQ(3u, object_node_ids.size());
+  EXPECT_EQ(1, object_node_ids[0]);
+  EXPECT_EQ(2, object_node_ids[1]);
+  EXPECT_EQ(3, object_node_ids[2]);
 
   std::unique_ptr<dom::QuerySelectorAllResult> clone(object->Clone());
-  EXPECT_TRUE(clone);
-  EXPECT_EQ(3u, clone->GetNodeIds()->size());
-  EXPECT_EQ(1, clone->GetNodeIds()->at(0));
-  EXPECT_EQ(2, clone->GetNodeIds()->at(1));
-  EXPECT_EQ(3, clone->GetNodeIds()->at(2));
+  ASSERT_TRUE(clone);
+  ASSERT_TRUE(clone->GetNodeIds());
+  const auto& clone_node_ids = *object->GetNodeIds();
+  ASSERT_EQ(3u, clone_node_ids.size());
+  EXPECT_EQ(1, clone_node_ids[0]);
+  EXPECT_EQ(2, clone_node_ids[1]);
+  EXPECT_EQ(3, clone_node_ids[2]);
 }
 
 TEST(TypesTest, ArrayPropertyParseError) {
-  const char* json = "{\"nodeIds\": true}";
+  const char json[] = "{\"nodeIds\": true}";
   std::unique_ptr<base::Value> object = base::JSONReader::Read(json);
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
 
 #if DCHECK_IS_ON()
   ErrorReporter errors;
@@ -176,18 +181,18 @@ TEST(TypesTest, ObjectProperty) {
       runtime::EvaluateResult::Builder()
           .SetResult(std::move(subobject))
           .Build());
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
   EXPECT_EQ(runtime::RemoteObjectType::SYMBOL, object->GetResult()->GetType());
 
   std::unique_ptr<runtime::EvaluateResult> clone(object->Clone());
-  EXPECT_TRUE(clone);
+  ASSERT_TRUE(clone);
   EXPECT_EQ(runtime::RemoteObjectType::SYMBOL, clone->GetResult()->GetType());
 }
 
 TEST(TypesTest, ObjectPropertyParseError) {
-  const char* json = "{\"result\": 42}";
+  const char json[] = "{\"result\": 42}";
   std::unique_ptr<base::Value> object = base::JSONReader::Read(json);
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
 
 #if DCHECK_IS_ON()
   ErrorReporter errors;
@@ -203,15 +208,15 @@ TEST(TypesTest, AnyProperty) {
           .SetType(accessibility::AXValueType::INTEGER)
           .SetValue(std::move(value))
           .Build());
-  EXPECT_TRUE(object);
+  ASSERT_TRUE(object);
   EXPECT_EQ(base::Value::Type::INTEGER, object->GetValue()->GetType());
 
   std::unique_ptr<accessibility::AXValue> clone(object->Clone());
-  EXPECT_TRUE(clone);
+  ASSERT_TRUE(clone);
   EXPECT_EQ(base::Value::Type::INTEGER, clone->GetValue()->GetType());
 
   int clone_value;
-  EXPECT_TRUE(clone->GetValue()->GetAsInteger(&clone_value));
+  ASSERT_TRUE(clone->GetValue()->GetAsInteger(&clone_value));
   EXPECT_EQ(123, clone_value);
 }
 
@@ -231,7 +236,7 @@ TEST(TypesTest, ComplexObjectClone) {
           .SetNodes(std::move(child_nodes))
           .Build();
   std::unique_ptr<dom::SetChildNodesParams> clone = params->Clone();
-  ASSERT_NE(nullptr, clone);
+  ASSERT_TRUE(clone);
 
   std::string orig;
   JSONStringValueSerializer(&orig).Serialize(*params->Serialize());