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

#include "ui/gl/delegated_ink_point_renderer_gpu.h"

#include <memory>

#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/base/win/hidden_window.h"
#include "ui/gfx/geometry/vector2d_f.h"
#include "ui/gl/dc_layer_tree.h"
#include "ui/gl/dcomp_presenter.h"
#include "ui/gl/direct_composition_support.h"
#include "ui/gl/gl_context.h"
#include "ui/gl/init/gl_factory.h"
#include "ui/gl/test/gl_test_helper.h"

namespace gl {
namespace {

// Standard number of microseconds that is put between each DelegatedInkPoint.
const int kMicrosecondsBetweenEachPoint = 10;

class DelegatedInkPointRendererGpuTest : public testing::Test {
 public:
  DelegatedInkPointRendererGpuTest() : parent_window_(ui::GetHiddenWindow()) {}

  DCompPresenter* presenter() { return presenter_.get(); }

  DCLayerTree* layer_tree() { return presenter()->GetLayerTreeForTesting(); }

  DCLayerTree::DelegatedInkRenderer* ink_renderer() {
    return layer_tree()->GetInkRendererForTesting();
  }

  void SendDelegatedInkPoint(const gfx::DelegatedInkPoint& point) {
    stored_points_[point.pointer_id()].push_back(point);
    ink_renderer()->StoreDelegatedInkPoint(point);
  }

  void SendDelegatedInkPointBasedOnPrevious(uint32_t pointer_id) {
    EXPECT_TRUE(stored_points_.find(pointer_id) != stored_points_.end());
    EXPECT_TRUE(!stored_points_[pointer_id].empty());

    auto last_point = stored_points_[pointer_id].back();
    SendDelegatedInkPoint(gfx::DelegatedInkPoint(
        last_point.point() + gfx::Vector2dF(5, 5),
        last_point.timestamp() +
            base::Microseconds(kMicrosecondsBetweenEachPoint),
        last_point.pointer_id()));
  }

  void SendDelegatedInkPointBasedOnPrevious() {
    EXPECT_EQ(stored_points_.size(), 1u);
    SendDelegatedInkPointBasedOnPrevious(stored_points_.begin()->first);
  }

  void SendMetadata(const gfx::DelegatedInkMetadata& metadata) {
    ink_renderer()->SetDelegatedInkTrailStartPoint(
        std::make_unique<gfx::DelegatedInkMetadata>(metadata));
  }

  // Sends a DelegatedInkMetadata that starts a new trail. this assumes that
  // there is only one `stored_points_` pointer id and that the points are
  // stored ordered by their timestamp.
  void SendNewTrailMetadata() {
    EXPECT_EQ(stored_points_.size(), 1u);
    auto points_it = stored_points_.find(stored_points_.begin()->first);
    EXPECT_TRUE(points_it != stored_points_.end());
    auto points_vec = points_it->second;
    EXPECT_GT(points_vec.size(), 0u);
    auto& last_point = points_vec.back();
    gfx::DelegatedInkMetadata metadata(
        last_point.point() + gfx::Vector2dF(5, 5), /*diameter=*/3,
        SK_ColorBLACK,
        last_point.timestamp() +
            base::Microseconds(kMicrosecondsBetweenEachPoint),
        gfx::RectF(0, 0, 100, 100), /*hovering=*/false);

    ink_renderer()->SetDelegatedInkTrailStartPoint(
        std::make_unique<gfx::DelegatedInkMetadata>(metadata));
  }

  gfx::DelegatedInkMetadata SendMetadataBasedOnStoredPoint(int32_t pointer_id,
                                                           uint64_t point) {
    EXPECT_TRUE(stored_points_.find(pointer_id) != stored_points_.end());
    EXPECT_GE(stored_points_[pointer_id].size(), point);

    const gfx::DelegatedInkPoint& ink_point = stored_points_[pointer_id][point];
    gfx::DelegatedInkMetadata metadata(
        ink_point.point(), /*diameter=*/3, SK_ColorBLACK, ink_point.timestamp(),
        gfx::RectF(0, 0, 100, 100), /*hovering=*/false);
    SendMetadata(metadata);
    return metadata;
  }

  gfx::DelegatedInkMetadata SendMetadataBasedOnStoredPoint(uint64_t point) {
    EXPECT_EQ(stored_points_.size(), 1u);
    return SendMetadataBasedOnStoredPoint(stored_points_.begin()->first, point);
  }

