Removes mouse listeners from UserInputMonitor.

media/base/keyboard_event_counter.cc

 // Copyright 2013 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 "media/base/keyboard_event_counter.h"
 
 #include "base/atomicops.h"
 #include "base/logging.h"
 
 namespace media {
 
 KeyboardEventCounter::KeyboardEventCounter() : total_key_presses_(0) {}
 
 KeyboardEventCounter::~KeyboardEventCounter() {}
 
 void KeyboardEventCounter::Reset() {
   pressed_keys_.clear();
   base::subtle::NoBarrier_Store(
       reinterpret_cast<base::subtle::AtomicWord*>(&total_key_presses_), 0);
 }
 
-void KeyboardEventCounter::OnKeyboardEvent(ui::EventType event,
+void KeyboardEventCounter::OnKeyboardEvent(bool down,

[xhwang, 2017/01/10 20:13:15]

personally I found an explicit enum is more readable than a boolean, especially
at the caller site, e.g. people won't understand what this means without looking
at the declaration of the function:

OnKeyboardEvent(true, ...);

If you still prefer this, the function probably should be named
OnKeyPressedOrRelased(bool pressed).

[Wez, 2017/01/10 23:19:24]

Yes, strictly it's preferable to keep this as an enum; the down-side of using
ui::EventType is that it includes a load of type values that are never valid.
:-/

So OK, yes, sorry, let's revert to using ui::EventType, but let's try to keep
that code trivial, e.g:

key_is_down ? KeyDown : KeyUp

to generate the OnKeyboardEvent() parameter.

[CJ, 2017/01/11 21:40:27]

Confused as how the key_is_down ? KeyDown : KeyUp expression is involved. 

Do we want this function to take in a ui::EventType or a bool? 

[Wez, 2017/01/11 21:54:22]

I just meant that instead of restoring this:
     ui::EventType type;	
 288     if (event->u.u.type == KeyPress) {	
 289       type = ui::ET_KEY_PRESSED;	
 290     } else if (event->u.u.type == KeyRelease) {	
 291       type = ui::ET_KEY_RELEASED;	
 292     } else {	
 293       NOTREACHED();	
 294       return;	
 295     }

let's reduce it to:

ui::EventType type = (event->u.u.type == KeyPress) ? ui::EventType::KeyDown :
ui::EventType::KeyUp;

[CJ, 2017/01/11 23:08:09]

Done.

                                            ui::KeyboardCode key_code) {
   // Updates the pressed keys and the total count of key presses.
-  if (event == ui::ET_KEY_PRESSED) {
+  if (down) {
     if (pressed_keys_.find(key_code) != pressed_keys_.end())
       return;
     pressed_keys_.insert(key_code);
     base::subtle::NoBarrier_AtomicIncrement(
         reinterpret_cast<base::subtle::AtomicWord*>(&total_key_presses_), 1);
   } else {
-    DCHECK_EQ(ui::ET_KEY_RELEASED, event);
     pressed_keys_.erase(key_code);
   }
 }
 
 size_t KeyboardEventCounter::GetKeyPressCount() const {
   return base::subtle::NoBarrier_Load(
       reinterpret_cast<const base::subtle::AtomicWord*>(&total_key_presses_));
 }
 
 }  // namespace media