Replace DCHECK() upon unexpected x11 event time with a workaround

ui/events/x/events_x_utils.cc

 // Copyright (c) 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 "ui/events/x/events_x_utils.h"
 
 #include <stddef.h>
 #include <string.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 288 matching lines @@
   if (!start_time)
     start_time = &start_time_;
   if (!end_time)
     end_time = &end_time_;
 
   ui::DeviceDataManagerX11::GetInstance()->GetGestureTimes(xev, start_time,
                                                            end_time);
   return true;
 }
 
+namespace {
 int64_t g_last_seen_timestamp_ms = 0;
-// accumulated rollover time.
 int64_t g_rollover_ms = 0;
+bool g_bogus_x11_timestamps = false;
 base::LazyInstance<std::unique_ptr<base::TickClock>>::Leaky g_tick_clock =
     LAZY_INSTANCE_INITIALIZER;
+}  // namespace
 
 // Takes Xlib Time and returns a time delta that is immune to timer rollover.
 // This function is not thread safe as we do not use a lock.
 base::TimeDelta TimeDeltaFromXEventTime(Time timestamp) {
   int64_t timestamp64 = timestamp;
 
   if (!timestamp)
     return base::TimeDelta();
 
+  if (g_bogus_x11_timestamps) {
+    return base::TimeDelta::FromMilliseconds(
+        (base::TimeTicks::Now() - base::TimeTicks()).InMilliseconds());

[majidvp, 2016/05/17 13:27:53]

Please use ui::EventTimeForNow() instead.

I don't think we should limit these timestamps to milliseconds resolution if we
are using TimeTicks::Now().

[caseq, 2016/05/20 23:41:33]

Done.

+  }
+
   // If this is the first event that we get, assume the time stamp roll-over
   // might have happened before the process was started.
   // Register a rollover if the distance between last timestamp and current one
   // is larger than half the width. This avoids false rollovers even in a case
   // where X server delivers reasonably close events out-of-order.
   bool had_recent_rollover =
       !g_last_seen_timestamp_ms ||
       g_last_seen_timestamp_ms - timestamp64 > (UINT32_MAX >> 1);
 
   g_last_seen_timestamp_ms = timestamp64;
   if (!had_recent_rollover)
     return base::TimeDelta::FromMilliseconds(g_rollover_ms + timestamp);
 
   DCHECK(timestamp64 <= UINT32_MAX)
       << "X11 Time does not roll over 32 bit, the below logic is likely wrong";
 
   base::TimeTicks now_ticks = g_tick_clock.Get() != nullptr
                                   ? g_tick_clock.Get()->NowTicks()
                                   : base::TimeTicks::Now();
   int64_t now_ms = (now_ticks - base::TimeTicks()).InMilliseconds();
 
   g_rollover_ms = now_ms & ~static_cast<int64_t>(UINT32_MAX);
   uint32_t delta = static_cast<uint32_t>(now_ms - timestamp);
-  // If using a mock clock, all bets are off -- in some tests, actual X11 events
-  // come through with real timestamps.
-  DCHECK(delta < 60 * 1000 || g_tick_clock.Get() != nullptr)
-      << "Unexpected X11 event time, now: " << now_ticks
-      << " event at: " << timestamp;
+  if (delta > 60 * 1000 && !g_tick_clock.Get()) {
+    // x11 timestamps don't seem to be using the same time base as TimeTicks,
+    // so ignore them altogether and always use current time instead.
+    delta = 0;
+    g_bogus_x11_timestamps = true;
+    LOG(WARNING) << "Unexpected x11 timestamps, will use browser time instead.";

[majidvp, 2016/05/17 13:27:53]

I wonder if it makes sense to also collect UMA metrics for this.

I suspect this should not happen very often. But if this turns out to be a large
percentage of cases then it can impact the way we interpret our event latency
telemetry metrics on Linux.

+tdresser@ in case he has opinion one way or another.

[caseq, 2016/05/20 23:41:33]

Done.

+  }
   return base::TimeDelta::FromMilliseconds(now_ms - delta);
 }
 
 }  // namespace
 
 namespace ui {
 
 EventType EventTypeFromXEvent(const XEvent& xev) {
   // Allow the DeviceDataManager to block the event. If blocked return
   // ET_UNKNOWN as the type so this event will not be further processed.
@@ skipping 445 matching lines @@
 
   DeviceDataManagerX11::GetInstance()->GetFlingData(xev, vx, vy, vx_ordinal,
                                                     vy_ordinal, is_cancel);
   return true;
 }
 
 void ResetTimestampRolloverCountersForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   g_last_seen_timestamp_ms = 0;
   g_rollover_ms = 0;
+  g_bogus_x11_timestamps = false;
   g_tick_clock.Get() = std::move(tick_clock);
 }
 
 }  // namespace ui