  void StoredMetadataMatchesSentMetadata(
      const gfx::DelegatedInkMetadata& sent_metadata) {
    gfx::DelegatedInkMetadata* renderer_metadata =
        ink_renderer()->MetadataForTesting();
    EXPECT_TRUE(renderer_metadata);
    EXPECT_EQ(renderer_metadata->point(), sent_metadata.point());
    EXPECT_EQ(renderer_metadata->diameter(), sent_metadata.diameter());
    EXPECT_EQ(renderer_metadata->color(), sent_metadata.color());
    EXPECT_EQ(renderer_metadata->timestamp(), sent_metadata.timestamp());
    EXPECT_EQ(renderer_metadata->presentation_area(),
              sent_metadata.presentation_area());
    EXPECT_EQ(renderer_metadata->is_hovering(), sent_metadata.is_hovering());
  }

 protected:
  void SetUp() override {
    // Without this, the following check always fails.
    display_ = gl::init::InitializeGLNoExtensionsOneOff(
        /*init_bindings=*/true,
        /*gpu_preference=*/gl::GpuPreference::kDefault);
    if (!gl::DirectCompositionSupported()) {
      GTEST_SKIP()
          << "GL implementation not using DirectComposition, skipping test.";
    }

    std::tie(gl_surface_, context_) =
        GLTestHelper::CreateOffscreenGLSurfaceAndContext();

    CreateDCompPresenter();

    if (!presenter_->SupportsDelegatedInk()) {
      GTEST_SKIP() << "Delegated ink unsupported, skipping test.";
    }

    // Create the swap chain
    constexpr gfx::Size window_size(100, 100);
    EXPECT_TRUE(presenter_->Resize(window_size, 1.0, gfx::ColorSpace(), true));

    ink_renderer()->InitializeForTesting(gl::GetDirectCompositionDevice());
  }

  void TearDown() override {
    context_.reset();
    gl_surface_.reset();
    if (presenter_) {
      DestroyPresenter(std::move(presenter_));
    }
    gl::init::ShutdownGL(display_, false);
  }

 private:
  void CreateDCompPresenter() {
    DCompPresenter::Settings settings;
    presenter_ = base::MakeRefCounted<DCompPresenter>(settings);

    // Add our child window to the root window.
    if (parent_window_)
      ::SetParent(presenter_->GetWindow(), parent_window_);
  }

  void DestroyPresenter(scoped_refptr<DCompPresenter> presenter) {
    scoped_refptr<base::TaskRunner> task_runner =
        presenter->GetWindowTaskRunnerForTesting();
    EXPECT_TRUE(presenter->HasOneRef());

    presenter = nullptr;

    base::RunLoop run_loop;
    task_runner->PostTask(FROM_HERE, run_loop.QuitClosure());
    run_loop.Run();
  }

  HWND parent_window_;
  scoped_refptr<GLSurface> gl_surface_;
  scoped_refptr<DCompPresenter> presenter_;
  scoped_refptr<GLContext> context_;
  raw_ptr<GLDisplay> display_ = nullptr;

  // Used as a reference when making DelegatedInkMetadatas based on previously
  // sent points.
  std::map<int32_t, std::vector<gfx::DelegatedInkPoint>> stored_points_;
};

// Test to confirm that points and tokens are stored and removed correctly based
// on when the metadata and points arrive.
TEST_F(DelegatedInkPointRendererGpuTest, StoreAndRemovePointsAndTokens) {
  // Send some points and make sure they are all stored even with no metadata.
  const int32_t kPointerId = 1;
  SendDelegatedInkPoint(gfx::DelegatedInkPoint(
      gfx::PointF(10, 10), base::TimeTicks::Now(), kPointerId));
  const uint64_t kPointsToStore = 5u;
  for (uint64_t i = 1; i < kPointsToStore; ++i)
    SendDelegatedInkPointBasedOnPrevious();

  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId).size(),
            kPointsToStore);
  EXPECT_EQ(ink_renderer()->InkTrailTokenCountForTesting(), 0u);
  EXPECT_FALSE(ink_renderer()->MetadataForTesting());
  EXPECT_TRUE(ink_renderer()->WaitForNewTrailToDrawForTesting());

