// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/tracing/tracing_scenario.h"
#include <memory>

#include "base/files/file_path.h"
#include "base/path_service.h"
#include "base/task/thread_pool.h"
#include "base/test/gmock_callback_support.h"
#include "base/test/test_proto_loader.h"
#include "base/trace_event/named_trigger.h"
#include "content/public/browser/background_tracing_manager.h"
#include "content/public/test/browser_task_environment.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace content {
namespace {

const char* kDefaultNestedConfig = R"pb(
  scenario_name: "test_nested_scenario"
  start_rules: { name: "start_trigger" manual_trigger_name: "start_trigger" }
  stop_rules: { name: "stop_trigger" manual_trigger_name: "stop_trigger" }
  upload_rules: { name: "upload_trigger" manual_trigger_name: "upload_trigger" }
)pb";

const char* kDefaultConfig = R"pb(
  scenario_name: "test_scenario"
  setup_rules: { name: "setup_trigger" manual_trigger_name: "setup_trigger" }
  start_rules: { name: "start_trigger" manual_trigger_name: "start_trigger" }
  stop_rules: { name: "stop_trigger" manual_trigger_name: "stop_trigger" }
  upload_rules: { name: "upload_trigger" manual_trigger_name: "upload_trigger" }
  trace_config: {
    data_sources: { config: { name: "org.chromium.trace_metadata" } }
  }
  nested_scenarios: {
    scenario_name: "nested_scenario"
    start_rules: {
      name: "nested_start_trigger"
      manual_trigger_name: "nested_start_trigger"
    }
    stop_rules: {
      name: "nested_stop_trigger"
      manual_trigger_name: "nested_stop_trigger"
    }
    upload_rules: {
      name: "nested_upload_trigger"
      manual_trigger_name: "nested_upload_trigger"
    }
  }
  nested_scenarios: {
    scenario_name: "other_nested_scenario"
    start_rules: {
      name: "other_nested_start_trigger"
      manual_trigger_name: "other_nested_start_trigger"
    }
    stop_rules: {
      name: "other_nested_stop_trigger"
      manual_trigger_name: "other_nested_stop_trigger"
    }
    upload_rules: {
      name: "other_nested_upload_trigger"
      manual_trigger_name: "other_nested_upload_trigger"
    }
  }
)pb";

using testing::_;

class TestTracingScenarioDelegate : public TracingScenario::Delegate {
 public:
  ~TestTracingScenarioDelegate() = default;

  MOCK_METHOD(bool, OnScenarioActive, (TracingScenario * scenario), (override));
  MOCK_METHOD(bool, OnScenarioIdle, (TracingScenario * scenario), (override));
  MOCK_METHOD(void,
              OnScenarioRecording,
              (TracingScenario * scenario),
              (override));
  MOCK_METHOD(void,
              SaveTrace,
              (TracingScenario * scenario,
               base::Token trace_uuid,
               const BackgroundTracingRule* triggered_rule,
               std::string&& trace_data),
              (override));
};

class TestNestedTracingScenarioDelegate
    : public NestedTracingScenario::Delegate {
 public:
  ~TestNestedTracingScenarioDelegate() = default;

  MOCK_METHOD(void,
              OnNestedScenarioStart,
              (NestedTracingScenario * scenario),
              (override));
  MOCK_METHOD(void,
              OnNestedScenarioStop,
              (NestedTracingScenario * scenario),
              (override));
  MOCK_METHOD(void,
              OnNestedScenarioUpload,
              (NestedTracingScenario * scenario,
               const BackgroundTracingRule* triggered_rule),
              (override));
};

// Fake perfetto::TracingSession.
class TestTracingSession : public perfetto::TracingSession {
 public:
  TestTracingSession() = default;
  ~TestTracingSession() override = default;

  void Setup(const perfetto::TraceConfig& config, int fd = -1) override {
    if (!config.data_sources().empty()) {
      start_should_fail_ =
          config.data_sources()[0].config().name() == "Invalid";
      should_spuriously_stop =
          config.data_sources()[0].config().name() == "Stop";
    }
  }

