UMA metrics for counting different ways of scrolling by keyboard.

third_party/WebKit/Source/core/input/KeyboardEventManager.cpp

 // 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 "KeyboardEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/Element.h"
 #include "core/editing/Editor.h"
 #include "core/events/KeyboardEvent.h"
@@ skipping 42 matching lines @@
   else if (event->key() == "ArrowLeft")
     retVal = WebFocusTypeLeft;
   else if (event->key() == "ArrowRight")
     retVal = WebFocusTypeRight;
   return retVal;
 }
 
 bool mapKeyCodeForScroll(int keyCode,
                          WebInputEvent::Modifiers modifiers,
                          ScrollDirection* scrollDirection,
-                         ScrollGranularity* scrollGranularity) {
+                         ScrollGranularity* scrollGranularity,
+                         UseCounter::Feature* scrollUseUMA) {
   if (modifiers & WebInputEvent::ShiftKey || modifiers & WebInputEvent::MetaKey)
     return false;
 
   if (modifiers & WebInputEvent::AltKey) {
     // Alt-Up/Down should behave like PageUp/Down on Mac.  (Note that Alt-keys
     // on other platforms are suppressed due to isSystemKey being set.)
     if (keyCode == VKEY_UP)
       keyCode = VKEY_PRIOR;
     else if (keyCode == VKEY_DOWN)
       keyCode = VKEY_NEXT;
     else
       return false;
   }
 
   if (modifiers & WebInputEvent::ControlKey) {
     // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl
     // key combinations which affect scrolling.
     if (keyCode != VKEY_HOME && keyCode != VKEY_END)
       return false;
   }
 
   switch (keyCode) {
     case VKEY_LEFT:
       *scrollDirection = ScrollLeftIgnoringWritingMode;
       *scrollGranularity = ScrollByLine;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardArrowKeys;
       break;
     case VKEY_RIGHT:
       *scrollDirection = ScrollRightIgnoringWritingMode;
       *scrollGranularity = ScrollByLine;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardArrowKeys;
       break;
     case VKEY_UP:
       *scrollDirection = ScrollUpIgnoringWritingMode;
       *scrollGranularity = ScrollByLine;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardArrowKeys;
       break;
     case VKEY_DOWN:
       *scrollDirection = ScrollDownIgnoringWritingMode;
       *scrollGranularity = ScrollByLine;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardArrowKeys;
       break;
     case VKEY_HOME:
       *scrollDirection = ScrollUpIgnoringWritingMode;
       *scrollGranularity = ScrollByDocument;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardHomeEndKeys;
       break;
     case VKEY_END:
       *scrollDirection = ScrollDownIgnoringWritingMode;
       *scrollGranularity = ScrollByDocument;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardHomeEndKeys;
       break;
     case VKEY_PRIOR:  // page up
       *scrollDirection = ScrollUpIgnoringWritingMode;
       *scrollGranularity = ScrollByPage;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardPageUpDownKeys;
       break;
     case VKEY_NEXT:  // page down
       *scrollDirection = ScrollDownIgnoringWritingMode;
       *scrollGranularity = ScrollByPage;
+      *scrollUseUMA = UseCounter::ScrollByKeyboardPageUpDownKeys;
       break;
     default:
       return false;
   }
 
   return true;
 }
 
 }  // namespace
 
@@ skipping 174 matching lines @@
 
   if (event->ctrlKey() || event->metaKey() || event->altKey())
     return;
 
   ScrollDirection direction = event->shiftKey() ? ScrollBlockDirectionBackward
                                                 : ScrollBlockDirectionForward;
 
   // FIXME: enable scroll customization in this case. See crbug.com/410974.
   if (m_scrollManager->logicalScroll(direction, ScrollByPage, nullptr,
                                      possibleFocusedNode)) {
+    UseCounter::count(m_frame->document(),
+                      UseCounter::ScrollByKeyboardSpacebarKey);
     event->setDefaultHandled();
     return;
   }
 }
 
 void KeyboardEventManager::defaultBackspaceEventHandler(KeyboardEvent* event) {
   DCHECK_EQ(event->type(), EventTypeNames::keydown);
 
   if (!RuntimeEnabledFeatures::backspaceDefaultHandlerEnabled())
     return;
@@ skipping 28 matching lines @@
       event->setDefaultHandled();
       return;
     }
   }
 
   if (event->keyEvent() && event->keyEvent()->isSystemKey)
     return;
 
   ScrollDirection scrollDirection;
   ScrollGranularity scrollGranularity;
+  UseCounter::Feature scrollUseUMA;
   if (!mapKeyCodeForScroll(event->keyCode(), event->modifiers(),
-                           &scrollDirection, &scrollGranularity))
+                           &scrollDirection, &scrollGranularity, &scrollUseUMA))
     return;
 
   if (m_scrollManager->bubblingScroll(scrollDirection, scrollGranularity,
                                       nullptr, possibleFocusedNode)) {
+    UseCounter::count(m_frame->document(), scrollUseUMA);
     event->setDefaultHandled();
     return;
   }
 }
 
 void KeyboardEventManager::defaultTabEventHandler(KeyboardEvent* event) {
   DCHECK_EQ(event->type(), EventTypeNames::keydown);
 
   // We should only advance focus on tabs if no special modifier keys are held
   // down.
@@ skipping 80 matching lines @@
   if (currentModifiers & ::cmdKey)
     modifiers |= WebInputEvent::MetaKey;
 #else
   // TODO(crbug.com/538289): Implement on other platforms.
   return static_cast<WebInputEvent::Modifiers>(0);
 #endif
   return static_cast<WebInputEvent::Modifiers>(modifiers);
 }
 
 }  // namespace blink