linux: port Jankometer

chrome/browser/jankometer.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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 <limits>
 
 #include "chrome/browser/jankometer.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "base/watchdog.h"
+#include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/chrome_switches.h"
 
+#if defined(OS_LINUX)
+#include "chrome/common/gtk_util.h"
+#endif
+
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
 
 // The maximum threshold of delay of the message  before considering it a delay.
 // For a debug build, you may want to set IO delay around 500ms.
 // For a release build, setting it around 350ms is sensible.
 // Visit about:histograms to see what the distribution is on your system, with
 // your build. Be sure to do some work to get interesting stats.
@@ skipping 70 matching lines @@
     if (MessageLoop::current()->type() == MessageLoop::TYPE_UI)
       MessageLoopForUI::current()->AddObserver(this);
   }
 
   // Detaches the observer to the current thread's message loop.
   void DetachFromCurrentThread() {
     if (MessageLoop::current()->type() == MessageLoop::TYPE_UI)
       MessageLoopForUI::current()->RemoveObserver(this);
   }
 
-  void WillProcessMessage(const MSG& msg) {
-    begin_process_message_ = TimeTicks::Now();
-
-    // GetMessageTime returns a LONG (signed 32-bit) and GetTickCount returns
-    // a DWORD (unsigned 32-bit). They both wrap around when the time is longer
-    // than they can hold. I'm not sure if GetMessageTime wraps around to 0,
-    // or if the original time comes from GetTickCount, it might wrap around
-    // to -1.
-    //
-    // Therefore, I cast to DWORD so if it wraps to -1 we will correct it. If
-    // it doesn't, then our time delta will be negative if a message happens
-    // to straddle the wraparound point, it will still be OK.
-    DWORD cur_message_issue_time = static_cast<DWORD>(msg.time);
-    DWORD cur_time = GetTickCount();
-    queueing_time_ = TimeDelta::FromMilliseconds(cur_time
-                                                 - cur_message_issue_time);
+  void StartProcessingTimers() {
     // Simulate arming when the message entered the queue.
     total_time_watchdog_.ArmSomeTimeDeltaAgo(queueing_time_);
     if (queueing_time_ > MaxMessageDelay_) {
       // Message is too delayed.
       queueing_delay_counter_.Increment();
+#if defined(OS_WIN)
       if (kPlaySounds)
         MessageBeep(MB_ICONASTERISK);
+#endif
     }
   }
 
-  void DidProcessMessage(const MSG& msg) {
+  void EndProcessingTimers() {
     total_time_watchdog_.Disarm();
     TimeTicks now = TimeTicks::Now();
     if (begin_process_message_ != TimeTicks()) {
       TimeDelta processing_time = now - begin_process_message_;
       process_times_.AddTime(processing_time);
       total_times_.AddTime(queueing_time_ + processing_time);
     }
     if (now - begin_process_message_ >
         TimeDelta::FromMilliseconds(kMaxMessageProcessingMs)) {
       // Message took too long to process.
       slow_processing_counter_.Increment();
+#if defined(OS_WIN)
       if (kPlaySounds)
         MessageBeep(MB_ICONHAND);
+#endif
     }
   }
 
+#if defined(OS_WIN)
+  void WillProcessMessage(const MSG& msg) {
+    begin_process_message_ = TimeTicks::Now();
+
+    // GetMessageTime returns a LONG (signed 32-bit) and GetTickCount returns
+    // a DWORD (unsigned 32-bit). They both wrap around when the time is longer
+    // than they can hold. I'm not sure if GetMessageTime wraps around to 0,
+    // or if the original time comes from GetTickCount, it might wrap around
+    // to -1.
+    //
+    // Therefore, I cast to DWORD so if it wraps to -1 we will correct it. If
+    // it doesn't, then our time delta will be negative if a message happens
+    // to straddle the wraparound point, it will still be OK.
+    DWORD cur_message_issue_time = static_cast<DWORD>(msg.time);
+    DWORD cur_time = GetTickCount();
+    queueing_time_ =
+        base::TimeDelta::FromMilliseconds(cur_time - cur_message_issue_time);
+
+    StartProcessingTimers();
+  }
+
+  void DidProcessMessage(const MSG& msg) {
+    EndProcessingTimers();
+  }
+
+#elif defined(OS_LINUX)
+  void WillProcessEvent(GdkEvent* event) {
+    begin_process_message_ = TimeTicks::Now();
+    guint event_time = event_utils::GetGdkEventTime(event);
+    // TODO(evanm): it is not clear what that event_time is relative to!
+    queueing_time_ = false  // TODO: We ignore event_time for now.
+        ? base::TimeDelta::FromMilliseconds(event_time)
+        : base::TimeDelta::FromMilliseconds(0);
+    StartProcessingTimers();
+  }
+
+  void DidProcessEvent(GdkEvent* event) {
+    EndProcessingTimers();
+  }
+#endif
+
  private:
   const TimeDelta MaxMessageDelay_;
+
+  // Time at which the current message processing began.
   TimeTicks begin_process_message_;
+
+  // Time the current message spent in the queue -- delta between message
+  // construction time and message processing time.
   TimeDelta queueing_time_;
 
   // Counters for the two types of jank we measure.
   StatsCounter slow_processing_counter_;  // Messages with long processing time.
   StatsCounter queueing_delay_counter_;   // Messages with long queueing delay.
   Histogram process_times_;           // Time spent processing task.
   Histogram total_times_;             // Total of queueing plus processing time.
   JankWatchdog total_time_watchdog_;  // Watching for excessive total_time.
 
   DISALLOW_EVIL_CONSTRUCTORS(JankObserver);
 };
 
 // These objects are created by InstallJankometer and leaked.
 JankObserver* ui_observer = NULL;
 JankObserver* io_observer = NULL;
 
 }  // namespace
 
-void InstallJankometer(const CommandLine &parsed_command_line) {
+void InstallJankometer(const CommandLine& parsed_command_line) {
   if (ui_observer || io_observer) {
     NOTREACHED() << "Initializing jank-o-meter twice";
     return;
   }
 
   bool ui_watchdog_enabled = false;
   bool io_watchdog_enabled = false;
   if (parsed_command_line.HasSwitch(switches::kEnableWatchdog)) {
     std::wstring list =
         parsed_command_line.GetSwitchValue(switches::kEnableWatchdog);
@@ skipping 33 matching lines @@
     ui_observer->Release();
     ui_observer = NULL;
   }
   if (io_observer) {
     // IO thread can't be running when we remove observers.
     DCHECK((!g_browser_process) || !(g_browser_process->io_thread()));
     io_observer->Release();
     io_observer = NULL;
   }
 }