  // Now send metadata that matches the first stored point. This should result
  // in all of the points being drawn and matching tokens stored. None of the
  // points should be removed from the circular deque because they are stored
  // until a metadata arrives with a later timestamp
  gfx::DelegatedInkMetadata metadata = SendMetadataBasedOnStoredPoint(0);

  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId).size(),
            kPointsToStore);
  EXPECT_EQ(ink_renderer()->InkTrailTokenCountForTesting(), kPointsToStore);
  EXPECT_FALSE(ink_renderer()->WaitForNewTrailToDrawForTesting());
  StoredMetadataMatchesSentMetadata(metadata);

  // Now send a metadata that matches a later one of the points. It should
  // result in all of the points up to and including the point that matches
  // the metadata being erased. Then, all remaining points should be drawn and
  // should therefore have tokens associated with them.
  const uint64_t kPointToSend = 3u;
  metadata = SendMetadataBasedOnStoredPoint(kPointToSend);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId).size(),
            kPointsToStore - kPointToSend - 1);
  EXPECT_EQ(ink_renderer()->InkTrailTokenCountForTesting(),
            kPointsToStore - kPointToSend - 1);
  StoredMetadataMatchesSentMetadata(metadata);

  // Now send a metadata after all of the stored point to make sure that it
  // results in all the tokens and stored points being erased because a new
  // trail is started.
  gfx::DelegatedInkPoint last_point =
      ink_renderer()->DelegatedInkPointsForTesting(kPointerId).rbegin()->first;
  metadata = gfx::DelegatedInkMetadata(
      last_point.point() + gfx::Vector2dF(2, 2), /*diameter=*/3, SK_ColorBLACK,
      last_point.timestamp() + base::Microseconds(20),
      gfx::RectF(0, 0, 100, 100), /*hovering=*/false);
  SendMetadata(metadata);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointPointerIdCountForTesting(), 0u);
  StoredMetadataMatchesSentMetadata(metadata);
}

// Basic test to confirm that points are drawn as they arrive if they are in the
// presentation area and after the metadata's timestamp.
TEST_F(DelegatedInkPointRendererGpuTest, DrawPointsAsTheyArrive) {
  gfx::DelegatedInkMetadata metadata(
      gfx::PointF(12, 12), /*diameter=*/3, SK_ColorBLACK,
      base::TimeTicks::Now(), gfx::RectF(10, 10, 90, 90), /*hovering=*/false);
  SendMetadata(metadata);

  // Send some points that should all be drawn to ensure that they are all drawn
  // as they arrive.
  const int32_t kPointerId = 1;
  const uint64_t kPointsToSend = 5u;
  for (uint64_t i = 1u; i <= kPointsToSend; ++i) {
    if (i == 1) {
      SendDelegatedInkPoint(gfx::DelegatedInkPoint(
          metadata.point(), metadata.timestamp(), kPointerId));
    } else {
      SendDelegatedInkPointBasedOnPrevious();
    }
    EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId).size(),
              i);
    EXPECT_EQ(ink_renderer()->InkTrailTokenCountForTesting(), i);
  }

  // Now send a point that is outside of the presentation area to ensure that
  // it is not drawn. It will still be stored - this is so if a future metadata
  // arrives with a presentation area that would contain this point, it can
  // still be drawn.
  gfx::DelegatedInkPoint last_point =
      ink_renderer()->DelegatedInkPointsForTesting(kPointerId).rbegin()->first;
  gfx::DelegatedInkPoint outside_point(
      gfx::PointF(5, 5), last_point.timestamp() + base::Microseconds(10),
      /*pointer_id=*/1);
  EXPECT_FALSE(metadata.presentation_area().Contains(outside_point.point()));
  SendDelegatedInkPoint(outside_point);

  const uint64_t kTotalPointsSent = kPointsToSend + 1u;
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId).size(),
            kTotalPointsSent);
  EXPECT_EQ(ink_renderer()->InkTrailTokenCountForTesting(), kPointsToSend);

  // Then send a metadata with a larger presentation area and timestamp earlier
  // than the above point to confirm it will be the only point drawn, but all
  // the points with later timestamps will be stored.
  const uint64_t kMetadataToSend = 3u;
  SendMetadataBasedOnStoredPoint(kMetadataToSend);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId).size(),
            kTotalPointsSent - kMetadataToSend - 1);
  EXPECT_EQ(ink_renderer()->InkTrailTokenCountForTesting(), 1u);
}

