jankometer: Use the stub implementation for non-Windows.

chrome/browser/jankometer_win.cc

 // Copyright (c) 2012 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/jankometer.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 30 matching lines @@
 const int kMaxIOMessageDelayMs = 200;
 #else
 const int kMaxUIMessageDelayMs = 500;
 const int kMaxIOMessageDelayMs = 400;
 #endif
 
 // Maximum processing time (excluding queueing delay) for a message before
 // considering it delayed.
 const int kMaxMessageProcessingMs = 100;
 
-#if defined(OS_WIN)
 // TODO(brettw) Consider making this a pref.
 const bool kPlaySounds = false;
-#endif
 
 //------------------------------------------------------------------------------
 // Provide a special watchdog to make it easy to set the breakpoint on this
 // class only.
 class JankWatchdog : public base::Watchdog {
  public:
   JankWatchdog(const TimeDelta& duration,
                const std::string& thread_watched_name,
                bool enabled)
       : Watchdog(duration, thread_watched_name, enabled),
@@ skipping 92 matching lines @@
 void JankObserverHelper::StartProcessingTimers(const TimeDelta& queueing_time) {
   DCHECK(measure_current_message_);
   begin_process_message_ = TimeTicks::Now();
   queueing_time_ = queueing_time;
 
   // Simulate arming when the message entered the queue.
   total_time_watchdog_.ArmSomeTimeDeltaAgo(queueing_time_);
   if (queueing_time_ > max_message_delay_) {
     // Message is too delayed.
     queueing_delay_counter_.Increment();
-#if defined(OS_WIN)
     if (kPlaySounds)
       MessageBeep(MB_ICONASTERISK);
-#endif
   }
 }
 
 // Called when a message has just finished processing, finalizes
 // per-message variables and timers.
 void JankObserverHelper::EndProcessingTimers() {
   if (!measure_current_message_)
     return;
   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
   }
 
   // Reset message specific times.
   begin_process_message_ = base::TimeTicks();
   queueing_time_ = base::TimeDelta();
 }
 
 bool JankObserverHelper::MessageWillBeMeasured() {
   measure_current_message_ = events_till_measurement_ <= 0;
   if (!measure_current_message_)
@@ skipping 93 matching lines @@
       return;
     base::TimeTicks now = base::TimeTicks::Now();
     const base::TimeDelta queueing_time = now - pending_task.time_posted;
     helper_.StartProcessingTimers(queueing_time);
   }
 
   virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
     helper_.EndProcessingTimers();
   }
 
-#if defined(OS_WIN)
   virtual base::EventStatus WillProcessEvent(
       const base::NativeEvent& event) OVERRIDE {
     if (!helper_.MessageWillBeMeasured())
       return base::EVENT_CONTINUE;
     // 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>(event.time);
     DWORD cur_time = GetTickCount();
     base::TimeDelta queueing_time =
         base::TimeDelta::FromMilliseconds(cur_time - cur_message_issue_time);
 
     helper_.StartProcessingTimers(queueing_time);
     return base::EVENT_CONTINUE;
   }
 
   virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE {
     helper_.EndProcessingTimers();
   }
-#elif defined(USE_AURA)
-  virtual base::EventStatus WillProcessEvent(
-      const base::NativeEvent& event) OVERRIDE {
-    return base::EVENT_CONTINUE;
-  }
-
-  virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE {
-  }
-#elif defined(TOOLKIT_GTK)
-  virtual void WillProcessEvent(GdkEvent* event) OVERRIDE {
-    if (!helper_.MessageWillBeMeasured())
-      return;
-    // TODO(evanm): we want to set queueing_time_ using
-    // gdk_event_get_time, but how do you convert that info
-    // into a delta?
-    // guint event_time = gdk_event_get_time(event);
-    base::TimeDelta queueing_time = base::TimeDelta::FromMilliseconds(0);
-    helper_.StartProcessingTimers(queueing_time);
-  }
-
-  virtual void DidProcessEvent(GdkEvent* event) OVERRIDE {
-    helper_.EndProcessingTimers();
-  }
-#endif
 
  private:
   friend class base::RefCountedThreadSafe<UIJankObserver>;
 
   virtual ~UIJankObserver() {}
 
   JankObserverHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(UIJankObserver);
 };
@@ skipping 51 matching lines @@
     delete ui_observer;
     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()));
     delete io_observer;
     io_observer = NULL;
   }
 }