  void Start() override {
    if (start_should_fail_) {
      base::ThreadPool::PostTask(
          FROM_HERE,
          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
           base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
          base::BindOnce(
              [](std::function<void(perfetto::TracingError)>  // nocheck
                     on_error_callback) {
                on_error_callback(
                    {perfetto::TracingError::kTracingFailed, "error"});
              },
              on_error_callback_));
      return;
    }
    if (should_spuriously_stop) {
      Stop();
      return;
    }
    // perfetto::TracingSession runs callbacks from its own background thread.
    base::ThreadPool::PostTask(
        FROM_HERE,
        {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
        base::BindOnce(
            [](std::function<void()> on_start_callback) {  // nocheck
              on_start_callback();
            },
            on_start_callback_));
  }

  void StartBlocking() override { NOTIMPLEMENTED(); }

  void SetOnStartCallback(std::function<void()> on_start) override {  // nocheck
    on_start_callback_ = on_start;
  }

  void SetOnErrorCallback(
      std::function<void(perfetto::TracingError)> on_error)  // nocheck
      override {
    on_error_callback_ = on_error;
  }

  void Flush(std::function<void(bool)>, uint32_t timeout_ms = 0)  // nocheck
      override {
    NOTIMPLEMENTED();
  }

  void Stop() override {
    // perfetto::TracingSession runs callbacks from its own background thread.
    base::ThreadPool::PostTask(
        FROM_HERE,
        {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
        base::BindOnce(
            [](std::function<void()> on_stop_callback) {  // nocheck
              on_stop_callback();
            },
            on_stop_callback_));
  }

  void StopBlocking() override { NOTIMPLEMENTED(); }

  void SetOnStopCallback(std::function<void()> on_stop) override {  // nocheck
    on_stop_callback_ = on_stop;
  }

  void ChangeTraceConfig(const perfetto::TraceConfig&) override {
    NOTIMPLEMENTED();
  }
  void ReadTrace(ReadTraceCallback read_callback) override {
    base::ThreadPool::PostTask(
        FROM_HERE,
        {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
         base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
        base::BindOnce(
            [](ReadTraceCallback read_callback) {  // nocheck
              std::string trace_content = "this is a trace";
              read_callback({trace_content.data(), trace_content.size(),
                             /*has_more=*/false});
            },
            read_callback));
  }
  void GetTraceStats(GetTraceStatsCallback) override { NOTIMPLEMENTED(); }
  void QueryServiceState(QueryServiceStateCallback) override {
    NOTIMPLEMENTED();
  }

 private:
  std::function<void()> on_start_callback_;                        // nocheck
  std::function<void()> on_stop_callback_;                         // nocheck
  std::function<void(perfetto::TracingError)> on_error_callback_;  // nocheck
  bool start_should_fail_ = false;
  bool should_spuriously_stop = false;
};

class TracingScenarioForTesting : public TracingScenario {
 public:
  TracingScenarioForTesting(const perfetto::protos::gen::ScenarioConfig& config,
                            TestTracingScenarioDelegate* delegate)
      : TracingScenario(config, delegate) {
    EXPECT_TRUE(Initialize(config, false, false));
  }

 protected:
  std::unique_ptr<perfetto::TracingSession> CreateTracingSession() override {
    return std::make_unique<TestTracingSession>();
  }
};

class NestedTracingScenarioForTesting : public NestedTracingScenario {
 public:
  NestedTracingScenarioForTesting(
      const perfetto::protos::gen::NestedScenarioConfig& config,
      NestedTracingScenario::Delegate* delegate)
      : NestedTracingScenario(config, delegate) {
    EXPECT_TRUE(Initialize(config));
  }
};

perfetto::protos::gen::ScenarioConfig ParseScenarioConfigFromText(
    const std::string& proto_text) {
  base::TestProtoLoader config_loader(
      base::PathService::CheckedGet(base::DIR_GEN_TEST_DATA_ROOT)
          .Append(
              FILE_PATH_LITERAL("third_party/perfetto/protos/perfetto/"
                                "config/chrome/scenario_config.descriptor")),
      "perfetto.protos.ScenarioConfig");
  std::string serialized_message;
  config_loader.ParseFromText(proto_text, serialized_message);
  perfetto::protos::gen::ScenarioConfig destination;
  destination.ParseFromString(serialized_message);
  return destination;
}

perfetto::protos::gen::NestedScenarioConfig ParseNestedScenarioConfigFromText(
    const std::string& proto_text) {
  base::TestProtoLoader config_loader(
      base::PathService::CheckedGet(base::DIR_GEN_TEST_DATA_ROOT)
          .Append(
              FILE_PATH_LITERAL("third_party/perfetto/protos/perfetto/"
                                "config/chrome/scenario_config.descriptor")),
      "perfetto.protos.NestedScenarioConfig");
  std::string serialized_message;
  config_loader.ParseFromText(proto_text, serialized_message);
  perfetto::protos::gen::NestedScenarioConfig destination;
  destination.ParseFromString(serialized_message);
  return destination;
}

class TracingScenarioTest : public testing::Test {
 public:
  TracingScenarioTest()
      : background_tracing_manager_(
            content::BackgroundTracingManager::CreateInstance()) {}

 protected:
  BrowserTaskEnvironment task_environment;
  TestTracingScenarioDelegate delegate;
  TestNestedTracingScenarioDelegate nested_delegate;
  std::unique_ptr<content::BackgroundTracingManager>
      background_tracing_manager_;
};

class NestedTracingScenarioTest : public testing::Test {
 public:
  NestedTracingScenarioTest()
      : background_tracing_manager_(
            content::BackgroundTracingManager::CreateInstance()) {}

 protected:
  BrowserTaskEnvironment task_environment;
  TestNestedTracingScenarioDelegate delegate;
  std::unique_ptr<content::BackgroundTracingManager>
      background_tracing_manager_;
};

}  // namespace

TEST_F(TracingScenarioTest, Init) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(R"pb(
        scenario_name: "test_scenario"
        trace_config: {
          data_sources: { config: { name: "org.chromium.trace_metadata" } }
        }
      )pb"),
      &delegate);
  EXPECT_EQ("test_scenario", tracing_scenario.scenario_name());
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, Disabled) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario)).Times(0);

  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("setup_trigger"));
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("start_trigger"));
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("nested_start_trigger"));

  tracing_scenario.Enable();
  EXPECT_EQ(TracingScenario::State::kEnabled, tracing_scenario.current_state());
  tracing_scenario.Disable();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());

  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("setup_trigger"));
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("start_trigger"));
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("nested_start_trigger"));
}

