Add constructors to WebInputEvents and setters so we can work at cleaning up these public structs.

chrome/browser/page_load_metrics/user_input_tracker_unittest.cc

 // Copyright 2016 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 "chrome/browser/page_load_metrics/user_input_tracker.h"
 
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 
 namespace page_load_metrics {
 
 namespace {
 
 // UserInputTracker allows events to be at most 2 seconds old. Thus we use
 // 2100ms to make sure the age is greater than 2 seconds.
 const int kTooOldMilliseconds = 2100;
 
 double ToMonotonicallyIncreasingSeconds(base::TimeTicks t) {
   return (t - base::TimeTicks()).InSecondsF();
 }
 
 class FakeInputEvent : public blink::WebInputEvent {
  public:
-  FakeInputEvent() : WebInputEvent(sizeof(FakeInputEvent)) {
-    timeStampSeconds = ToMonotonicallyIncreasingSeconds(base::TimeTicks::Now());
-    type = blink::WebInputEvent::Char;
-  }
+  FakeInputEvent(blink::WebInputEvent::Type type = blink::WebInputEvent::Char,

[Lei Zhang, 2017/02/24 08:43:23]

I'm personally biased again default arguments. You could have made this without
default arguments and added a default ctor that delegates to this one. That
would cover everything except the IgnoredEventType case.

But this is also a test, and it's not my code. So I'm meh more about it. Maybe
mention this to bmcquade and see if there's a stronger preference?

+                 int modifiers = blink::WebInputEvent::NoModifiers)
+      : WebInputEvent(
+            sizeof(FakeInputEvent),
+            type,
+            modifiers,
+            ToMonotonicallyIncreasingSeconds(base::TimeTicks::Now())) {}
 
   base::TimeTicks GetTimeStamp() {
     return UserInputTracker::GetEventTime(*this);
   }
 
   base::TimeTicks GetTimeStampRounded() {
     return UserInputTracker::RoundToRateLimitedOffset(GetTimeStamp());
   }
 };
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(base::TimeTicks(),
             tracker.FindMostRecentUserInputEventBefore(after));
 }
 
 TEST_F(UserInputTrackerTest, MultipleEvents) {
   FakeInputEvent e1;
   FakeInputEvent e2;
 
   // Make sure that the two events are monotonically increasing, and that both
   // are in the past.
-  e1.timeStampSeconds = ToMonotonicallyIncreasingSeconds(
-      e2.GetTimeStamp() - base::TimeDelta::FromMilliseconds(100));
+  e1.setTimeStampSeconds(ToMonotonicallyIncreasingSeconds(
+      e2.GetTimeStamp() - base::TimeDelta::FromMilliseconds(100)));
 
   base::TimeTicks after =
       e2.GetTimeStampRounded() + base::TimeDelta::FromMicroseconds(1);
 
   {
     UserInputTracker tracker;
     tracker.OnInputEvent(e1);
     tracker.OnInputEvent(e2);
 
     EXPECT_EQ(base::TimeTicks(), tracker.FindMostRecentUserInputEventBefore(
@@ skipping 35 matching lines @@
               tracker.FindMostRecentUserInputEventBefore(after));
   }
 }
 
 TEST_F(UserInputTrackerTest, IgnoreEventsOlderThanConsumed) {
   FakeInputEvent e1;
   FakeInputEvent e2;
 
   // Make sure that the two events are monotonically increasing, and that both
   // are in the past.
-  e1.timeStampSeconds = ToMonotonicallyIncreasingSeconds(
-      e2.GetTimeStamp() - base::TimeDelta::FromMilliseconds(100));
+  e1.setTimeStampSeconds(ToMonotonicallyIncreasingSeconds(
+      e2.GetTimeStamp() - base::TimeDelta::FromMilliseconds(100)));
 
   base::TimeTicks after =
       e2.GetTimeStampRounded() + base::TimeDelta::FromMicroseconds(1);
 
   UserInputTracker tracker;
   tracker.OnInputEvent(e2);
 
   EXPECT_EQ(base::TimeTicks(), tracker.FindMostRecentUserInputEventBefore(
                                    e1.GetTimeStampRounded()));
   EXPECT_EQ(base::TimeTicks(), tracker.FindMostRecentUserInputEventBefore(
@@ skipping 11 matching lines @@
   EXPECT_EQ(base::TimeTicks(), tracker.FindMostRecentUserInputEventBefore(
                                    e1.GetTimeStampRounded() +
                                    base::TimeDelta::FromMicroseconds(1)));
 }
 
 TEST_F(UserInputTrackerTest, ExcludeOldEvents) {
   UserInputTracker tracker;
   FakeInputEvent e1;
   FakeInputEvent e2;
   // make sure e1 is too old to be considered.
-  e1.timeStampSeconds = ToMonotonicallyIncreasingSeconds(
+  e1.setTimeStampSeconds(ToMonotonicallyIncreasingSeconds(
       e2.GetTimeStamp() -
-      base::TimeDelta::FromMilliseconds(kTooOldMilliseconds));
+      base::TimeDelta::FromMilliseconds(kTooOldMilliseconds)));
 
   tracker.OnInputEvent(e1);
   tracker.OnInputEvent(e2);
 
   EXPECT_EQ(base::TimeTicks(), tracker.FindMostRecentUserInputEventBefore(
                                    e1.GetTimeStampRounded() +
                                    base::TimeDelta::FromMilliseconds(1)));
   EXPECT_EQ(base::TimeTicks(),
             tracker.FindMostRecentUserInputEventBefore(
                 e2.GetTimeStampRounded() +
@@ skipping 11 matching lines @@
   const size_t kTooManyEntries = UserInputTracker::kMaxTrackedEvents * 5;
 
   UserInputTracker tracker;
   FakeInputEvent e;
 
   // UserInputTracker DCHECKs that event timestamps aren't after the current
   // time, so to be safe, we use a starting timestamp that is twice
   // kTooManyEntries milliseconds in the past, and then synthesize one event for
   // each of kTooManyEntries after this start point. This guarantees that all
   // events are in the past.
-  e.timeStampSeconds = ToMonotonicallyIncreasingSeconds(
+  e.setTimeStampSeconds(ToMonotonicallyIncreasingSeconds(
       e.GetTimeStamp() -
-      base::TimeDelta::FromMilliseconds(kTooManyEntries * 2));
+      base::TimeDelta::FromMilliseconds(kTooManyEntries * 2)));
 
   // Insert more than kMaxEntries entries. The rate limiting logic should
   // prevent more than kMaxEntries entries from actually being inserted. A
   // DCHECK in OnInputEvent verifies that we don't exceed the expected capacity.
   for (size_t i = 0; i < kTooManyEntries; ++i) {
     tracker.OnInputEvent(e);
-    e.timeStampSeconds += base::TimeDelta::FromMilliseconds(1).InSecondsF();
+    e.setTimeStampSeconds(e.timeStampSeconds +
+                          base::TimeDelta::FromMilliseconds(1).InSecondsF());
   }
 
   // Do a basic sanity check to make sure we can find events in the tracker.
   EXPECT_NE(base::TimeTicks(),
             tracker.FindMostRecentUserInputEventBefore(base::TimeTicks::Now()));
 }
 
 TEST_F(UserInputTrackerTest, IgnoredEventType) {
   UserInputTracker tracker;
-  FakeInputEvent e;
-  e.type = blink::WebInputEvent::MouseMove;
+  FakeInputEvent e(blink::WebInputEvent::MouseMove);
   tracker.OnInputEvent(e);
   EXPECT_EQ(base::TimeTicks(), tracker.FindMostRecentUserInputEventBefore(
                                    e.GetTimeStampRounded() +
                                    base::TimeDelta::FromMilliseconds(1)));
 }
 
 TEST_F(UserInputTrackerTest, IgnoreRepeatEvents) {
   UserInputTracker tracker;
-  FakeInputEvent e;
-  e.modifiers |= blink::WebInputEvent::IsAutoRepeat;
+  FakeInputEvent e(blink::WebInputEvent::Char,
+                   blink::WebInputEvent::IsAutoRepeat);
   tracker.OnInputEvent(e);
   EXPECT_EQ(base::TimeTicks(), tracker.FindMostRecentUserInputEventBefore(
                                    e.GetTimeStampRounded() +
                                    base::TimeDelta::FromMilliseconds(1)));
 }
 
 }  // namespace page_load_metrics