// Confirm that points with different pointer ids are handled correctly.
TEST_F(DelegatedInkPointRendererGpuTest, MultiplePointerIds) {
  const int32_t kPointerId1 = 1;
  const int32_t kPointerId2 = 2;

  // First send a few points with different pointer ids to make sure they are
  // stored separately and correctly. Separate the timestamps so that we can
  // test how sending metadatas impacts them each separately.
  const base::TimeTicks timestamp = base::TimeTicks::Now();
  const int kPointerId2PointsAheadOfPointerId1 = 3;
  SendDelegatedInkPoint(
      gfx::DelegatedInkPoint(gfx::PointF(16, 22), timestamp, kPointerId1));
  SendDelegatedInkPoint(gfx::DelegatedInkPoint(
      gfx::PointF(40, 13.3f),
      timestamp + base::Microseconds(kPointerId2PointsAheadOfPointerId1 *
                                     kMicrosecondsBetweenEachPoint),
      kPointerId2));

  uint64_t pointer_id_1_count = 1u;
  uint64_t pointer_id_2_count = 1u;
  const uint64_t kTotalPoints = 9u;
  for (uint64_t i = 0u; i < kTotalPoints; ++i) {
    if (i % 2 == 0) {
      SendDelegatedInkPointBasedOnPrevious(kPointerId1);
      pointer_id_1_count++;
    } else {
      SendDelegatedInkPointBasedOnPrevious(kPointerId2);
      pointer_id_2_count++;
    }
  }

  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId1).size(),
            pointer_id_1_count);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId2).size(),
            pointer_id_2_count);

  // Send a metadata matching one of the points with |kPointerId1|. This should
  // erase all points with a timestamp before that from the trail with
  // |kPointerId1| but none from the other pointer id.
  const uint64_t kMetadataToSendForPointerId1 = 1u;
  SendMetadataBasedOnStoredPoint(kPointerId1, kMetadataToSendForPointerId1);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId1).size(),
            pointer_id_1_count - kMetadataToSendForPointerId1);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId2).size(),
            pointer_id_2_count);

  // Now send a metadata matching one of the points with |kPointerId2|. Since
  // |kPointerId2| points have timestamps greater than |kPointerId1|, it should
  // cause some points with |kPointerId1| to be erased too.
  const uint64_t kMetadataToSendForPointerId2 = 2u;
  SendMetadataBasedOnStoredPoint(kPointerId2, kMetadataToSendForPointerId2);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId1).size(),
            pointer_id_1_count - kPointerId2PointsAheadOfPointerId1 -
                kMetadataToSendForPointerId2);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId2).size(),
            pointer_id_2_count - kMetadataToSendForPointerId2);

  // Add another pointer id into the mix and make sure the counts are all what
  // we expect.
  const int32_t kPointerId3 = 3;
  const int kPointerId3PointsAheadOfPointerId1 = 5;
  SendDelegatedInkPoint(gfx::DelegatedInkPoint(
      gfx::PointF(23, 64),
      timestamp + base::Microseconds(kPointerId3PointsAheadOfPointerId1 *
                                     kMicrosecondsBetweenEachPoint),
      kPointerId3));

  const uint64_t kPointsWithPointerId3 = 4u;
  for (uint64_t i = 1u; i < kPointsWithPointerId3; ++i)
    SendDelegatedInkPointBasedOnPrevious(kPointerId3);

  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId1).size(),
            pointer_id_1_count - kPointerId2PointsAheadOfPointerId1 -
                kMetadataToSendForPointerId2);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId2).size(),
            pointer_id_2_count - kMetadataToSendForPointerId2);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId3).size(),
            kPointsWithPointerId3);

  // Then send a point with |kPointerId3| that is beyond all the points with
  // |kPointerId1| to make sure that |kPointerId1| is removed from the flat map
  // completely.
  const uint64_t kMetadataToSendForPointerId3 = 1u;
  SendMetadataBasedOnStoredPoint(kPointerId3, kMetadataToSendForPointerId3);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointPointerIdCountForTesting(), 2u);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId2).size(),
            pointer_id_2_count - kMetadataToSendForPointerId2 -
                kMetadataToSendForPointerId3);
  EXPECT_EQ(ink_renderer()->DelegatedInkPointsForTesting(kPointerId3).size(),
            kPointsWithPointerId3 - kMetadataToSendForPointerId3);
}

