Add Keyboard Latency UMA Metrics.

content/browser/renderer_host/render_widget_host_view_mac.mm

 // 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 "content/browser/renderer_host/render_widget_host_view_mac.h"
 
 #import <Carbon/Carbon.h>
 #import <objc/runtime.h>
 #include <OpenGL/gl.h>
 #include <QuartzCore/QuartzCore.h>
@@ skipping 2092 matching lines @@
       return;
   }
 
   // Don't cancel child popups; the key events are probably what's triggering
   // the popup in the first place.
 
   RenderWidgetHostImpl* widgetHost = renderWidgetHostView_->render_widget_host_;
   DCHECK(widgetHost);
 
   NativeWebKeyboardEvent event(theEvent);
+  ui::LatencyInfo latency_info;
+  if (event.GetType() == blink::WebInputEvent::kRawKeyDown ||
+      event.GetType() == blink::WebInputEvent::kChar) {
+    latency_info.set_source_event_type(ui::SourceEventType::KEY_PRESS);
+  }
+
+  latency_info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 
   // Force fullscreen windows to close on Escape so they won't keep the keyboard
   // grabbed or be stuck onscreen if the renderer is hanging.
   if (event.GetType() == NativeWebKeyboardEvent::kRawKeyDown &&
       event.windows_key_code == ui::VKEY_ESCAPE &&
       renderWidgetHostView_->pepper_fullscreen_window()) {
     RenderWidgetHostViewMac* parent =
         renderWidgetHostView_->fullscreen_parent_host_view();
     if (parent)
       parent->cocoa_view()->suppressNextEscapeKeyUp_ = YES;
@@ skipping 19 matching lines @@
   // otherwise we might get an event from releasing the return key in the
   // omnibox (http://crbug.com/338736).
   if ([theEvent type] == NSKeyUp) {
     auto numErased = keyDownCodes_.erase([theEvent keyCode]);
     if (numErased < 1)
       return;
   }
 
   // We only handle key down events and just simply forward other events.
   if ([theEvent type] != NSKeyDown) {
-    widgetHost->ForwardKeyboardEvent(event);
+    widgetHost->ForwardKeyboardEventWithLatencyInfo(event, latency_info);
 
     // Possibly autohide the cursor.
     if ([self shouldAutohideCursorForEvent:theEvent])
       [NSCursor setHiddenUntilMouseMoves:YES];
 
     return;
   }
 
   keyDownCodes_.insert([theEvent keyCode]);
 
@@ skipping 34 matching lines @@
   // To emulate Windows, over-write |event.windowsKeyCode| to VK_PROCESSKEY
   // while an input method is composing or inserting a text.
   // Gmail checks this code in its onkeydown handler to stop auto-completing
   // e-mail addresses while composing a CJK text.
   // If the text to be inserted has only one character, then we don't need this
   // trick, because we'll send the text as a key press event instead.
   if (hasMarkedText_ || oldHasMarkedText || textToBeInserted_.length() > 1) {
     NativeWebKeyboardEvent fakeEvent = event;
     fakeEvent.windows_key_code = 0xE5;  // VKEY_PROCESSKEY
     fakeEvent.skip_in_browser = true;
-    widgetHost->ForwardKeyboardEvent(fakeEvent);
+    widgetHost->ForwardKeyboardEventWithLatencyInfo(fakeEvent, latency_info);
     // If this key event was handled by the input method, but
     // -doCommandBySelector: (invoked by the call to -interpretKeyEvents: above)
     // enqueued edit commands, then in order to let webkit handle them
     // correctly, we need to send the real key event and corresponding edit
     // commands after processing the input method result.
     // We shouldn't do this if a new marked text was set by the input method,
     // otherwise the new marked text might be cancelled by webkit.
     if (hasEditCommands_ && !hasMarkedText_)
       delayEventUntilAfterImeCompostion = YES;
   } else {
-    widgetHost->ForwardKeyboardEventWithCommands(event, &editCommands_);
+    widgetHost->ForwardKeyboardEventWithCommands(event, latency_info,
+                                                 &editCommands_);
   }
 
-  // Calling ForwardKeyboardEvent() could have destroyed the widget. When the
-  // widget was destroyed, |renderWidgetHostView_->render_widget_host_| will
-  // be set to NULL. So we check it here and return immediately if it's NULL.
+  // Calling ForwardKeyboardEventWithCommands() could have destroyed the
+  // widget. When the widget was destroyed,
+  // |renderWidgetHostView_->render_widget_host_| will be set to NULL. So we
+  // check it here and return immediately if it's NULL.
   if (!renderWidgetHostView_->render_widget_host_)
     return;
 
   // Then send keypress and/or composition related events.
   // If there was a marked text or the text to be inserted is longer than 1
   // character, then we send the text by calling FinishComposingText().
   // Otherwise, if the text to be inserted only contains 1 character, then we
   // can just send a keypress event which is fabricated by changing the type of
   // the keydown event, so that we can retain all necessary informations, such
   // as unmodifiedText, etc. And we need to set event.skip_in_browser to true to
@@ skipping 38 matching lines @@
   // finish current composition session but still wants the application to
   // handle the key event. See http://crbug.com/48161 for reference.
   if (delayEventUntilAfterImeCompostion) {
     // If |delayEventUntilAfterImeCompostion| is YES, then a fake key down event
     // with windowsKeyCode == 0xE5 has already been sent to webkit.
     // So before sending the real key down event, we need to send a fake key up
     // event to balance it.
     NativeWebKeyboardEvent fakeEvent = event;
     fakeEvent.SetType(blink::WebInputEvent::kKeyUp);
     fakeEvent.skip_in_browser = true;
-    widgetHost->ForwardKeyboardEvent(fakeEvent);
+    widgetHost->ForwardKeyboardEventWithLatencyInfo(fakeEvent, latency_info);
     // Not checking |renderWidgetHostView_->render_widget_host_| here because
     // a key event with |skip_in_browser| == true won't be handled by browser,
     // thus it won't destroy the widget.
 
-    widgetHost->ForwardKeyboardEventWithCommands(event, &editCommands_);
+    widgetHost->ForwardKeyboardEventWithCommands(event, latency_info,
+                                                 &editCommands_);
 
-    // Calling ForwardKeyboardEvent() could have destroyed the widget. When the
-    // widget was destroyed, |renderWidgetHostView_->render_widget_host_| will
-    // be set to NULL. So we check it here and return immediately if it's NULL.
+    // Calling ForwardKeyboardEventWithCommands() could have destroyed the
+    // widget. When the widget was destroyed,
+    // |renderWidgetHostView_->render_widget_host_| will be set to NULL. So we
+    // check it here and return immediately if it's NULL.
     if (!renderWidgetHostView_->render_widget_host_)
       return;
   }
 
   const NSUInteger kCtrlCmdKeyMask = NSControlKeyMask | NSCommandKeyMask;
   // Only send a corresponding key press event if there is no marked text.
   if (!hasMarkedText_) {
     if (!textInserted && textToBeInserted_.length() == 1) {
       // If a single character was inserted, then we just send it as a keypress
       // event.
       event.SetType(blink::WebInputEvent::kChar);
       event.text[0] = textToBeInserted_[0];
       event.text[1] = 0;
       event.skip_in_browser = true;
-      widgetHost->ForwardKeyboardEvent(event);
+      widgetHost->ForwardKeyboardEventWithLatencyInfo(event, latency_info);
     } else if ((!textInserted || delayEventUntilAfterImeCompostion) &&
                event.text[0] != '\0' &&
                (([theEvent modifierFlags] & kCtrlCmdKeyMask) ||
                 (hasEditCommands_ && editCommands_.empty()))) {
       // We don't get insertText: calls if ctrl or cmd is down, or the key event
       // generates an insert command. So synthesize a keypress event for these
       // cases, unless the key event generated any other command.
       event.SetType(blink::WebInputEvent::kChar);
       event.skip_in_browser = true;
-      widgetHost->ForwardKeyboardEvent(event);
+      widgetHost->ForwardKeyboardEventWithLatencyInfo(event, latency_info);
     }
   }
 
   // Possibly autohide the cursor.
   if ([self shouldAutohideCursorForEvent:theEvent])
     [NSCursor setHiddenUntilMouseMoves:YES];
 }
 
 - (void)forceTouchEvent:(NSEvent*)theEvent {
   if (ui::ForceClickInvokesQuickLook())
@@ skipping 1179 matching lines @@
 
 // "-webkit-app-region: drag | no-drag" is implemented on Mac by excluding
 // regions that are not draggable. (See ControlRegionView in
 // native_app_window_cocoa.mm). This requires the render host view to be
 // draggable by default.
 - (BOOL)mouseDownCanMoveWindow {
   return YES;
 }
 
 @end