Implement FromDict/IntoDict for BackgroundTracingConfig.

content/browser/tracing/background_tracing_config_unittest.cc

Index: content/browser/tracing/background_tracing_config_unittest.cc
diff --git a/content/browser/tracing/background_tracing_config_unittest.cc b/content/browser/tracing/background_tracing_config_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3a8f01adb400f064d0c9cda86bda00c48272c2f2
--- /dev/null
+++ b/content/browser/tracing/background_tracing_config_unittest.cc
@@ -0,0 +1,387 @@
+// Copyright 2015 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 "base/json/json_reader.h"
+#include "base/json/json_writer.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+#include "content/public/browser/background_tracing_preemptive_config.h"
+#include "content/public/browser/background_tracing_reactive_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+class BackgroundTracingConfigTest : public testing::Test {};
+
+scoped_ptr<BackgroundTracingConfig> ReadFromJSONString(
+    const std::string& json_text) {
+  scoped_ptr<base::Value> json_value(base::JSONReader::Read(json_text));
+
+  base::DictionaryValue* dict = NULL;
+  if (json_value)
+    json_value->GetAsDictionary(&dict);
+
+  return content::BackgroundTracingConfig::FromDict(dict);
+}
+
+scoped_ptr<BackgroundTracingPreemptiveConfig> ReadPreemptiveFromJSONString(
+    const std::string& json_text) {
+  return make_scoped_ptr(static_cast<BackgroundTracingPreemptiveConfig*>(
+      ReadFromJSONString(json_text).release()));
+}
+
+scoped_ptr<BackgroundTracingReactiveConfig> ReadReactiveFromJSONString(
+    const std::string& json_text) {
+  return make_scoped_ptr(static_cast<BackgroundTracingReactiveConfig*>(
+      ReadFromJSONString(json_text).release()));
+}
+
+std::string ConfigToString(const BackgroundTracingConfig* config) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+
+  BackgroundTracingConfig::IntoDict(config, dict.get());
+
+  std::string results;
+  if (base::JSONWriter::Write(*dict.get(), &results))
+    return results;
+  return "";
+}
+
+TEST_F(BackgroundTracingConfigTest, ConfigFromInvalidString) {
+  // The config string needs to be a properly formatted JSON dictionary.
+  EXPECT_FALSE(ReadFromJSONString(""));
+  EXPECT_FALSE(ReadFromJSONString("Invalid JSON."));
+  EXPECT_FALSE(ReadFromJSONString("[\"Invalid\"]"));
+
+  // Missing or invalid mode
+  EXPECT_FALSE(ReadFromJSONString("{}"));
+  EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"invalid\"}"));
+}
+
+TEST_F(BackgroundTracingConfigTest, PreemptiveConfigFromInvalidString) {
+  // Missing or invalid category
+  EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"preemptive\"}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"invalid\"}"));
+
+  // Missing or invalid configs
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\"}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": \"\"}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": {}}"));
+
+  // Invalid config entries
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": [{}]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": [\"invalid\"]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": [[]]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": [{\"rule\": \"invalid\"}]}"));
+
+  // Missing or invalid keys for a named trigger.
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": [{\"rule\": \"monitor_named\"}]}"));
+  // EXPECT_FALSE(ReadFromJSONString(
+  //     "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+  //     "\"configs\": [{\"rule\": \"monitor_named\", \"trigger_name\":
+  //     \"foo\"}]}"));
+}
+
+TEST_F(BackgroundTracingConfigTest, ReactiveConfigFromInvalidString) {
+  // Missing or invalid configs
+  EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"reactive\"}"));
+  EXPECT_FALSE(
+      ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": \"invalid\"}"));
+  EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": {}}"));
+
+  // Invalid config entries
+  EXPECT_FALSE(
+      ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": [{}]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\", \"configs\": [\"invalid\"]}"));
+
+  // Invalid tracing rule type
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": []}]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": \"\"}]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\"}]}"));
+
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": []}]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": \"\"}]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": "
+      "\"benchmark\"}]}"));
+
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": "
+      "\"benchmark\", \"trigger_name\": []}]}"));
+  EXPECT_FALSE(ReadFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": "
+      "\"benchmark\", \"trigger_name\": 0}]}"));
+}
+
+TEST_F(BackgroundTracingConfigTest, PreemptiveConfigFromValidString) {
+  scoped_ptr<BackgroundTracingPreemptiveConfig> config;
+
+  config = ReadPreemptiveFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": []}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE);
+  EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK);
+  EXPECT_EQ(config->configs.size(), 0u);
+
+  config = ReadPreemptiveFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark-deep\","
+      "\"configs\": []}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE);
+  EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK_DEEP);
+  EXPECT_EQ(config->configs.size(), 0u);
+
+  config = ReadPreemptiveFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": [{\"rule\": \"monitor_named\", \"trigger_name\":"
+      "\"foo\"}]}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE);
+  EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK);
+  EXPECT_EQ(config->configs.size(), 1u);
+  EXPECT_EQ(
+      config->configs[0].type,
+      BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED);
+  EXPECT_EQ(config->configs[0].named_trigger_info.trigger_name, "foo");
+
+  config = ReadPreemptiveFromJSONString(
+      "{\"mode\":\"preemptive\", \"category\": \"benchmark\","
+      "\"configs\": [{\"rule\": \"monitor_named\", \"trigger_name\":"
+      "\"foo1\"}, {\"rule\": \"monitor_named\", \"trigger_name\":"
+      "\"foo2\"}]}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE);
+  EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK);
+  EXPECT_EQ(config->configs.size(), 2u);
+  EXPECT_EQ(
+      config->configs[0].type,
+      BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED);
+  EXPECT_EQ(config->configs[0].named_trigger_info.trigger_name, "foo1");
+  EXPECT_EQ(
+      config->configs[1].type,
+      BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED);
+  EXPECT_EQ(config->configs[1].named_trigger_info.trigger_name, "foo2");
+}
+
+TEST_F(BackgroundTracingConfigTest, ReactiveConfigFromValidString) {
+  scoped_ptr<BackgroundTracingReactiveConfig> config;
+
+  config =
+      ReadReactiveFromJSONString("{\"mode\":\"reactive\", \"configs\": []}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE);
+  EXPECT_EQ(config->configs.size(), 0u);
+
+  config = ReadReactiveFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": "
+      "\"benchmark\", \"trigger_name\": \"foo\"}]}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE);
+  EXPECT_EQ(config->configs.size(), 1u);
+  EXPECT_EQ(config->configs[0].type,
+            BackgroundTracingReactiveConfig::
+                TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL);
+  EXPECT_EQ(config->configs[0].trigger_name, "foo");
+  EXPECT_EQ(config->configs[0].category_preset,
+            BackgroundTracingConfig::BENCHMARK);
+
+  config = ReadReactiveFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": "
+      "\"benchmark-deep\", \"trigger_name\": \"foo\"}]}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE);
+  EXPECT_EQ(config->configs.size(), 1u);
+  EXPECT_EQ(config->configs[0].type,
+            BackgroundTracingReactiveConfig::
+                TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL);
+  EXPECT_EQ(config->configs[0].trigger_name, "foo");
+  EXPECT_EQ(config->configs[0].category_preset,
+            BackgroundTracingConfig::BENCHMARK_DEEP);
+
+  config = ReadReactiveFromJSONString(
+      "{\"mode\":\"reactive\","
+      "\"configs\": [{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": "
+      "\"benchmark-deep\", \"trigger_name\": \"foo1\"},"
+      "{\"rule\": "
+      "\"trace_on_trigger_or_10s_or_trigger_or_full\", \"category\": "
+      "\"benchmark-deep\", \"trigger_name\": \"foo2\"}]}");
+  EXPECT_TRUE(config);
+  EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE);
+  EXPECT_EQ(config->configs.size(), 2u);
+  EXPECT_EQ(config->configs[0].type,
+            BackgroundTracingReactiveConfig::
+                TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL);
+  EXPECT_EQ(config->configs[0].trigger_name, "foo1");
+  EXPECT_EQ(config->configs[0].category_preset,
+            BackgroundTracingConfig::BENCHMARK_DEEP);
+  EXPECT_EQ(config->configs[1].type,
+            BackgroundTracingReactiveConfig::
+                TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL);
+  EXPECT_EQ(config->configs[1].trigger_name, "foo2");
+  EXPECT_EQ(config->configs[1].category_preset,
+            BackgroundTracingConfig::BENCHMARK_DEEP);
+}
+
+TEST_F(BackgroundTracingConfigTest, ValidPreemptiveConfigToString) {
+  scoped_ptr<BackgroundTracingPreemptiveConfig> config(
+      new BackgroundTracingPreemptiveConfig());
+
+  // Default values
+  EXPECT_EQ(
+      ConfigToString(config.get()),
+      "{\"category\":\"benchmark\",\"configs\":[],\"mode\":\"preemptive\"}");
+
+  // Change category_preset
+  config->category_preset = BackgroundTracingConfig::BENCHMARK_DEEP;
+  EXPECT_EQ(ConfigToString(config.get()),
+            "{\"category\":\"benchmark-deep\",\"configs\":[],\"mode\":"
+            "\"preemptive\"}");
+
+  {
+    config.reset(new BackgroundTracingPreemptiveConfig());
+    config->category_preset = BackgroundTracingConfig::BENCHMARK_DEEP;
+
+    BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+    rule.type =
+        BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+    rule.named_trigger_info.trigger_name = "foo";
+    config->configs.push_back(rule);
+    EXPECT_EQ(ConfigToString(config.get()),
+              "{\"category\":\"benchmark-deep\",\"configs\":[{\"rule\":"
+              "\"monitor_named\",\"trigger_name\":\"foo\"}],\"mode\":"
+              "\"preemptive\"}");
+  }
+
+  {
+    config.reset(new BackgroundTracingPreemptiveConfig());
+    config->category_preset = BackgroundTracingConfig::BENCHMARK_DEEP;
+
+    BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+    rule.type =
+        BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+    rule.named_trigger_info.trigger_name = "foo1";
+    config->configs.push_back(rule);
+    rule.named_trigger_info.trigger_name = "foo2";
+    config->configs.push_back(rule);
+    EXPECT_EQ(ConfigToString(config.get()),
+              "{\"category\":\"benchmark-deep\",\"configs\":[{\"rule\":"
+              "\"monitor_named\",\"trigger_name\":\"foo1\"},{\"rule\":"
+              "\"monitor_named\",\"trigger_name\":\"foo2\"}],\"mode\":"
+              "\"preemptive\"}");
+  }
+}
+
+TEST_F(BackgroundTracingConfigTest, InvalidPreemptiveConfigToString) {
+  scoped_ptr<BackgroundTracingPreemptiveConfig> config;
+
+  {
+    config.reset(new BackgroundTracingPreemptiveConfig());
+
+    BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+    rule.type = BackgroundTracingPreemptiveConfig::
+        MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
+    config->configs.push_back(rule);
+    EXPECT_EQ(ConfigToString(config.get()), "{}");
+  }
+
+  {
+    config.reset(new BackgroundTracingPreemptiveConfig());
+
+    BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+    rule.type = BackgroundTracingPreemptiveConfig::
+        MONITOR_AND_DUMP_WHEN_BROWSER_STARTUP_COMPLETE;
+    config->configs.push_back(rule);
+    EXPECT_EQ(ConfigToString(config.get()), "{}");
+  }
+}
+
+TEST_F(BackgroundTracingConfigTest, ValidReactiveConfigToString) {
+  scoped_ptr<BackgroundTracingReactiveConfig> config(
+      new BackgroundTracingReactiveConfig());
+
+  // Default values
+  EXPECT_EQ(ConfigToString(config.get()),
+            "{\"configs\":[],\"mode\":\"reactive\"}");
+
+  {
+    config.reset(new BackgroundTracingReactiveConfig());
+
+    BackgroundTracingReactiveConfig::TracingRule rule;
+    rule.type = BackgroundTracingReactiveConfig::
+        TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL;
+    rule.trigger_name = "foo";
+    rule.category_preset = BackgroundTracingConfig::BENCHMARK_DEEP;
+    config->configs.push_back(rule);
+    EXPECT_EQ(ConfigToString(config.get()),
+              "{\"configs\":[{\"category\":\"benchmark-deep\",\"rule\":\"trace_"
+              "on_trigger_or_10s_or_trigger_or_full\",\"trigger_name\":\"foo\"}"
+              "],\"mode\":\"reactive\"}");
+  }
+
+  {
+    config.reset(new BackgroundTracingReactiveConfig());
+
+    BackgroundTracingReactiveConfig::TracingRule rule;
+    rule.type = BackgroundTracingReactiveConfig::
+        TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL;
+    rule.trigger_name = "foo1";
+    rule.category_preset = BackgroundTracingConfig::BENCHMARK_DEEP;
+    config->configs.push_back(rule);
+    rule.trigger_name = "foo2";
+    config->configs.push_back(rule);
+    EXPECT_EQ(ConfigToString(config.get()),
+              "{\"configs\":[{\"category\":\"benchmark-deep\",\"rule\":\"trace_"
+              "on_trigger_or_10s_or_trigger_or_full\",\"trigger_name\":"
+              "\"foo1\"},{\"category\":\"benchmark-deep\",\"rule\":\"trace_on_"
+              "trigger_or_10s_or_trigger_or_full\",\"trigger_name\":\"foo2\"}],"
+              "\"mode\":\"reactive\"}");
+  }
+}
+
+#if defined(GTEST_HAS_DEATH_TEST)
+#endif
+
+}  // namspace content