TEST_F(TracingScenarioTest, StartStop) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_EQ(TracingScenario::State::kEnabled, tracing_scenario.current_state());
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, NestedStartStop) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_EQ(TracingScenario::State::kEnabled, tracing_scenario.current_state());
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("nested_start_trigger"));

  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("nested_stop_trigger"));

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, StartFail) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(R"pb(
        scenario_name: "test_scenario"
        start_rules: {
          name: "start_trigger"
          manual_trigger_name: "start_trigger"
        }
        stop_rules: { name: "stop_trigger" manual_trigger_name: "stop_trigger" }
        trace_config: { data_sources: { config: { name: "Invalid" } } }
      )pb"),
      &delegate);

  tracing_scenario.Enable();
  EXPECT_EQ(TracingScenario::State::kEnabled, tracing_scenario.current_state());
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("stop_trigger"));
}

TEST_F(TracingScenarioTest, SpuriousStop) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(R"pb(
        scenario_name: "test_scenario"
        start_rules: {
          name: "start_trigger"
          manual_trigger_name: "start_trigger"
        }
        stop_rules: { name: "stop_trigger" manual_trigger_name: "stop_trigger" }
        trace_config: { data_sources: { config: { name: "Stop" } } }
      )pb"),
      &delegate);

  tracing_scenario.Enable();
  EXPECT_EQ(TracingScenario::State::kEnabled, tracing_scenario.current_state());
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("stop_trigger"));
}

TEST_F(TracingScenarioTest, SetupStop) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("setup_trigger"));
  EXPECT_EQ(TracingScenario::State::kSetup, tracing_scenario.current_state());

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, SetupUpload) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("setup_trigger"));
  EXPECT_EQ(TracingScenario::State::kSetup, tracing_scenario.current_state());

  base::Token trace_uuid = tracing_scenario.GetSessionID();
  base::RunLoop run_loop;
  EXPECT_CALL(delegate, SaveTrace(_, trace_uuid, _, _)).Times(0);
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("upload_trigger"));
  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, SetupStartStop) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("setup_trigger"));
  EXPECT_EQ(TracingScenario::State::kSetup, tracing_scenario.current_state());

  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario)).Times(0);
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));
  EXPECT_EQ(TracingScenario::State::kRecording,
            tracing_scenario.current_state());

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, SetupNestedStartStop) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("setup_trigger"));
  EXPECT_EQ(TracingScenario::State::kSetup, tracing_scenario.current_state());

  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario)).Times(0);
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("nested_start_trigger"));
  EXPECT_EQ(TracingScenario::State::kRecording,
            tracing_scenario.current_state());
  EXPECT_FALSE(
      base::trace_event::EmitNamedTrigger("other_nested_start_trigger"));
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("stop_trigger"));

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("nested_stop_trigger"));

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, Abort) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));
  EXPECT_EQ(TracingScenario::State::kRecording,
            tracing_scenario.current_state());

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce([&run_loop]() {
        run_loop.Quit();
        return true;
      });

  tracing_scenario.Abort();
  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("stop_trigger"));
}