// Make sure that the DelegatedInkPoint with the earliest timestamp is removed
// if we have reached the maximum number of pointer ids.
TEST_F(DelegatedInkPointRendererGpuTest, MaximumPointerIds) {
  // First add DelegatedInkPoints with unique pointer ids up to the limit and
  // make sure they are all correctly added separately.
  const base::TimeTicks kEarliestTimestamp =
      base::TimeTicks::Now() -
      base::Microseconds(kMicrosecondsBetweenEachPoint);
  const int32_t kEarliestTimestampPointerId = 4;

  base::TimeTicks timestamp = base::TimeTicks::Now();
  gfx::PointF point(34.4f, 20);
  const uint64_t kMaxNumberOfPointerIds =
      ink_renderer()->GetMaximumNumberOfPointerIdsForTesting();
  for (uint64_t pointer_id = 0; pointer_id < kMaxNumberOfPointerIds;
       ++pointer_id) {
    SendDelegatedInkPoint(gfx::DelegatedInkPoint(
        point,
        pointer_id == kEarliestTimestampPointerId ? kEarliestTimestamp
                                                  : timestamp,
        pointer_id));
    point += gfx::Vector2dF(5, 5);
    timestamp += base::Microseconds(kMicrosecondsBetweenEachPoint);
  }

  EXPECT_EQ(ink_renderer()->DelegatedInkPointPointerIdCountForTesting(),
            kMaxNumberOfPointerIds);
  EXPECT_TRUE(
      ink_renderer()->CheckForPointerIdForTesting(kEarliestTimestampPointerId));

  // Now send one more with a later timestamp to ensure that the one with the
  // earliest timestamp was removed.
  SendDelegatedInkPoint(
      gfx::DelegatedInkPoint(point, timestamp, kMaxNumberOfPointerIds));

  EXPECT_EQ(ink_renderer()->DelegatedInkPointPointerIdCountForTesting(),
            kMaxNumberOfPointerIds);
  EXPECT_FALSE(
      ink_renderer()->CheckForPointerIdForTesting(kEarliestTimestampPointerId));

  // Finally, add a point with a earlier timestamp than everything else and make
  // sure that it is not added to the map of pointer ids.
  point += gfx::Vector2dF(5, 5);
  timestamp = kEarliestTimestamp + base::Microseconds(5);
  const int32_t kEarlyTimestampPointerId = kMaxNumberOfPointerIds + 1;
  SendDelegatedInkPoint(
      gfx::DelegatedInkPoint(point, timestamp, kEarlyTimestampPointerId));

  EXPECT_EQ(ink_renderer()->DelegatedInkPointPointerIdCountForTesting(),
            kMaxNumberOfPointerIds);
  EXPECT_FALSE(
      ink_renderer()->CheckForPointerIdForTesting(kEarlyTimestampPointerId));
}

