[fuchsia] Add LegacyMetricsUserEventRecorder class.

Adds a class which accumulates a buffer of user events, which are
timestamped strings recorded with the base::RecordAction() API.
The buffer will periodically be drained and sent over FIDL IPC (not in
scope for this CL).

Bug: 1060768
Change-Id: Ieb235654e030eef81eefd963ae614ce68b72dba7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2103393
Commit-Queue: Kevin Marshall <kmarshall@chromium.org>
Reviewed-by: David Dorwin <ddorwin@chromium.org>
Reviewed-by: Wez <wez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#751081}

fuchsia/base/BUILD.gn

@@ -62,6 +62,15 @@ source_set("message_port") {
   ]
 }
 
+source_set("legacymetrics") {
+  sources = [
+    "legacymetrics_user_event_recorder.cc",
+    "legacymetrics_user_event_recorder.h",
+  ]
+  deps = [ "//base" ]
+  public_deps = [ "//third_party/fuchsia-sdk/sdk/fidl/fuchsia.legacymetrics" ]
+}
+
 # Used to propagate release-qualified package names to integration test code.
 buildflag_header("release_channel_buildflags") {
   header = "release_channel.h"
@@ -102,8 +111,12 @@ source_set("test_support") {
 
 # Unit-tests for all //fuchsia/base utilities.
 test("cr_fuchsia_base_unittests") {
-  sources = [ "agent_impl_unittests.cc" ]
+  sources = [
+    "agent_impl_unittests.cc",
+    "legacymetrics_user_event_recorder_unittest.cc",
+  ]
   deps = [
+    ":legacymetrics",
     ":modular",
     ":test_support",
     "//base",

fuchsia/base/legacymetrics_user_event_recorder.cc

+// Copyright 2019 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 "fuchsia/base/legacymetrics_user_event_recorder.h"
+
+#include <utility>
+
+#include "base/callback.h"
+#include "base/metrics/user_metrics.h"
+
+namespace cr_fuchsia {
+
+LegacyMetricsUserActionRecorder::LegacyMetricsUserActionRecorder()
+    : on_event_callback_(
+          base::BindRepeating(&LegacyMetricsUserActionRecorder::OnUserAction,
+                              base::Unretained(this))) {
+  base::AddActionCallback(on_event_callback_);
+}
+
+LegacyMetricsUserActionRecorder::~LegacyMetricsUserActionRecorder() {
+  base::RemoveActionCallback(on_event_callback_);
+}
+
+bool LegacyMetricsUserActionRecorder::HasEvents() const {
+  return !events_.empty();
+}
+
+std::vector<fuchsia::legacymetrics::UserActionEvent>
+LegacyMetricsUserActionRecorder::TakeEvents() {
+  return std::move(events_);
+}
+
+void LegacyMetricsUserActionRecorder::OnUserAction(
+    const std::string& event_name,
+    base::TimeTicks time) {
+  fuchsia::legacymetrics::UserActionEvent fidl_event;
+  fidl_event.set_name(event_name);
+  fidl_event.set_time(time.ToZxTime());
+  events_.push_back(std::move(fidl_event));
+}
+
+}  // namespace cr_fuchsia

fuchsia/base/legacymetrics_user_event_recorder.h

+// Copyright 2019 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.
+
+#ifndef FUCHSIA_BASE_LEGACYMETRICS_USER_EVENT_RECORDER_H_
+#define FUCHSIA_BASE_LEGACYMETRICS_USER_EVENT_RECORDER_H_
+
+#include <fuchsia/legacymetrics/cpp/fidl.h>
+#include <string>
+#include <vector>
+
+#include "base/metrics/user_metrics.h"
+
+namespace cr_fuchsia {
+
+// Captures and stores user action events, and converts them to
+// fuchsia.legacymetrics equivalent.
+class LegacyMetricsUserActionRecorder {
+ public:
+  LegacyMetricsUserActionRecorder();
+  ~LegacyMetricsUserActionRecorder();
+
+  LegacyMetricsUserActionRecorder(const LegacyMetricsUserActionRecorder&) =
+      delete;
+  LegacyMetricsUserActionRecorder& operator=(
+      const LegacyMetricsUserActionRecorder&) = delete;
+
+  bool HasEvents() const;
+  std::vector<fuchsia::legacymetrics::UserActionEvent> TakeEvents();
+
+ private:
+  // base::UserActionCallback implementation.
+  void OnUserAction(const std::string& event_name, base::TimeTicks time);
+
+  std::vector<fuchsia::legacymetrics::UserActionEvent> events_;
+  const base::ActionCallback on_event_callback_;
+};
+
+}  // namespace cr_fuchsia
+
+#endif  // FUCHSIA_BASE_LEGACYMETRICS_USER_EVENT_RECORDER_H_

fuchsia/base/legacymetrics_user_event_recorder_unittest.cc

+// Copyright 2020 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 "fuchsia/base/legacymetrics_user_event_recorder.h"
+
+#include "base/test/task_environment.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cr_fuchsia {
+namespace {
+
+TEST(LegacyMetricsUserActionRecorderTest, ProduceAndConsume) {
+  constexpr char kExpectedUserAction1[] = "Hello";
+  constexpr char kExpectedUserAction2[] = "There";
+
+  base::test::SingleThreadTaskEnvironment task_environment;
+  base::SetRecordActionTaskRunner(base::ThreadTaskRunnerHandle::Get());
+
+  zx_time_t time_start = base::TimeTicks::Now().ToZxTime();
+  auto buffer = std::make_unique<LegacyMetricsUserActionRecorder>();
+  base::RecordComputedAction(kExpectedUserAction1);
+  EXPECT_TRUE(buffer->HasEvents());
+  base::RecordComputedAction(kExpectedUserAction2);
+
+  auto events = buffer->TakeEvents();
+  EXPECT_FALSE(buffer->HasEvents());
+  EXPECT_EQ(2u, events.size());
+
+  EXPECT_EQ(kExpectedUserAction1, events[0].name());
+  EXPECT_GE(events[0].time(), time_start);
+
+  EXPECT_EQ(kExpectedUserAction2, events[1].name());
+  EXPECT_GE(events[1].time(), time_start);
+
+  EXPECT_GE(events[1].time(), events[0].time());
+
+  EXPECT_TRUE(buffer->TakeEvents().empty());
+
+  base::RecordComputedAction(kExpectedUserAction2);
+  EXPECT_TRUE(buffer->HasEvents());
+  events = buffer->TakeEvents();
+  EXPECT_FALSE(buffer->HasEvents());
+  EXPECT_EQ(1u, events.size());
+  EXPECT_EQ(kExpectedUserAction2, events[0].name());
+}
+
+TEST(LegacyMetricsUserActionRecorderTest, RecorderDeleted) {
+  base::test::SingleThreadTaskEnvironment task_environment;
+  base::SetRecordActionTaskRunner(base::ThreadTaskRunnerHandle::Get());
+
+  auto buffer = std::make_unique<LegacyMetricsUserActionRecorder>();
+  buffer.reset();
+
+  // |buffer| was destroyed, so check that recording actions doesn't cause a
+  // use-after-free error.
+  base::RecordComputedAction("NoCrashingPlz");
+}
+
+TEST(LegacyMetricsUserActionRecorderTest, EmptyBuffer) {
+  base::test::SingleThreadTaskEnvironment task_environment;
+  base::SetRecordActionTaskRunner(base::ThreadTaskRunnerHandle::Get());
+  auto buffer = std::make_unique<LegacyMetricsUserActionRecorder>();
+  EXPECT_FALSE(buffer->HasEvents());
+}
+
+}  // namespace
+}  // namespace cr_fuchsia