TEST_F(TracingScenarioTest, Upload) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  base::Token trace_uuid = tracing_scenario.GetSessionID();
  base::RunLoop run_loop;
  EXPECT_CALL(delegate, SaveTrace(&tracing_scenario, trace_uuid, _,
                                  std::string("this is a trace")))
      .WillOnce(base::test::RunOnceClosure(run_loop.QuitClosure()));
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce(testing::Return(true));

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("upload_trigger"));

  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, StopUpload) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  base::Token trace_uuid = tracing_scenario.GetSessionID();
  base::RunLoop run_loop;
  EXPECT_CALL(delegate, SaveTrace(&tracing_scenario, trace_uuid, _,
                                  std::string("this is a trace")))
      .WillOnce(base::test::RunOnceClosure(run_loop.QuitClosure()));
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce(testing::Return(true));

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("upload_trigger"));

  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(TracingScenarioTest, NestedUpload) {
  TracingScenarioForTesting tracing_scenario(
      ParseScenarioConfigFromText(kDefaultConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnScenarioActive(&tracing_scenario))
      .WillOnce(testing::Return(true));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("nested_start_trigger"));

  base::Token trace_uuid = tracing_scenario.GetSessionID();
  base::RunLoop run_loop;
  EXPECT_CALL(delegate, SaveTrace(&tracing_scenario, trace_uuid, _,
                                  std::string("this is a trace")))
      .WillOnce(base::test::RunOnceClosure(run_loop.QuitClosure()));
  EXPECT_CALL(delegate, OnScenarioIdle(&tracing_scenario))
      .WillOnce(testing::Return(true));

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("nested_upload_trigger"));

  run_loop.Run();
  EXPECT_EQ(TracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(NestedTracingScenarioTest, Disabled) {
  NestedTracingScenarioForTesting tracing_scenario(
      ParseNestedScenarioConfigFromText(kDefaultNestedConfig), &delegate);

  EXPECT_CALL(delegate, OnNestedScenarioStart(&tracing_scenario)).Times(0);

  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("start_trigger"));

  tracing_scenario.Enable();
  EXPECT_EQ(NestedTracingScenario::State::kEnabled,
            tracing_scenario.current_state());
  tracing_scenario.Disable();
  EXPECT_EQ(NestedTracingScenario::State::kDisabled,
            tracing_scenario.current_state());

  EXPECT_FALSE(base::trace_event::EmitNamedTrigger("start_trigger"));
}

TEST_F(NestedTracingScenarioTest, StartStop) {
  NestedTracingScenarioForTesting tracing_scenario(
      ParseNestedScenarioConfigFromText(kDefaultNestedConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_EQ(NestedTracingScenario::State::kEnabled,
            tracing_scenario.current_state());
  EXPECT_CALL(delegate, OnNestedScenarioStart(&tracing_scenario)).Times(1);
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  EXPECT_CALL(delegate, OnNestedScenarioStop(&tracing_scenario)).Times(1);
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  EXPECT_EQ(NestedTracingScenario::State::kStopping,
            tracing_scenario.current_state());
  tracing_scenario.Disable();
  EXPECT_EQ(NestedTracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(NestedTracingScenarioTest, Upload) {
  NestedTracingScenarioForTesting tracing_scenario(
      ParseNestedScenarioConfigFromText(kDefaultNestedConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnNestedScenarioStart(&tracing_scenario)).Times(1);
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  EXPECT_CALL(delegate, OnNestedScenarioUpload(&tracing_scenario, _)).Times(1);
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("upload_trigger"));

  EXPECT_EQ(NestedTracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

TEST_F(NestedTracingScenarioTest, StopUpload) {
  NestedTracingScenarioForTesting tracing_scenario(
      ParseNestedScenarioConfigFromText(kDefaultNestedConfig), &delegate);

  tracing_scenario.Enable();
  EXPECT_CALL(delegate, OnNestedScenarioStart(&tracing_scenario)).Times(1);
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("start_trigger"));

  base::RunLoop run_loop;
  EXPECT_CALL(delegate, OnNestedScenarioUpload(&tracing_scenario, _))
      .WillOnce(base::test::RunOnceClosure(run_loop.QuitClosure()));
  EXPECT_CALL(delegate, OnNestedScenarioStop(&tracing_scenario)).Times(1);

  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("stop_trigger"));
  EXPECT_TRUE(base::trace_event::EmitNamedTrigger("upload_trigger"));

  run_loop.Run();
  EXPECT_EQ(NestedTracingScenario::State::kDisabled,
            tracing_scenario.current_state());
}

}  // namespace content