// Verify that the `points_to_be_drawn_` is set correctly when points are
// added to the API's trail, and that the TimeToDrawPointsMillis histogram is
// reported correctly on draw.
TEST_F(DelegatedInkPointRendererGpuTest, ReportTimeToDraw) {
  const std::string kHistogramName =
      "Renderer.DelegatedInkTrail.OS.TimeToDrawPointsMillis";
  const base::HistogramTester histogram_tester;
  constexpr int32_t kPointerId = 1u;

  EXPECT_TRUE(ink_renderer()->PointstoBeDrawnForTesting().empty());
  ink_renderer()->ReportPointsDrawn();
  // No histogram should be fired if `points_to_be_drawn_` is empty.
  histogram_tester.ExpectTotalCount(kHistogramName, 0);

  const base::TimeTicks timestamp = base::TimeTicks::Now();
  SendDelegatedInkPoint(
      gfx::DelegatedInkPoint(gfx::PointF(20, 20), timestamp, kPointerId));
  SendMetadataBasedOnStoredPoint(0);

  // `DrawDelegatedInkPoint` should've added the point's timestamp to
  // `points_to_be_drawn_`.
  EXPECT_EQ(ink_renderer()->PointstoBeDrawnForTesting().size(), 1u);
  EXPECT_EQ(ink_renderer()->PointstoBeDrawnForTesting()[0].timestamp(),
            timestamp);

  // Send another point and expect that the new point's timestamp is added to
  // `points_to_be_drawn_`.
  SendDelegatedInkPointBasedOnPrevious(kPointerId);
  EXPECT_EQ(ink_renderer()->PointstoBeDrawnForTesting().size(), 2u);
  EXPECT_EQ(ink_renderer()->PointstoBeDrawnForTesting()[1].timestamp(),
            timestamp + base::Microseconds(kMicrosecondsBetweenEachPoint));

  ink_renderer()->ReportPointsDrawn();
  // Two histograms should've been fired with the delta between the point's
  // creation times and the function call, and `points_to_be_drawn_` should've
  // been cleared.
  histogram_tester.ExpectTotalCount(kHistogramName, 2);
  EXPECT_TRUE(ink_renderer()->PointstoBeDrawnForTesting().empty());
}
// Test that stale points get removed from `points_to_be_drawn_` when a newer
// metadata is added.
TEST_F(DelegatedInkPointRendererGpuTest,
       PointsToBeDrawnIsClearedWithNewMetadata) {
  constexpr int32_t kPointerId = 1u;
  const base::TimeTicks timestamp = base::TimeTicks::Now();
  SendDelegatedInkPoint(
      gfx::DelegatedInkPoint(gfx::PointF(20, 20), timestamp, kPointerId));
  SendMetadataBasedOnStoredPoint(0);
  EXPECT_EQ(ink_renderer()->PointstoBeDrawnForTesting().size(), 1u);
  // Test that sending a metadata with a timestamp larger than some points will
  // remove those points from the points to be drawn vector.
  SendDelegatedInkPointBasedOnPrevious();
  SendDelegatedInkPointBasedOnPrevious();
  SendDelegatedInkPointBasedOnPrevious();
  SendMetadataBasedOnStoredPoint(3);
  // The new metadata should cause all points but the last one to be deleted.
  EXPECT_EQ(ink_renderer()->PointstoBeDrawnForTesting().size(), 1u);

  // A metadata that starts a new trail should clear all the points in the
  // vector.
  SendNewTrailMetadata();
  EXPECT_EQ(ink_renderer()->PointstoBeDrawnForTesting().size(), 0u);
}

TEST_F(DelegatedInkPointRendererGpuTest, ReportLatencyImprovement) {
  const std::string kHistogramName =
      "Renderer.DelegatedInkTrail.LatencyImprovement.OS.WithoutPrediction";
  const base::HistogramTester histogram_tester;
  constexpr int32_t kPointerId = 1u;

  ink_renderer()->ReportPointsDrawn();
  // No histogram should be fired if `points_to_be_drawn_` is empty.
  EXPECT_TRUE(ink_renderer()->PointstoBeDrawnForTesting().empty());
  histogram_tester.ExpectTotalCount(kHistogramName, 0);

  // Create three points, `kMicrosecondsBetweenEachPoint` milliseconds apart
  // from each other (the histogram is measured in ms, microseconds would be
  // too small of a difference).
  gfx::DelegatedInkPoint point_1(gfx::PointF(20, 20), base::TimeTicks::Now(),
                                 kPointerId);
  gfx::DelegatedInkPoint point_2(
      point_1.point() + gfx::Vector2dF(5, 5),
      point_1.timestamp() + base::Milliseconds(kMicrosecondsBetweenEachPoint),
      kPointerId);
  gfx::DelegatedInkPoint point_3(
      point_2.point() + gfx::Vector2dF(5, 5),
      point_2.timestamp() + base::Milliseconds(kMicrosecondsBetweenEachPoint),
      kPointerId);
  SendDelegatedInkPoint(point_1);
  SendDelegatedInkPoint(point_2);
  SendDelegatedInkPoint(point_3);
  SendMetadataBasedOnStoredPoint(0);
  ink_renderer()->ReportPointsDrawn();

  // One histogram should've been fired with the delta between the metadata's
  // creation times and the `point_3`'s timestamp, in milliseconds.
  histogram_tester.ExpectUniqueSample(kHistogramName,
                                      kMicrosecondsBetweenEachPoint * 2, 1);
  EXPECT_TRUE(ink_renderer()->PointstoBeDrawnForTesting().empty());
}

TEST_F(DelegatedInkPointRendererGpuTest, ReportOutstandingPointsToDraw) {
  const std::string kHistogramName =
      "Renderer.DelegatedInkTrail.OS.OutstandingPointsToDraw";
  const base::HistogramTester histogram_tester;
  constexpr int32_t kPointerId = 1u;

  // No histogram should be fired when `metadata_paint_time_` is not set.
  histogram_tester.ExpectTotalCount(kHistogramName, 0);

  SendDelegatedInkPoint(gfx::DelegatedInkPoint(
      gfx::PointF(10, 10), base::TimeTicks::Now(), kPointerId));
  ink_renderer()->ReportPointsDrawn();
  SendMetadataBasedOnStoredPoint(0);
  ink_renderer()->ReportPointsDrawn();
  histogram_tester.ExpectUniqueSample(kHistogramName, 1, 1);
  SendDelegatedInkPointBasedOnPrevious();
  SendDelegatedInkPointBasedOnPrevious();
  ink_renderer()->ReportPointsDrawn();
  histogram_tester.ExpectBucketCount(kHistogramName, 2, 1);
  histogram_tester.ExpectBucketCount(kHistogramName, 1, 1);
  SendDelegatedInkPointBasedOnPrevious();
  SendDelegatedInkPointBasedOnPrevious();
  SendDelegatedInkPointBasedOnPrevious();
  ink_renderer()->ReportPointsDrawn();
  histogram_tester.ExpectBucketCount(kHistogramName, 3, 1);
  histogram_tester.ExpectBucketCount(kHistogramName, 2, 1);
  histogram_tester.ExpectBucketCount(kHistogramName, 1, 1);
}

// Test that the histogram `TimeFromDelegatedInkToApiPaint` is fired when a
// point is painted via the Delegated Ink API and then found to match a metadata
// point.
TEST_F(DelegatedInkPointRendererGpuTest, TestTimeFromDelegatedInkToApiPaint) {
  const std::string kHistogramName =
      "Renderer.DelegatedInkTrail.OS.TimeFromDelegatedInkToApiPaint";
  const base::HistogramTester histogram_tester;
  constexpr int32_t kPointerId = 1u;

  ink_renderer()->ReportPointsDrawn();
  // No histogram should be fired when `metadata_paint_time_` is not set.
  histogram_tester.ExpectTotalCount(kHistogramName, 0);

  SendDelegatedInkPoint(gfx::DelegatedInkPoint(
      gfx::PointF(10, 10), base::TimeTicks::Now(), kPointerId));
  // This metadata starts the trail and calls `DrawSavedTrailPoints`.
  SendMetadataBasedOnStoredPoint(0);
  // The `painted_time` timestamp should be set for the point with the
  // value of `base::TimeTicks::Now()`.
  ink_renderer()->ReportPointsDrawn();
  gfx::DelegatedInkPoint last_point =
      ink_renderer()->DelegatedInkPointsForTesting(kPointerId).rbegin()->first;
  EXPECT_TRUE(last_point.paint_timestamp().has_value());
  // `metadata_paint_time_` is not set yet, so the histogram should not have
  // been fired.
  histogram_tester.ExpectTotalCount(kHistogramName, 0);

  // Simulate receiving another point and painting it.
  SendDelegatedInkPointBasedOnPrevious();
  ink_renderer()->ReportPointsDrawn();
  // A new metadata is received that matches a Delegated Ink point with a
  // `painted_time` timestamp, so a histogram should be fired on next paint.
  SendMetadataBasedOnStoredPoint(1);
  ink_renderer()->ReportPointsDrawn();
  histogram_tester.ExpectTotalCount(kHistogramName, 1);

  // Adding a new point without updating the metadata should not fire a new
  // histogram.
  SendDelegatedInkPointBasedOnPrevious();
  ink_renderer()->ReportPointsDrawn();
  histogram_tester.ExpectTotalCount(kHistogramName, 1);

  // Send the metadata that matches the previous point and verify that a
  // histogram was fired.
  SendMetadataBasedOnStoredPoint(2);
  ink_renderer()->ReportPointsDrawn();
  histogram_tester.ExpectTotalCount(kHistogramName, 2);

  // Add a new point, then send a metadata that does not match it. Then verify
  // that a histogram wasn't fired.
  SendDelegatedInkPointBasedOnPrevious();
  ink_renderer()->ReportPointsDrawn();
  last_point =
      ink_renderer()->DelegatedInkPointsForTesting(kPointerId).rbegin()->first;
  SendMetadata(gfx::DelegatedInkMetadata(
      last_point.point() + gfx::Vector2dF(2, 2), /*diameter=*/3, SK_ColorBLACK,
      last_point.timestamp() + base::Microseconds(20),
      gfx::RectF(0, 0, 100, 100), /*hovering=*/false));
  ink_renderer()->ReportPointsDrawn();
  histogram_tester.ExpectTotalCount(kHistogramName, 2);
}

}  // namespace
}  // namespace gl