content/app_shim_remote_cocoa/render_widget_host_view_cocoa.mm - chromium/src - Git at Google

 // Copyright 2018 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #import "content/app_shim_remote_cocoa/render_widget_host_view_cocoa.h"

 #include <AppKit/AppKit.h>
 #include <Carbon/Carbon.h>  // for <HIToolbox/Events.h>

 #include <algorithm>
 #include <limits>
 #include <tuple>
 #include <utility>

 #import "base/apple/foundation_util.h"
 #include "base/apple/owned_objc.h"
 #include "base/containers/contains.h"
 #include "base/debug/crash_logging.h"
 #import "base/mac/mac_util.h"
 #include "base/memory/raw_ptr.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/remote_cocoa/app_shim/ns_view_ids.h"
 #import "content/browser/accessibility/browser_accessibility_cocoa.h"
 #import "content/browser/accessibility/browser_accessibility_mac.h"
 #include "content/browser/accessibility/browser_accessibility_manager_mac.h"
 #import "content/browser/cocoa/system_hotkey_helper_mac.h"
 #import "content/browser/cocoa/system_hotkey_map.h"
 #include "content/browser/renderer_host/render_widget_host_view_mac.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.h"
 #include "content/common/features.h"
 #include "content/common/input/web_input_event_builders_mac.h"
 #import "content/public/browser/render_widget_host_view_mac_delegate.h"
 #include "content/public/common/content_features.h"
 #include "skia/ext/skia_utils_mac.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/mojom/input/input_handler.mojom.h"
 #include "third_party/blink/public/platform/web_text_input_type.h"
 #import "ui/base/clipboard/clipboard_util_mac.h"
 #import "ui/base/cocoa/appkit_utils.h"
 #import "ui/base/cocoa/nsmenu_additions.h"
 #import "ui/base/cocoa/nsmenuitem_additions.h"
 #include "ui/base/cocoa/remote_accessibility_api.h"
 #import "ui/base/cocoa/touch_bar_util.h"
 #include "ui/base/ui_base_features.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/mac/coordinate_conversion.h"

 using content::NativeWebKeyboardEvent;
 using content::RenderWidgetHostViewMacEditCommandHelper;
 using content::WebGestureEventBuilder;
 using content::WebMouseEventBuilder;
 using content::WebMouseWheelEventBuilder;
 using content::WebTouchEventBuilder;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebGestureEvent;
 using blink::WebTouchEvent;
 using remote_cocoa::mojom::RenderWidgetHostNSViewHost;
 using remote_cocoa::RenderWidgetHostNSViewHostHelper;

 namespace {

 constexpr NSString* WebAutomaticQuoteSubstitutionEnabled =
     @"WebAutomaticQuoteSubstitutionEnabled";
 constexpr NSString* const WebAutomaticDashSubstitutionEnabled =
     @"WebAutomaticDashSubstitutionEnabled";
 constexpr NSString* const WebAutomaticTextReplacementEnabled =
     @"WebAutomaticTextReplacementEnabled";

 constexpr NSString* const kGoogleJapaneseInputPrefix =
     @"com.google.inputmethod.Japanese.";

 // A dummy RenderWidgetHostNSViewHostHelper implementation which no-ops all
 // functions.
 class DummyHostHelper : public RenderWidgetHostNSViewHostHelper {
  public:
   explicit DummyHostHelper() = default;

   DummyHostHelper(const DummyHostHelper&) = delete;
   DummyHostHelper& operator=(const DummyHostHelper&) = delete;

  private:
   // RenderWidgetHostNSViewHostHelper implementation.
   id GetRootBrowserAccessibilityElement() override { return nil; }
   id GetFocusedBrowserAccessibilityElement() override { return nil; }
   void SetAccessibilityWindow(NSWindow* window) override {}
   void ForwardKeyboardEvent(const NativeWebKeyboardEvent& key_event,
                             const ui::LatencyInfo& latency_info) override {}
   void ForwardKeyboardEventWithCommands(
       const NativeWebKeyboardEvent& key_event,
       const ui::LatencyInfo& latency_info,
       const std::vector<blink::mojom::EditCommandPtr> commands) override {}
   void RouteOrProcessMouseEvent(
       const blink::WebMouseEvent& web_event) override {}
   void RouteOrProcessTouchEvent(
       const blink::WebTouchEvent& web_event) override {}
   void RouteOrProcessWheelEvent(
       const blink::WebMouseWheelEvent& web_event) override {}
   void ForwardMouseEvent(const blink::WebMouseEvent& web_event) override {}
   void ForwardWheelEvent(const blink::WebMouseWheelEvent& web_event) override {}
   void GestureBegin(blink::WebGestureEvent begin_event,
                     bool is_synthetically_injected) override {}
   void GestureUpdate(blink::WebGestureEvent update_event) override {}
   void GestureEnd(blink::WebGestureEvent end_event) override {}
   void SmartMagnify(const blink::WebGestureEvent& web_event) override {}
 };

 // Touch bar identifier.
 NSString* const kWebContentTouchBarId = @"web-content";

 constexpr int kWrapAroundDistance = 10000;

 // Whether a keyboard event has been reserved by macOS.
 BOOL EventIsReservedBySystem(NSEvent* event) {
   return content::GetSystemHotkeyMap()->IsEventReserved(event);
 }

 // Extract underline information from an attributed string. Inspired by
 // `extractUnderlines` in
 // https://github.com/WebKit/WebKit/blob/main/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
 void ExtractUnderlines(NSAttributedString* string,
                        std::vector<ui::ImeTextSpan>* ime_text_spans) {
   NSUInteger length = string.length;
   NSUInteger i = 0;
   while (i < length) {
     NSRange range;
     NSDictionary* attrs = [string attributesAtIndex:i
                               longestEffectiveRange:&range
                                             inRange:NSMakeRange(i, length - i)];
     if (NSNumber* style_attr = attrs[NSUnderlineStyleAttributeName]) {
       SkColor color = SK_ColorBLACK;
       if (NSColor* color_attr = attrs[NSUnderlineColorAttributeName]) {
         color = skia::NSDeviceColorToSkColor(
             [color_attr colorUsingColorSpace:NSColorSpace.deviceRGBColorSpace]);
       }

       // `NSUnderlineStyle` is the combination of a type enum with a pattern
       // style in the higher bits. Fold anything more complicated than a single
       // unstyled underline down to "thick" rather than "thin".
       ui::ImeTextSpan::Thickness thickness =
           style_attr.intValue > NSUnderlineStyleSingle
               ? ui::ImeTextSpan::Thickness::kThick
               : ui::ImeTextSpan::Thickness::kThin;
       ui::ImeTextSpan ui_ime_text_span = ui::ImeTextSpan(
           ui::ImeTextSpan::Type::kComposition, range.location,
           NSMaxRange(range), thickness, ui::ImeTextSpan::UnderlineStyle::kSolid,
           SK_ColorTRANSPARENT);
       ui_ime_text_span.underline_color = color;
       ime_text_spans->push_back(ui_ime_text_span);
     }
     i = NSMaxRange(range);
   }
 }

 }  // namespace

 // RenderWidgetHostViewCocoa ---------------------------------------------------

 // Private methods:
 @interface RenderWidgetHostViewCocoa ()

 @property(readonly) NSSpellChecker* spellChecker;

 @property(getter=isAutomaticTextReplacementEnabled)
     BOOL automaticTextReplacementEnabled;
 @property(getter=isAutomaticQuoteSubstitutionEnabled)
     BOOL automaticQuoteSubstitutionEnabled;
 @property(getter=isAutomaticDashSubstitutionEnabled)
     BOOL automaticDashSubstitutionEnabled;

 - (void)processedWheelEvent:(const blink::WebMouseWheelEvent&)event
                    consumed:(BOOL)consumed;
 - (void)keyEvent:(NSEvent*)theEvent wasKeyEquivalent:(BOOL)equiv;
 - (void)windowDidChangeScreenOrBackingProperties:(NSNotification*)notification;
 - (void)windowChangedGlobalFrame:(NSNotification*)notification;
 - (void)windowDidBecomeKey:(NSNotification*)notification;
 - (void)windowDidResignKey:(NSNotification*)notification;
 - (void)sendViewBoundsInWindowToHost;
 - (void)requestTextSubstitutions;
 - (void)requestTextSuggestions;
 - (void)sendWindowFrameInScreenToHost;
 - (bool)hostIsDisconnected;
 - (void)invalidateTouchBar;

 // NSCandidateListTouchBarItemDelegate implementation
 - (void)candidateListTouchBarItem:(NSCandidateListTouchBarItem*)anItem
      endSelectingCandidateAtIndex:(NSInteger)index;
 - (void)candidateListTouchBarItem:(NSCandidateListTouchBarItem*)anItem
     changedCandidateListVisibility:(BOOL)isVisible;
 @end

 @implementation RenderWidgetHostViewCocoa {
   // Dummy host and host helper that are always valid (see comments below about
   // _host).
   // These need to be declared before |_host| and |_hostHelper| so that it
   // gets destroyed last.
   mojo::Remote<remote_cocoa::mojom::RenderWidgetHostNSViewHost> _dummyHost;
   std::unique_ptr<remote_cocoa::RenderWidgetHostNSViewHostHelper>
       _dummyHostHelper;

   // The communications channel to the RenderWidgetHostViewMac. This pointer is
   // always valid. When the original host disconnects, |_host| is changed to
   // point to |_dummyHost|, to avoid having to preface every dereference with
   // a nullptr check.
   raw_ptr<remote_cocoa::mojom::RenderWidgetHostNSViewHost> _host;

   // A separate host interface for the parts of the interface to
   // RenderWidgetHostViewMac that cannot or should not be forwarded over mojo.
   // This includes events (where the extra translation is unnecessary or loses
   // information) and access to accessibility structures (only present in the
   // browser process).
   raw_ptr<remote_cocoa::RenderWidgetHostNSViewHostHelper> _hostHelper;

   // This ivar is the cocoa delegate of the NSResponder.
   NSObject<RenderWidgetHostViewMacDelegate>* __strong _responderDelegate;
   BOOL _canBeKeyView;
   BOOL _closeOnDeactivate;
   std::unique_ptr<content::RenderWidgetHostViewMacEditCommandHelper>
       _editCommandHelper;

   // Is YES if there was a mouse-down as yet unbalanced with a mouse-up.
   BOOL _hasOpenMouseDown;

   // The cursor for the page. This is passed up from the renderer.
   NSCursor* __strong _currentCursor;

   // Is YES if the cursor is hidden by key events.
   BOOL _cursorHidden;

   // Controlled by setShowingContextMenu.
   BOOL _showingContextMenu;

   // Set during -setFrame to avoid spamming host_ with origin and size
   // changes.
   BOOL _inSetFrame;

   // Variables used by our implementation of the NSTextInput protocol.
   // An input method of Mac calls the methods of this protocol not only to
   // notify an application of its status, but also to retrieve the status of
   // the application. That is, an application cannot control an input method
   // directly.
   // This object keeps the status of a composition of the renderer and returns
   // it when an input method asks for it.
   // We need to implement Objective-C methods for the NSTextInput protocol. On
   // the other hand, we need to implement a C++ method for an IPC-message
   // handler which receives input-method events from the renderer.

   // keyCode value of an NSEvent. This field has a value while we're handling
   // a key down event.
   std::optional<unsigned short> _currentKeyDownCode;

   // Indicates if a reconversion (which means a piece of committed text becomes
   // part of the composition again) is triggered in Japanese IME when Live
   // Conversion is on.
   BOOL _isReconversionTriggered;

   // Indicates if there is any marked text.
   BOOL _hasMarkedText;

   // Indicates if unmarkText is called or not when handling a keyboard
   // event.
   BOOL _unmarkTextCalled;

   // The range of current marked text inside the whole content of the DOM node
   // being edited.
   // TODO(suzhe): This is currently a fake value, as we do not support accessing
   // the whole content yet.
   NSRange _markedRange;

   // The text selection, cached from the RenderWidgetHostView.
   // |_availableText| contains the selected text and is a substring of the
   // full string in the renderer.
   std::u16string _availableText;
   size_t _availableTextOffset;
   gfx::Range _textSelectionRange;

   // The composition range, cached from the RenderWidgetHostView. This is only
   // ever updated from the renderer (unlike |_markedRange|, which sometimes but
   // not always coincides with |_compositionRange|).
   gfx::Range _compositionRange;

   // Text to be inserted which was generated by handling a key down event.
   std::u16string _textToBeInserted;

   // Marked text which was generated by handling a key down event.
   std::u16string _markedText;

   // Selected range of |markedText_|.
   NSRange _markedTextSelectedRange;

   // Underline information of the |markedText_|.
   std::vector<ui::ImeTextSpan> _imeTextSpans;

   // Replacement range information received from |setMarkedText:|.
   gfx::Range _setMarkedTextReplacementRange;

   // Indicates if doCommandBySelector method receives any edit command when
   // handling a key down event.
   BOOL _hasEditCommands;

   // Contains edit commands received by the -doCommandBySelector: method when
   // handling a key down event, not including inserting commands, eg. insertTab,
   // etc.
   std::vector<blink::mojom::EditCommandPtr> _editCommands;

   // Whether the previous mouse event was ignored due to hitTest check.
   BOOL _mouseEventWasIgnored;

   // Event monitor for scroll wheel end event.
   id __strong _endWheelMonitor;

   // This is used to indicate if a stylus is currently in the proximity of the
   // tablet.
   bool _isStylusEnteringProximity;
   blink::WebPointerProperties::PointerType _pointerType;

   // The set of key codes from key down events that we haven't seen the matching
   // key up events yet.
   // Used for filtering out non-matching NSEventTypeKeyUp events.
   std::set<unsigned short> _unmatchedKeyDownCodes;

   // The filter used to guide touch events towards a horizontal or vertical
   // orientation.
   content::MouseWheelRailsFilterMac _mouseWheelFilter;

   bool _mouseLocked;
   bool _mouseLockUnacceleratedMovement;
   gfx::PointF _lastMouseScreenPosition;

   // The parent accessibility element. This is set only in the browser process.
   id __strong _accessibilityParent;

   uint64_t _popupParentNSViewId;

   bool _keyboardLockActive;
   std::optional<base::flat_set<ui::DomCode>> _lockedKeys;

   NSCandidateListTouchBarItem* __strong _candidateListTouchBarItem;
   NSInteger _textSuggestionsSequenceNumber;
   BOOL _shouldRequestTextSubstitutions;
   BOOL _substitutionWasApplied;
 }

 @synthesize markedRange = _markedRange;
 @synthesize textInputType = _textInputType;
 @synthesize textInputFlags = _textInputFlags;
 @synthesize spellCheckerForTesting = _spellCheckerForTesting;

 + (void)initialize {
   RenderWidgetHostViewMacEditCommandHelper::AddEditingSelectorsToClass(self);
 }

 - (instancetype)initWithHost:(RenderWidgetHostNSViewHost*)host
               withHostHelper:(RenderWidgetHostNSViewHostHelper*)hostHelper {
   self = [super initWithFrame:NSZeroRect tracking:YES];
   if (self) {
     // Enable trackpad touches ("direct" touches are touchbar touches).
     self.allowedTouchTypes |= NSTouchTypeMaskIndirect;
     _editCommandHelper =
         std::make_unique<RenderWidgetHostViewMacEditCommandHelper>();

     _host = host;
     _hostHelper = hostHelper;
     _canBeKeyView = YES;
     _isStylusEnteringProximity = false;
     _keyboardLockActive = false;
     _textInputType = ui::TEXT_INPUT_TYPE_NONE;
   }
   return self;
 }

 - (void)dealloc {
   DCHECK([self hostIsDisconnected]);
   [[NSNotificationCenter defaultCenter] removeObserver:self];

   // Update and cache the new input context. Otherwise,
   // [NSTextInputContext currentInputContext] might still hold on to this
   // view's NSTextInputContext even after it's deallocated.
   // See http://crbug.com/684388.
   [[self window] makeFirstResponder:nil];
   [NSApp updateWindows];
 }

 - (void)sendViewBoundsInWindowToHost {
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewCocoa::sendViewBoundsInWindowToHost");
   if (_inSetFrame)
     return;

   NSRect viewBoundsInView = [self bounds];
   NSWindow* enclosingWindow = [self window];
   if (!enclosingWindow) {
     _host->OnBoundsInWindowChanged(gfx::Rect(viewBoundsInView), false);
     return;
   }

   NSRect viewBoundsInWindow = [self convertRect:viewBoundsInView toView:nil];
   gfx::Rect gfxViewBoundsInWindow(viewBoundsInWindow);
   gfxViewBoundsInWindow.set_y(NSHeight([enclosingWindow frame]) -
                               NSMaxY(viewBoundsInWindow));
   _host->OnBoundsInWindowChanged(gfxViewBoundsInWindow, true);
 }

 - (NSSpellChecker*)spellChecker {
   if (_spellCheckerForTesting)
     return _spellCheckerForTesting;
   return NSSpellChecker.sharedSpellChecker;
 }

 - (void)requestTextSubstitutions {
   NSTextCheckingType textCheckingTypes =
       self.allowedTextCheckingTypes & self.enabledTextCheckingTypes;
   if (!textCheckingTypes)
     return;

   NSString* availableText = base::SysUTF16ToNSString(_availableText);

   if (!availableText)
     return;

   auto* textCheckingResults =
       [self.spellChecker checkString:availableText
                                range:NSMakeRange(0, availableText.length)
                                types:textCheckingTypes
                              options:nil
               inSpellDocumentWithTag:0
                          orthography:nullptr
                            wordCount:nullptr];

   NSUInteger cursorLocation = _textSelectionRange.start();
   NSTextCheckingResult* candidateResult;
   for (NSTextCheckingResult* result in textCheckingResults) {
     NSTextCheckingResult* adjustedResult =
         [result resultByAdjustingRangesWithOffset:_availableTextOffset];
     if (!NSLocationInRange(cursorLocation,
                            NSMakeRange(adjustedResult.range.location,
                                        adjustedResult.range.length + 1)))
       continue;
     constexpr NSTextCheckingType textCheckingTypesToReplaceImmediately =
         NSTextCheckingTypeQuote | NSTextCheckingTypeDash;
     if (adjustedResult.resultType & textCheckingTypesToReplaceImmediately) {
       [self insertText:adjustedResult.replacementString
           replacementRange:adjustedResult.range];
       continue;
     }
     candidateResult = adjustedResult;
   }
   if (!candidateResult)
     return;

   NSRect textRectInScreenCoordinates =
       [self firstRectForCharacterRange:candidateResult.range
                            actualRange:nullptr];
   NSRect textRectInWindowCoordinates =
       [self.window convertRectFromScreen:textRectInScreenCoordinates];
   NSRect textRectInViewCoordinates =
       [self convertRect:textRectInWindowCoordinates fromView:nil];

   [self.spellChecker
       showCorrectionIndicatorOfType:NSCorrectionIndicatorTypeDefault
                       primaryString:candidateResult.replacementString
                  alternativeStrings:candidateResult.alternativeStrings
                     forStringInRect:textRectInViewCoordinates
                                view:self
                   completionHandler:^(NSString* acceptedString) {
                     [self didAcceptReplacementString:acceptedString
                                forTextCheckingResult:candidateResult];
                   }];
 }

 - (void)didAcceptReplacementString:(NSString*)acceptedString
              forTextCheckingResult:(NSTextCheckingResult*)correction {
   // TODO: Keep NSSpellChecker up to date on the user's response via
   // -recordResponse:toCorrection:forWord:language:inSpellDocumentWithTag:.
   // Call it to report whether they initially accepted or rejected the
   // suggestion, but also if they edit, revert, etc. later.

   if (acceptedString == nil)
     return;

   NSRange availableTextRange =
       NSMakeRange(_availableTextOffset, _availableText.length());

   if (NSMaxRange(correction.range) > NSMaxRange(availableTextRange))
     return;

   NSAttributedString* attString = [[NSAttributedString alloc]
       initWithString:base::SysUTF16ToNSString(_availableText)];
   NSRange trailingRange = NSMakeRange(
       NSMaxRange(correction.range),
       NSMaxRange(availableTextRange) - NSMaxRange(correction.range));

   if (trailingRange.length > 0 &&
       trailingRange.location < NSMaxRange(availableTextRange)) {
     NSRange trailingRangeInAvailableText = NSMakeRange(
         trailingRange.location - _availableTextOffset, trailingRange.length);
     NSString* trailingString =
         [attString.string substringWithRange:trailingRangeInAvailableText];
     if ([self.spellChecker preventsAutocorrectionBeforeString:trailingString
                                                      language:nil])
       return;
     if ([attString doubleClickAtIndex:trailingRangeInAvailableText.location]
             .location < trailingRangeInAvailableText.location)
       return;
   }

   _substitutionWasApplied = YES;
   [self insertText:acceptedString replacementRange:correction.range];
 }

 - (void)requestTextSuggestions {
   auto* touchBarItem = _candidateListTouchBarItem;
   if (!touchBarItem)
     return;
   [touchBarItem
       updateWithInsertionPointVisibility:_textSelectionRange.is_empty()];
   if (_textInputType == ui::TEXT_INPUT_TYPE_PASSWORD)
     return;
   if (!touchBarItem.candidateListVisible)
     return;
   if (!_textSelectionRange.IsValid() ||
       _availableTextOffset > _textSelectionRange.GetMin())
     return;

   NSRange selectionRange = _textSelectionRange.ToNSRange();
   NSString* selectionText = base::SysUTF16ToNSString(_availableText);
   selectionRange.location -= _availableTextOffset;
   if (NSMaxRange(selectionRange) > selectionText.length)
     return;

   // TODO: Fetch the spell document tag from the renderer (or equivalent).
   _textSuggestionsSequenceNumber = [self.spellChecker
       requestCandidatesForSelectedRange:selectionRange
                                inString:selectionText
                                   types:NSTextCheckingAllSystemTypes
                                 options:nil
                  inSpellDocumentWithTag:0
                       completionHandler:^(
                           NSInteger sequenceNumber,
                           NSArray<NSTextCheckingResult*>* candidates) {
                         dispatch_async(dispatch_get_main_queue(), ^{
                           if (sequenceNumber !=
                               self->_textSuggestionsSequenceNumber) {
                             return;
                           }
                           [touchBarItem setCandidates:candidates
                                      forSelectedRange:selectionRange
                                              inString:selectionText];
                         });
                       }];
 }

 - (NSTextCheckingType)allowedTextCheckingTypes {
   if (_textInputType == ui::TEXT_INPUT_TYPE_NONE)
     return 0;
   if (_textInputType == ui::TEXT_INPUT_TYPE_PASSWORD)
     return 0;
   if (_textInputFlags & blink::kWebTextInputFlagAutocorrectOff)
     return 0;
   NSTextCheckingType checkingTypes = NSTextCheckingTypeReplacement;
   if (!(_textInputFlags & blink::kWebTextInputFlagSpellcheckOff))
     checkingTypes |= NSTextCheckingTypeQuote | NSTextCheckingTypeDash;
   return checkingTypes;
 }

 - (NSTextCheckingType)enabledTextCheckingTypes {
   NSTextCheckingType checkingTypes = 0;
   if (self.automaticQuoteSubstitutionEnabled)
     checkingTypes |= NSTextCheckingTypeQuote;
   if (self.automaticDashSubstitutionEnabled)
     checkingTypes |= NSTextCheckingTypeDash;
   if (self.automaticTextReplacementEnabled)
     checkingTypes |= NSTextCheckingTypeReplacement;
   return checkingTypes;
 }

 - (void)orderFrontSubstitutionsPanel:(id)sender {
   [NSSpellChecker.sharedSpellChecker.substitutionsPanel orderFront:sender];
 }

 - (bool)canTransformText {
   if (_textInputType == ui::TEXT_INPUT_TYPE_NONE)
     return NO;
   if (_textInputType == ui::TEXT_INPUT_TYPE_PASSWORD)
     return NO;

   return YES;
 }

 - (void)uppercaseWord:(id)sender {
   NSString *text = base::SysUTF16ToNSString([self selectedText]);
   if (!text)
     return;

   [self insertText:text.localizedUppercaseString
       replacementRange:_textSelectionRange.ToNSRange()];
 }

 - (void)lowercaseWord:(id)sender {
   NSString *text = base::SysUTF16ToNSString([self selectedText]);
   if (!text)
     return;

   [self insertText:text.localizedLowercaseString
       replacementRange:_textSelectionRange.ToNSRange()];
 }

 - (void)capitalizeWord:(id)sender {
   NSString *text = base::SysUTF16ToNSString([self selectedText]);
   if (!text)
     return;

   [self insertText:text.localizedCapitalizedString
       replacementRange:_textSelectionRange.ToNSRange()];
 }

 - (void)setTextSelectionText:(std::u16string)text
                       offset:(size_t)offset
                        range:(gfx::Range)range {
   _availableText = text;
   _availableTextOffset = offset;
   _textSelectionRange = range;
   _substitutionWasApplied = NO;
   [NSSpellChecker.sharedSpellChecker dismissCorrectionIndicatorForView:self];
   if (_shouldRequestTextSubstitutions && !_substitutionWasApplied &&
       _textSelectionRange.is_empty()) {
     _shouldRequestTextSubstitutions = NO;
     [self requestTextSubstitutions];
   }
   [self requestTextSuggestions];
 }

 - (void)candidateListTouchBarItem:(NSCandidateListTouchBarItem*)anItem
      endSelectingCandidateAtIndex:(NSInteger)index {
   if (index == NSNotFound)
     return;
   NSTextCheckingResult* selectedResult = anItem.candidates[index];
   NSRange replacementRange = selectedResult.range;
   replacementRange.location += _availableTextOffset;
   [self insertText:selectedResult.replacementString
       replacementRange:replacementRange];
 }

 - (void)candidateListTouchBarItem:(NSCandidateListTouchBarItem*)anItem
     changedCandidateListVisibility:(BOOL)isVisible {
   [self requestTextSuggestions];
 }

 - (void)setTextInputType:(ui::TextInputType)textInputType {
   if (_textInputType == textInputType)
     return;
   _textInputType = textInputType;

   [self invalidateTouchBar];
 }

 - (std::u16string)selectedText {
   gfx::Range textRange(_availableTextOffset,
                        _availableTextOffset + _availableText.size());
   gfx::Range intersectionRange = textRange.Intersect(_textSelectionRange);
   if (intersectionRange.is_empty())
     return std::u16string();
   return _availableText.substr(intersectionRange.start() - _availableTextOffset,
                                intersectionRange.length());
 }

 - (void)setCompositionRange:(gfx::Range)range {
   _compositionRange = range;
 }

 - (void)sendWindowFrameInScreenToHost {
   TRACE_EVENT0("browser",
                "RenderWidgetHostViewCocoa::sendWindowFrameInScreenToHost");
   NSWindow* enclosingWindow = [self window];
   if (!enclosingWindow)
     return;
   _host->OnWindowFrameInScreenChanged(
       gfx::ScreenRectFromNSRect([enclosingWindow frame]));
 }

 - (void)setResponderDelegate:
     (NSObject<RenderWidgetHostViewMacDelegate>*)delegate {
   DCHECK(!_responderDelegate);
   _responderDelegate = delegate;
 }

 - (void)resetCursorRects {
   if (_currentCursor)
     [self addCursorRect:[self visibleRect] cursor:_currentCursor];
 }

 - (void)processedWheelEvent:(const blink::WebMouseWheelEvent&)event
                    consumed:(BOOL)consumed {
   [_responderDelegate rendererHandledWheelEvent:event consumed:consumed];
 }

 - (void)processedGestureScrollEvent:(const blink::WebGestureEvent&)event
                            consumed:(BOOL)consumed {
   [_responderDelegate rendererHandledGestureScrollEvent:event
                                                consumed:consumed];
 }

 - (void)processedOverscroll:(const ui::DidOverscrollParams&)params {
   [_responderDelegate rendererHandledOverscrollEvent:params];
 }

 - (BOOL)respondsToSelector:(SEL)selector {
   // Trickiness: this doesn't mean "does this object's superclass respond to
   // this selector" but rather "does the -respondsToSelector impl from the
   // superclass say that this class responds to the selector".
   if ([super respondsToSelector:selector])
     return YES;

   if (_responderDelegate)
     return [_responderDelegate respondsToSelector:selector];

   return NO;
 }

 - (id)forwardingTargetForSelector:(SEL)selector {
   if ([_responderDelegate respondsToSelector:selector])
     return _responderDelegate;

   return [super forwardingTargetForSelector:selector];
 }

 - (void)setCanBeKeyView:(BOOL)can {
   _canBeKeyView = can;
 }

 - (BOOL)acceptsMouseEventsWhenInactive {
   // Some types of windows (balloons, always-on-top panels) want to accept mouse
   // clicks w/o the first click being treated as 'activation'. Same applies to
   // mouse move events.
   return [[self window] level] > NSNormalWindowLevel;
 }

 - (BOOL)acceptsFirstMouse:(NSEvent*)theEvent {
   return [self acceptsMouseEventsWhenInactive];
 }

 - (void)setCloseOnDeactivate:(BOOL)b {
   _closeOnDeactivate = b;
 }

 - (void)setHostDisconnected {
   // Set the host to be an abandoned message pipe, and set the hostHelper
   // to forward messages to that host.
   std::ignore = _dummyHost.BindNewPipeAndPassReceiver();
   _dummyHostHelper = std::make_unique<DummyHostHelper>();
   _host = _dummyHost.get();
   _hostHelper = _dummyHostHelper.get();

   // |responderDelegate_| may attempt to access the RenderWidgetHostViewMac
   // through its internal pointers, so detach it here.
   // TODO(ccameron): Force |responderDelegate_| to use the |host_| as well,
   // and the viewGone method to hostGone.
   if (_responderDelegate &&
       [_responderDelegate respondsToSelector:@selector(viewGone:)])
     [_responderDelegate viewGone:self];
   _responderDelegate = nil;
 }

 - (bool)hostIsDisconnected {
   return _host == (_dummyHost.is_bound() ? _dummyHost.get() : nullptr);
 }

 - (void)setShowingContextMenu:(BOOL)showing {
   _showingContextMenu = showing;

   // Create a fake mouse event to inform the render widget that the mouse
   // left or entered.
   NSWindow* window = [self window];
   int windowNumber = window ? [window windowNumber] : -1;

   // TODO(asvitkine): If the location outside of the event stream doesn't
   // correspond to the current event (due to delayed event processing), then
   // this may result in a cursor flicker if there are later mouse move events
   // in the pipeline. Find a way to use the mouse location from the event that
   // dismissed the context menu.
   NSPoint location = [window mouseLocationOutsideOfEventStream];
   NSTimeInterval eventTime = [[NSApp currentEvent] timestamp];
   NSEvent* event = [NSEvent mouseEventWithType:NSEventTypeMouseMoved
                                       location:location
                                  modifierFlags:0
                                      timestamp:eventTime
                                   windowNumber:windowNumber
                                        context:nil
                                    eventNumber:0
                                     clickCount:0
                                       pressure:0];
   WebMouseEvent webEvent = WebMouseEventBuilder::Build(event, self);
   webEvent.SetModifiers(webEvent.GetModifiers() |
                         WebInputEvent::kRelativeMotionEvent);
   // TODO(crbug.com/1465562): We shouldn't be posting events with null
   // timestamps. However `MessagePumpNSApplication::DoQuit` usage of
   // `otherEventWithType` seems to truncate `NSTimeInterval` to seconds. Which
   // could lead to those generated events be in the past, compared to ones
   // created directly in later parts of the pipeline or in tests.
   if (webEvent.TimeStamp().is_null()) {
     webEvent.SetTimeStamp(ui::EventTimeForNow());
   }
   _hostHelper->ForwardMouseEvent(webEvent);
 }

 - (BOOL)shouldIgnoreMouseEvent:(NSEvent*)theEvent {
   NSWindow* window = [self window];
   // If this is a background window, don't handle mouse movement events. This
   // is the expected behavior on the Mac as evidenced by other applications.
   if ([theEvent type] == NSEventTypeMouseMoved &&
       ![self acceptsMouseEventsWhenInactive] && ![window isMainWindow] &&
       ![window isKeyWindow]) {
     return YES;
   }

   NSView* contentView = [window contentView];
   NSView* view = [contentView hitTest:[theEvent locationInWindow]];
   // Traverse the superview hierarchy as the hitTest will return the frontmost
   // view, such as an NSTextView, while nonWebContentView may be specified by
   // its parent view.
   BOOL hitSelf = NO;
   while (view) {
     if (view == self)
       hitSelf = YES;
     if ([view isKindOfClass:[self class]] && ![view isEqual:self] &&
         !_hasOpenMouseDown) {
       // The cursor is over an overlapping render widget. This check is done by
       // both views so the one that's returned by -hitTest: will end up
       // processing the event.
       // Note that while dragging, we only get events for the render view where
       // drag started, even if mouse is  actually over another view or outside
       // the window. Cocoa does this for us. We should handle these events and
       // not ignore (since there is no other render view to handle them). Thus
       // the |!hasOpenMouseDown_| check above.
       return YES;
     }
     view = [view superview];
   }
   // Ignore events which don't hit test to this subtree (and hit, for example,
   // an overlapping view instead). As discussed above, the mouse may go outside
   // the bounds of the view and keep sending events during a drag.
   return !hitSelf && !_hasOpenMouseDown;
 }

 - (void)mouseEvent:(NSEvent*)theEvent {
   TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::mouseEvent");
   if (_responderDelegate &&
       [_responderDelegate respondsToSelector:@selector(handleEvent:)]) {
     BOOL handled = [_responderDelegate handleEvent:theEvent];
     if (handled)
       return;
   }
   if (ui::PlatformEventSource::ShouldIgnoreNativePlatformEvents())
     return;

   // Set the pointer type when we are receiving a NSEventTypeMouseEntered event
   // and the following NSEventTypeMouseExited event should have the same pointer
   // type. For NSEventTypeMouseExited and NSEventTypeMouseEntered events, they
   // do not have a subtype. We decide their pointer types by checking if we
   // received a NSEventTypeTabletProximity event.
   NSEventType type = [theEvent type];
   if (type == NSEventTypeMouseEntered || type == NSEventTypeMouseExited) {
     _pointerType = _isStylusEnteringProximity
                        ? _pointerType
                        : blink::WebPointerProperties::PointerType::kMouse;
   } else {
     NSEventSubtype subtype = [theEvent subtype];
     // For other mouse events and touchpad events, the pointer type is mouse.
     if (subtype != NSEventSubtypeTabletPoint &&
         subtype != NSEventSubtypeTabletProximity) {
       _pointerType = blink::WebPointerProperties::PointerType::kMouse;
     } else if (subtype == NSEventSubtypeTabletProximity) {
       _isStylusEnteringProximity = [theEvent isEnteringProximity];
       NSPointingDeviceType deviceType = [theEvent pointingDeviceType];
       // For all tablet events, the pointer type will be pen or eraser.
       _pointerType = deviceType == NSPointingDeviceTypeEraser
                          ? blink::WebPointerProperties::PointerType::kEraser
                          : blink::WebPointerProperties::PointerType::kPen;
     }
   }

   // Because |updateCursor:| changes the current cursor, we have to reset it to
   // the default cursor on mouse exit.
   if (type == NSEventTypeMouseExited)
     [[NSCursor arrowCursor] set];

   if ([self shouldIgnoreMouseEvent:theEvent]) {
     // If this is the first such event, send a mouse exit to the host view.
     if (!_mouseEventWasIgnored && !self.hidden) {
       WebMouseEvent exitEvent =
           WebMouseEventBuilder::Build(theEvent, self, _pointerType);
       exitEvent.SetType(WebInputEvent::Type::kMouseLeave);
       exitEvent.button = WebMouseEvent::Button::kNoButton;
       _hostHelper->ForwardMouseEvent(exitEvent);
     }
     _mouseEventWasIgnored = YES;
     [self updateCursor:nil];
     return;
   }

   if (_mouseEventWasIgnored) {
     // If this is the first mouse event after a previous event that was ignored
     // due to the hitTest, send a mouse enter event to the host view.
     WebMouseEvent enterEvent =
         WebMouseEventBuilder::Build(theEvent, self, _pointerType);
     enterEvent.SetType(WebInputEvent::Type::kMouseMove);
     enterEvent.button = WebMouseEvent::Button::kNoButton;
     _hostHelper->RouteOrProcessMouseEvent(enterEvent);
   }
   _mouseEventWasIgnored = NO;

   // Don't cancel child popups; killing them on a mouse click would prevent the
   // user from positioning the insertion point in the text field spawning the
   // popup. A click outside the text field would cause the text field to drop
   // the focus, and then EditorHostImpl::textFieldDidEndEditing() would cancel
   // the popup anyway, so we're OK.
   if (type == NSEventTypeLeftMouseDown)
     _hasOpenMouseDown = YES;
   else if (type == NSEventTypeLeftMouseUp)
     _hasOpenMouseDown = NO;

   // TODO(suzhe): We should send mouse events to the input method first if it
   // wants to handle them. But it won't work without implementing method
   // - (NSUInteger)characterIndexForPoint:.
   // See: http://code.google.com/p/chromium/issues/detail?id=47141
   // Instead of sending mouse events to the input method first, we now just
   // simply confirm all ongoing composition here.
   if (type == NSEventTypeLeftMouseDown || type == NSEventTypeRightMouseDown ||
       type == NSEventTypeOtherMouseDown) {
     [self finishComposingText];
   }

   if (type == NSEventTypeMouseMoved)
     _cursorHidden = NO;

   bool unacceleratedMovement = _mouseLocked && _mouseLockUnacceleratedMovement;
   WebMouseEvent event = WebMouseEventBuilder::Build(
       theEvent, self, _pointerType, unacceleratedMovement);

   if (_mouseLocked &&
       base::FeatureList::IsEnabled(features::kConsolidatedMovementXY)) {
     // When mouse is locked, we keep increasing |_lastMouseScreenPosition|
     // by movement_x/y so that we can still use PositionInScreen to calculate
     // movements in blink. We need to keep |_lastMouseScreenPosition| from
     // getting too large because it will lose some precision. So whenever it
     // exceed the |kWrapAroundDistance|, we start again from the current
     // mouse position (locked position), and also send a synthesized event to
     // update the blink-side status.
     if (std::abs(_lastMouseScreenPosition.x()) > kWrapAroundDistance ||
         std::abs(_lastMouseScreenPosition.y()) > kWrapAroundDistance) {
       NSWindow* window = [self window];
       NSPoint location = [window mouseLocationOutsideOfEventStream];
       int windowNumber = window ? [window windowNumber] : -1;
       NSEvent* nsevent = [NSEvent mouseEventWithType:NSEventTypeMouseMoved
                                             location:location
                                        modifierFlags:[theEvent modifierFlags]
                                            timestamp:[theEvent timestamp]
                                         windowNumber:windowNumber
                                              context:nil
                                          eventNumber:0
                                           clickCount:[theEvent clickCount]
                                             pressure:0];
       WebMouseEvent wrapAroundEvent =
           WebMouseEventBuilder::Build(nsevent, self, _pointerType);
       _lastMouseScreenPosition = wrapAroundEvent.PositionInScreen();
       wrapAroundEvent.SetModifiers(
           event.GetModifiers() |
           blink::WebInputEvent::Modifiers::kRelativeMotionEvent);
       _hostHelper->RouteOrProcessMouseEvent(wrapAroundEvent);
     }
     event.SetPositionInScreen(
         _lastMouseScreenPosition +
         gfx::Vector2dF(event.movement_x, event.movement_y));
   }

   _lastMouseScreenPosition = event.PositionInScreen();
   _hostHelper->RouteOrProcessMouseEvent(event);
 }

 - (void)tabletEvent:(NSEvent*)theEvent {
   if ([theEvent type] == NSEventTypeTabletProximity) {
     _isStylusEnteringProximity = [theEvent isEnteringProximity];
     NSPointingDeviceType deviceType = [theEvent pointingDeviceType];
     // For all tablet events, the pointer type will be pen or eraser.
     _pointerType = deviceType == NSPointingDeviceTypeEraser
                        ? blink::WebPointerProperties::PointerType::kEraser
                        : blink::WebPointerProperties::PointerType::kPen;
   }
 }

 - (void)lockKeyboard:(std::optional<base::flat_set<ui::DomCode>>)keysToLock {
   // TODO(joedow): Integrate System-level keyboard hook into this method.
   _lockedKeys = std::move(keysToLock);
   _keyboardLockActive = true;
 }

 - (void)unlockKeyboard {
   _keyboardLockActive = false;
   _lockedKeys.reset();
 }

 - (void)setCursorLocked:(BOOL)locked {
   _mouseLocked = locked;
   if (_mouseLocked) {
     CGAssociateMouseAndMouseCursorPosition(NO);
     [NSCursor hide];
   } else {
     // Unlock position of mouse cursor and unhide it.
     CGAssociateMouseAndMouseCursorPosition(YES);
     [NSCursor unhide];
   }
 }

 - (void)setCursorLockedUnacceleratedMovement:(BOOL)unaccelerated {
   _mouseLockUnacceleratedMovement = unaccelerated;
 }

 // CommandDispatcherTarget implementation:
 - (BOOL)isKeyLocked:(NSEvent*)event {
   int keyCode = [event keyCode];
   // Note: We do not want to treat the ESC key as locked as that key is used
   // to exit fullscreen and we don't want to prevent them from exiting.
   ui::DomCode domCode = ui::KeycodeConverter::NativeKeycodeToDomCode(keyCode);
   return _keyboardLockActive && domCode != ui::DomCode::ESCAPE &&
          (!_lockedKeys || base::Contains(_lockedKeys.value(), domCode));
 }

 - (BOOL)performKeyEquivalent:(NSEvent*)theEvent {
   // TODO(bokan): Tracing added temporarily to diagnose crbug.com/1039833.
   TRACE_EVENT0("browser", "RenderWidgetHostViewCocoa::performKeyEquivalent");
   // |performKeyEquivalent:| is sent to all views of a window, not only down the
   // responder chain (cf. "Handling Key Equivalents" in
   // http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/EventOverview/HandlingKeyEvents/HandlingKeyEvents.html
   // ). A |performKeyEquivalent:| may also bubble up from a dialog child window
   // to perform browser commands such as switching tabs. We only want to handle
   // key equivalents if we're first responder in the keyWindow.
   if (![[self window] isKeyWindow] || [[self window] firstResponder] != self) {
     TRACE_EVENT_INSTANT0("browser", "NotKeyWindow", TRACE_EVENT_SCOPE_THREAD);
     return NO;
   }

   // If the event is reserved by the system, do not pass it to web content.
   // If the user changes the system hotkey mapping after Chrome has been
   // launched, it is possible that a formerly reserved system hotkey is no
   // longer reserved. The hotkey would have skipped the renderer, but would
   // also have not been handled by the system. If this is the case, immediately
   // return.
   // TODO(erikchen): SystemHotkeyHelperMac should use the File System Events
   // api to monitor changes to system hotkeys. This logic will have to be
   // updated.
   // http://crbug.com/383558.
   if (EventIsReservedBySystem(theEvent)) {
     return NO;
   }

   // Command key combinations are sent via performKeyEquivalent rather than
   // keyDown:. We just forward this on and if WebCore doesn't want to handle
   // it, we let the WebContentsView figure out how to reinject it.
   [self keyEvent:theEvent wasKeyEquivalent:YES];
   return YES;
 }

 - (BOOL)_wantsKeyDownForEvent:(NSEvent*)event {
   // This is a SPI that AppKit apparently calls after |performKeyEquivalent:|
   // returned NO. If this function returns |YES|, Cocoa sends the event to
   // |keyDown:| instead of doing other things with it. Ctrl-tab will be sent
   // to us instead of doing key view loop control, ctrl-left/right get handled
   // correctly, etc.
   // (However, there are still some keys that Cocoa swallows, e.g. the key
   // equivalent that Cocoa uses for toggling the input language. In this case,
   // that's actually a good thing, though -- see http://crbug.com/26115 .)
   return YES;
 }

 - (EventHandled)keyEvent:(NSEvent*)theEvent {
   if (_responderDelegate &&
       [_responderDelegate respondsToSelector:@selector(handleEvent:)]) {
     BOOL handled = [_responderDelegate handleEvent:theEvent];
     if (handled)
       return kEventHandled;
   }

   [self keyEvent:theEvent wasKeyEquivalent:NO];
   return kEventHandled;
 }

 - (void)keyEvent:(NSEvent*)theEvent wasKeyEquivalent:(BOOL)equiv {
   TRACE_EVENT1("browser", "RenderWidgetHostViewCocoa::keyEvent", "WindowNum",
                [[self window] windowNumber]);
   NSEventType eventType = [theEvent type];
   NSEventModifierFlags modifierFlags = [theEvent modifierFlags];
   int keyCode = [theEvent keyCode];

   // If the user changes the system hotkey mapping after Chrome has been
   // launched, then it is possible that a formerly reserved system hotkey is no
   // longer reserved. The hotkey would have skipped the renderer, but would
   // also have not been handled by the system. If this is the case, immediately
   // return.
   // TODO(erikchen): SystemHotkeyHelperMac should use the File System Events
   // api to monitor changes to system hotkeys. This logic will have to be
   // updated.
   // http://crbug.com/383558.
   if (EventIsReservedBySystem(theEvent))
     return;

   if (eventType == NSEventTypeFlagsChanged) {
     // Ignore NSEventTypeFlagsChanged events from the NumLock and Fn keys as
     // Safari does in -[WebHTMLView flagsChanged:] (of "WebHTMLView.mm").
     // Also ignore unsupported |keyCode| (255) generated by Convert, NonConvert
     // and KanaMode from JIS PC keyboard.
     if (!keyCode || keyCode == 10 || keyCode == 63 || keyCode == 255)
       return;
   }

   // Don't cancel child popups; the key events are probably what's triggering
   // the popup in the first place.

   NativeWebKeyboardEvent event((base::apple::OwnedNSEvent(theEvent)));
   ui::LatencyInfo latencyInfo;
   if (event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ||
       event.GetType() == blink::WebInputEvent::Type::kChar) {
     latencyInfo.set_source_event_type(ui::SourceEventType::KEY_PRESS);
   }

   latencyInfo.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_UI_COMPONENT);

   // If KeyboardLock has been requested for this keyCode, then mark the event
   // so it skips the pre-handler and is delivered straight to the website.
   if ([self isKeyLocked:theEvent])
     event.skip_if_unhandled = true;

   // Do not forward key up events unless preceded by a matching key down,
   // otherwise we might get an event from releasing the return key in the
   // omnibox (https://crbug.com/338736) or from closing another window
   // (https://crbug.com/155492).
   if (eventType == NSEventTypeKeyUp) {
     auto numErased = _unmatchedKeyDownCodes.erase(keyCode);
     if (numErased < 1)
       return;
   }

   // Tell the host that we are beginning a keyboard event. This ensures that
   // all event and Ime messages target the same RenderWidgetHost throughout this
   // function call.
   _host->BeginKeyboardEvent();

   bool shouldAutohideCursor = _textInputType != ui::TEXT_INPUT_TYPE_NONE &&
                               eventType == NSEventTypeKeyDown &&
                               !(modifierFlags & NSEventModifierFlagCommand);

   // We only handle key down events and just simply forward other events.
   if (eventType != NSEventTypeKeyDown) {
     _hostHelper->ForwardKeyboardEvent(event, latencyInfo);

     // Possibly autohide the cursor.
     if (shouldAutohideCursor) {
       [NSCursor setHiddenUntilMouseMoves:YES];
       _cursorHidden = YES;
     }

     _host->EndKeyboardEvent();
     return;
   }

   _unmatchedKeyDownCodes.insert(keyCode);

   RenderWidgetHostViewCocoa* __attribute__((objc_precise_lifetime))
   keepSelfAlive = self;

   // Records the current marked text state, so that we can know if the marked
   // text was deleted or not after handling the key down event.
   BOOL oldHasMarkedText = _hasMarkedText;

   // This method should not be called recursively.
   DCHECK(![self isHandlingKeyDown]);

   // Tells insertText: and doCommandBySelector: that we are handling a key
   // down event.
   _currentKeyDownCode = keyCode;

   // This is to handle an edge case for the "Live Conversion" feature in default
   // Japanese IME. When the feature is on, pressing the left key at the
   // composition boundary will reconvert previously committed text. The text
   // input system will call setMarkedText multiple times to end the current
   // composition and start a new one. In this case we'll need to call
   // ImeSetComposition in setMarkedText instead of here in keyEvent:, otherwise,
   // only the last setMarkedText will be processed.
   ui::DomCode domCode = ui::KeycodeConverter::NativeKeycodeToDomCode(keyCode);
   _isReconversionTriggered =
       base::FeatureList::IsEnabled(features::kMacImeLiveConversionFix) &&
       _hasMarkedText && domCode == ui::DomCode::ARROW_LEFT &&
       _markedTextSelectedRange.location == 0 && _markedRange.location != 0 &&
       _markedRange.location != NSNotFound;

   // These variables might be set when handling the keyboard event.
   // Clear them here so that we can know whether they have changed afterwards.
   _textToBeInserted.clear();
   _markedText.clear();
   _markedTextSelectedRange = NSMakeRange(NSNotFound, 0);
   _imeTextSpans.clear();
   _setMarkedTextReplacementRange = gfx::Range::InvalidRange();
   _unmarkTextCalled = NO;
   _hasEditCommands = NO;
   _editCommands.clear();

   // Since Mac Eisu Kana keys cannot be handled by interpretKeyEvents to enable/
   // disable an IME, we need to pass the event to processInputKeyBindings.
   // processInputKeyBindings is available at least on 10.11-11.0.
   if (keyCode == kVK_JIS_Eisu || keyCode == kVK_JIS_Kana) {
     if ([NSTextInputContext
             respondsToSelector:@selector(processInputKeyBindings:)]) {
       [NSTextInputContext performSelector:@selector(processInputKeyBindings:)
                                withObject:theEvent];
     }
   } else {
     // Previously, we would just send the event, shortcut or no, to
     // -interpretKeyEvents: below. The problem is that certain keyboard
     // shortcuts now use the Function/World key and in those cases the
     // corresponding shortcut fires but the shortcut event also gets processed
     // as if it were a key press. As a result, with the insertion point
     // in a web text box, after typing something like "Function e" to invoke
     // the Emoji palette, we would wind up in -insertText:replacementRange:.
     // The logic there ([self isHandlingKeyDown] && replacementRange.location ==
     // NSNotFound) would create an invisible placeholder for the character. This
     // invisible placeholder would cause macOS to position the palette at the
     // upper-left corner of the webcontents instead of at the insertion point.
     //
     // For these Function/World events, we want the AppKit to process them
     // as it usually would (i.e. via performKeyEquivalent:). It would be simpler
     // if we could pass all of these keyboard shortcut events along to
     // performKeyEquivalent:, however web pages are allowed to hijack keyboard
     // shortcuts and apparently that's done through interpretKeyEvents:.
     // Applications are not allowed to create these system events (you get a
     // warning if you try and the Function event modifier flag doesn't stick)
     // so it's OK not to allow web pages to do so either.
     //
     // If the event's not a shortcut, send it along to the input method first.
     // We can then decide what should be done according to the input method's
     // feedback.
     bool isASystemShortcutEvent = false;
     if (equiv) {
       bool isAKeyboardShortcutEvent =
           [[NSApp mainMenu] cr_menuItemForKeyEquivalentEvent:theEvent] != nil;

       const NSEventModifierFlags kSystemShortcutModifierFlag =
           NSEventModifierFlagFunction;
       isASystemShortcutEvent = isAKeyboardShortcutEvent &&
                                (ui::cocoa::ModifierMaskForKeyEvent(theEvent) &
                                 kSystemShortcutModifierFlag) != 0;
     }

     if (isASystemShortcutEvent) {
       [[NSApp mainMenu] performKeyEquivalent:theEvent];

       // Behavior changed in macOS Sonoma - now it's important we early-out
       // rather than allow the code to reach
       // _hostHelper->ForwardKeyboardEventWithCommands(). Go with the existing
       // behavior for prior versions because we know it works for them.
       if (base::mac::MacOSVersion() >= 14'00'00) {
         _currentKeyDownCode.reset();
         _host->EndKeyboardEvent();
         return;
       }
     } else {
       [self interpretKeyEvents:@[ theEvent ]];
     }
   }

   _currentKeyDownCode.reset();

   // Indicates if we should send the key event and corresponding editor commands
   // after processing the input method result.
   BOOL delayEventUntilAfterImeComposition = NO;

   // 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_if_unhandled = true;
     _hostHelper->ForwardKeyboardEvent(fakeEvent, latencyInfo);
     // 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)
       delayEventUntilAfterImeComposition = YES;
   } else {
     _hostHelper->ForwardKeyboardEventWithCommands(event, latencyInfo,
                                                   std::move(_editCommands));
   }

   // 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 information, such
   // as unmodifiedText, etc. And we need to set event.skip_if_unhandled to true
   // to prevent the browser from handling it again. Note that,
   // |textToBeInserted_| is a UTF-16 string, but it's fine to only handle BMP
   // characters here, as we can always insert non-BMP characters as text.
   BOOL textInserted = NO;
   if (_textToBeInserted.length() >
       ((_hasMarkedText || oldHasMarkedText) ? 0u : 1u)) {
     _host->ImeCommitText(_textToBeInserted, gfx::Range::InvalidRange());
     textInserted = YES;
   }

   // Updates or cancels the composition. If some text has been inserted, then
   // we don't need to cancel the composition explicitly.
   if (_hasMarkedText && _markedText.length()) {
     // Sends the updated marked text to the renderer so it can update the
     // composition node in WebKit.
     // When marked text is available, |markedTextSelectedRange_| will be the
     // range being selected inside the marked text.
     if (!_isReconversionTriggered) {
       _host->ImeSetComposition(_markedText, _imeTextSpans,
                                _setMarkedTextReplacementRange,
                                _markedTextSelectedRange.location,
                                NSMaxRange(_markedTextSelectedRange));
     }
   } else if (oldHasMarkedText && !_hasMarkedText && !textInserted) {
     if (_unmarkTextCalled) {
       _host->ImeFinishComposingText();
     } else {
       _host->ImeCancelCompositionFromCocoa();
     }
   }

   _isReconversionTriggered = NO;

   // Clear information from |interpretKeyEvents:|
   _setMarkedTextReplacementRange = gfx::Range::InvalidRange();

   // If the key event was handled by the input method but it also generated some
   // edit commands, then we need to send the real key event and corresponding
   // edit commands here. This usually occurs when the input method wants to
   // finish current composition session but still wants the application to
   // handle the key event. See http://crbug.com/48161 for reference.
   if (delayEventUntilAfterImeComposition) {
     // If |delayEventUntilAfterImeComposition| 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::Type::kKeyUp);
     fakeEvent.skip_if_unhandled = true;
     ui::LatencyInfo fakeEventLatencyInfo = latencyInfo;
     fakeEventLatencyInfo.set_source_event_type(ui::SourceEventType::OTHER);
     _hostHelper->ForwardKeyboardEvent(fakeEvent, fakeEventLatencyInfo);
     _hostHelper->ForwardKeyboardEventWithCommands(event, fakeEventLatencyInfo,
                                                   std::move(_editCommands));
   }

   const NSUInteger kCtrlCmdKeyMask =
       NSEventModifierFlagControl | NSEventModifierFlagCommand;
   // 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::Type::kChar);
       event.text[0] = _textToBeInserted[0];
       event.text[1] = 0;
       event.skip_if_unhandled = true;
       _hostHelper->ForwardKeyboardEvent(event, latencyInfo);
     } else if ((!textInserted || delayEventUntilAfterImeComposition) &&
                event.text[0] != '\0' &&
                ((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::Type::kChar);
       event.skip_if_unhandled = true;
       _hostHelper->ForwardKeyboardEvent(event, latencyInfo);
     }
   }

   // Possibly autohide the cursor.
   if (shouldAutohideCursor) {
     [NSCursor setHiddenUntilMouseMoves:YES];
     _cursorHidden = YES;
   }

   _host->EndKeyboardEvent();
 }

 - (BOOL)suppressNextKeyUpForTesting:(int)keyCode {
   return _unmatchedKeyDownCodes.count(keyCode) == 0;
 }

 - (void)forceTouchEvent:(NSEvent*)theEvent {
   if (ui::ForceClickInvokesQuickLook())
     [self quickLookWithEvent:theEvent];
 }

 - (void)shortCircuitScrollWheelEvent:(NSEvent*)event {
   if ([event phase] != NSEventPhaseEnded &&
       [event phase] != NSEventPhaseCancelled) {
     return;
   }

   // History-swiping is not possible if the logic reaches this point.
   WebMouseWheelEvent webEvent = WebMouseWheelEventBuilder::Build(event, self);
   webEvent.rails_mode = _mouseWheelFilter.UpdateRailsMode(webEvent);
   _hostHelper->ForwardWheelEvent(webEvent);

   if (_endWheelMonitor) {
     [NSEvent removeMonitor:_endWheelMonitor];
     _endWheelMonitor = nil;
   }
 }

 - (void)handleBeginGestureWithEvent:(NSEvent*)event
             isSyntheticallyInjected:(BOOL)isSyntheticallyInjected {
   [_responderDelegate beginGestureWithEvent:event];

   WebGestureEvent gestureBeginEvent(WebGestureEventBuilder::Build(event, self));

   _hostHelper->GestureBegin(gestureBeginEvent, isSyntheticallyInjected);
 }

 - (void)handleEndGestureWithEvent:(NSEvent*)event {
   [_responderDelegate endGestureWithEvent:event];

   // On macOS 10.11+, the end event has type = NSEventTypeMagnify and phase =
   // NSEventPhaseEnded. On macOS 10.10 and older, the event has type =
   // NSEventTypeEndGesture.
   if ([event type] == NSEventTypeMagnify ||
       [event type] == NSEventTypeEndGesture) {
     WebGestureEvent endEvent(WebGestureEventBuilder::Build(event, self));
     endEvent.SetType(WebInputEvent::Type::kGesturePinchEnd);
     endEvent.SetSourceDevice(blink::WebGestureDevice::kTouchpad);
     endEvent.SetNeedsWheelEvent(true);
     _hostHelper->GestureEnd(endEvent);
   }
 }

 - (void)touchesMovedWithEvent:(NSEvent*)event {
   [_responderDelegate touchesMovedWithEvent:event];
 }

 - (void)touchesBeganWithEvent:(NSEvent*)event {
   [_responderDelegate touchesBeganWithEvent:event];
 }

 - (void)touchesCancelledWithEvent:(NSEvent*)event {
   [_responderDelegate touchesCancelledWithEvent:event];
 }

 - (void)touchesEndedWithEvent:(NSEvent*)event {
   [_responderDelegate touchesEndedWithEvent:event];
 }

 - (void)smartMagnifyWithEvent:(NSEvent*)event {
   const WebGestureEvent& smartMagnifyEvent =
       WebGestureEventBuilder::Build(event, self);
   _hostHelper->SmartMagnify(smartMagnifyEvent);
 }

 - (void)showLookUpDictionaryOverlayFromRange:(NSRange)range {
   _host->LookUpDictionaryOverlayFromRange(gfx::Range(range));
 }

 // This is invoked only on 10.8 or newer when the user taps a word using
 // three fingers.
 - (void)quickLookWithEvent:(NSEvent*)event {
   NSPoint point = [self convertPoint:[event locationInWindow] fromView:nil];
   gfx::PointF rootPoint(point.x, NSHeight([self frame]) - point.y);
   _host->LookUpDictionaryOverlayAtPoint(rootPoint);
 }

 // This method handles 2 different types of hardware events.
 // (Apple does not distinguish between them).
 //  a. Scrolling the middle wheel of a mouse.
 //  b. Swiping on the track pad.
 //
 // This method is responsible for 2 types of behavior:
 //  a. Scrolling the content of window.
 //  b. Navigating forwards/backwards in history.
 //
 // This is a brief description of the logic:
 //  1. If the content can be scrolled, scroll the content.
 //     (This requires a roundtrip to blink to determine whether the content
 //      can be scrolled.)
 //     Once this logic is triggered, the navigate logic cannot be triggered
 //     until the gesture finishes.
 //  2. If the user is making a horizontal swipe, start the navigate
 //     forward/backwards UI.
 //     Once this logic is triggered, the user can either cancel or complete
 //     the gesture. If the user completes the gesture, all remaining touches
 //     are swallowed, and not allowed to scroll the content. If the user
 //     cancels the gesture, all remaining touches are forwarded to the content
 //     scroll logic. The user cannot trigger the navigation logic again.
 - (void)scrollWheel:(NSEvent*)event {
   if (event.phase == NSEventPhaseBegan) {
     [self handleBeginGestureWithEvent:event isSyntheticallyInjected:NO];
   }

   if (event.phase == NSEventPhaseEnded ||
       event.phase == NSEventPhaseCancelled) {
     [self handleEndGestureWithEvent:event];
   }

   if (_responderDelegate &&
       [_responderDelegate respondsToSelector:@selector(handleEvent:)]) {
     BOOL handled = [_responderDelegate handleEvent:event];
     if (handled)
       return;
   }

   // Use an NSEvent monitor to listen for the wheel-end end. This ensures that
   // the event is received even when the mouse cursor is no longer over the view
   // when the scrolling ends (e.g. if the tab was switched). This is necessary
   // for ending rubber-banding in such cases.
   if ([event phase] == NSEventPhaseBegan && !_endWheelMonitor) {
     _endWheelMonitor = [NSEvent
         addLocalMonitorForEventsMatchingMask:NSEventMaskScrollWheel
                                      handler:^(NSEvent* blockEvent) {
                                        [self shortCircuitScrollWheelEvent:
                                                  blockEvent];
                                        return blockEvent;
                                      }];
   }

   // This is responsible for content scrolling!
   WebMouseWheelEvent webEvent = WebMouseWheelEventBuilder::Build(event, self);
   webEvent.rails_mode = _mouseWheelFilter.UpdateRailsMode(webEvent);
   _hostHelper->RouteOrProcessWheelEvent(webEvent);
 }

 // Called repeatedly during a pinch gesture, with incremental change values.
 - (void)magnifyWithEvent:(NSEvent*)event {
   if (event.phase == NSEventPhaseBegan) {
     [self handleBeginGestureWithEvent:event isSyntheticallyInjected:NO];
     return;
   }

   if (event.phase == NSEventPhaseEnded ||
       event.phase == NSEventPhaseCancelled) {
     [self handleEndGestureWithEvent:event];
     return;
   }

   // If this conditional evaluates to true, and the function has not
   // short-circuited from the previous block, then this event is a duplicate of
   // a gesture event, and should be ignored.
   if (event.phase == NSEventPhaseBegan || event.phase == NSEventPhaseEnded ||
       event.phase == NSEventPhaseCancelled) {
     return;
   }

   WebGestureEvent updateEvent = WebGestureEventBuilder::Build(event, self);
   _hostHelper->GestureUpdate(updateEvent);
 }

 - (void)viewWillMoveToWindow:(NSWindow*)newWindow {
   NSWindow* oldWindow = [self window];

   NSNotificationCenter* notificationCenter =
       [NSNotificationCenter defaultCenter];

   if (oldWindow) {
     [notificationCenter removeObserver:self
                                   name:NSWindowDidChangeScreenNotification
                                 object:oldWindow];
     [notificationCenter
         removeObserver:self
                   name:NSWindowDidChangeBackingPropertiesNotification
                 object:oldWindow];
     [notificationCenter removeObserver:self
                                   name:NSWindowDidMoveNotification
                                 object:oldWindow];
     [notificationCenter removeObserver:self
                                   name:NSWindowDidResizeNotification
                                 object:oldWindow];
     [notificationCenter removeObserver:self
                                   name:NSWindowDidBecomeKeyNotification
                                 object:oldWindow];
     [notificationCenter removeObserver:self
                                   name:NSWindowDidResignKeyNotification
                                 object:oldWindow];
   }
   if (newWindow) {
     [notificationCenter
         addObserver:self
            selector:@selector(windowDidChangeScreenOrBackingProperties:)
                name:NSWindowDidChangeScreenNotification
              object:newWindow];
     [notificationCenter
         addObserver:self
            selector:@selector(windowDidChangeScreenOrBackingProperties:)
                name:NSWindowDidChangeBackingPropertiesNotification
              object:newWindow];
     [notificationCenter addObserver:self
                            selector:@selector(windowChangedGlobalFrame:)
                                name:NSWindowDidMoveNotification
                              object:newWindow];
     [notificationCenter addObserver:self
                            selector:@selector(windowChangedGlobalFrame:)
                                name:NSWindowDidResizeNotification
                              object:newWindow];
     [notificationCenter addObserver:self
                            selector:@selector(windowDidBecomeKey:)
                                name:NSWindowDidBecomeKeyNotification
                              object:newWindow];
     [notificationCenter addObserver:self
                            selector:@selector(windowDidResignKey:)
                                name:NSWindowDidResignKeyNotification
                              object:newWindow];
   }

   _hostHelper->SetAccessibilityWindow(newWindow);
   [self sendWindowFrameInScreenToHost];
 }

 - (void)updateScreenProperties {
   NSWindow* enclosingWindow = [self window];
   if (!enclosingWindow)
     return;

   // TODO(ccameron): This will call [enclosingWindow screen], which may return
   // nil. Do that call here to avoid sending bogus display info to the host.
   auto* screen = display::Screen::GetScreen();
   const display::ScreenInfos newScreenInfos =
       screen->GetScreenInfosNearestDisplay(
           screen->GetDisplayNearestView(self).id());
   _host->OnScreenInfosChanged(newScreenInfos);
 }

 // This will be called when the NSView's NSWindow moves from one NSScreen to
 // another, and makes note of the new screen's color space, scale factor, etc.
 // It is also called when the current NSScreen's properties change (which is
 // redundant with display::DisplayObserver::OnDisplayMetricsChanged).
 - (void)windowDidChangeScreenOrBackingProperties:(NSNotification*)notification {
   // Delay calling updateScreenProperties so that display::ScreenMac can
   // update our display::Displays first (if applicable).
   [self performSelector:@selector(updateScreenProperties)
              withObject:nil
              afterDelay:0];
 }

 - (void)windowChangedGlobalFrame:(NSNotification*)notification {
   [self sendWindowFrameInScreenToHost];
   // Update the view bounds relative to the window, as they may have changed
   // during layout, and we don't explicitly listen for re-layout of parent
   // views.
   [self sendViewBoundsInWindowToHost];
 }

 - (void)setFrame:(NSRect)r {
   // Note that -setFrame: calls through -setFrameSize: and -setFrameOrigin. To
   // avoid spamming the host with transiently invalid states, only send one
   // message at the end.
   _inSetFrame = YES;
   [super setFrame:r];
   _inSetFrame = NO;
   [self sendViewBoundsInWindowToHost];
 }

 - (void)setFrameOrigin:(NSPoint)newOrigin {
   [super setFrameOrigin:newOrigin];
   [self sendViewBoundsInWindowToHost];
 }

 - (void)setFrameSize:(NSSize)newSize {
   [super setFrameSize:newSize];
   [self sendViewBoundsInWindowToHost];
 }

 - (BOOL)canBecomeKeyView {
   if ([self hostIsDisconnected])
     return NO;

   return _canBeKeyView;
 }

 - (BOOL)acceptsFirstResponder {
   if ([self hostIsDisconnected])
     return NO;

   return _canBeKeyView;
 }

 - (void)windowDidBecomeKey:(NSNotification*)notification {
   DCHECK([self window]);
   DCHECK_EQ([self window], [notification object]);
   if ([_responderDelegate respondsToSelector:@selector(windowDidBecomeKey)])
     [_responderDelegate windowDidBecomeKey];
   if ([self window].isKeyWindow)
     _host->OnWindowIsKeyChanged(true);
 }

 - (void)windowDidResignKey:(NSNotification*)notification {
   DCHECK([self window]);
   DCHECK_EQ([self window], [notification object]);

   // If our app is still active and we're still the key window, ignore this
   // message, since it just means that a menu extra (on the "system status bar")
   // was activated; we'll get another |-windowDidResignKey| if we ever really
   // lose key window status.
   if ([NSApp isActive] && ([NSApp keyWindow] == [self window]))
     return;

   _host->OnWindowIsKeyChanged(false);
 }

 - (BOOL)becomeFirstResponder {
   if ([self hostIsDisconnected])
     return NO;
   if ([_responderDelegate respondsToSelector:@selector(becomeFirstResponder)])
     [_responderDelegate becomeFirstResponder];

   _host->OnFirstResponderChanged(true);

   // Cancel any ongoing composition text which was left before we lost focus.
   // TODO(suzhe): We should do it in -resignFirstResponder: method, but
   // somehow that method won't be called when switching among different tabs.
   // See http://crbug.com/47209
   [self cancelComposition];

   NSNumber* direction = @([[self window] keyViewSelectionDirection]);
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kViewDidBecomeFirstResponder
                     object:self
                   userInfo:@{kSelectionDirection : direction}];

   return YES;
 }

 - (BOOL)resignFirstResponder {
   if ([_responderDelegate respondsToSelector:@selector(resignFirstResponder)])
     [_responderDelegate resignFirstResponder];

   _host->OnFirstResponderChanged(false);
   if (_closeOnDeactivate) {
     [self setHidden:YES];
     _host->RequestShutdown();
   }

   // We should cancel any ongoing composition whenever RWH's Blur() method gets
   // called, because in this case, webkit will confirm the ongoing composition
   // internally.
   [self cancelComposition];

   return YES;
 }

 - (BOOL)isAutomaticQuoteSubstitutionEnabled {
   return [NSUserDefaults.standardUserDefaults
       boolForKey:WebAutomaticQuoteSubstitutionEnabled];
 }

 - (void)setAutomaticQuoteSubstitutionEnabled:(BOOL)enabled {
   [NSUserDefaults.standardUserDefaults
       setBool:enabled
        forKey:WebAutomaticQuoteSubstitutionEnabled];
 }

 - (void)toggleAutomaticQuoteSubstitution:(id)sender {
   self.automaticQuoteSubstitutionEnabled =
       !self.automaticQuoteSubstitutionEnabled;
 }

 - (BOOL)isAutomaticDashSubstitutionEnabled {
   return [NSUserDefaults.standardUserDefaults
       boolForKey:WebAutomaticDashSubstitutionEnabled];
 }

 - (void)setAutomaticDashSubstitutionEnabled:(BOOL)enabled {
   [NSUserDefaults.standardUserDefaults
       setBool:enabled
        forKey:WebAutomaticDashSubstitutionEnabled];
 }

 - (void)toggleAutomaticDashSubstitution:(id)sender {
   self.automaticDashSubstitutionEnabled =
       !self.automaticDashSubstitutionEnabled;
 }

 - (BOOL)isAutomaticTextReplacementEnabled {
   if (![NSUserDefaults.standardUserDefaults
           objectForKey:WebAutomaticTextReplacementEnabled]) {
     return NSSpellChecker.automaticTextReplacementEnabled;
   }
   return [NSUserDefaults.standardUserDefaults
       boolForKey:WebAutomaticTextReplacementEnabled];
 }

 - (void)setAutomaticTextReplacementEnabled:(BOOL)enabled {
   [NSUserDefaults.standardUserDefaults
       setBool:enabled
        forKey:WebAutomaticTextReplacementEnabled];
 }

 - (void)toggleAutomaticTextReplacement:(id)sender {
   self.automaticTextReplacementEnabled = !self.automaticTextReplacementEnabled;
 }

 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
   if (item.action == @selector(orderFrontSubstitutionsPanel:))
     return YES;
   if (NSMenuItem* menuItem = base::apple::ObjCCast<NSMenuItem>(item)) {
     if (item.action == @selector(toggleAutomaticQuoteSubstitution:)) {
       menuItem.state = self.automaticQuoteSubstitutionEnabled;
       return !!(self.allowedTextCheckingTypes & NSTextCheckingTypeQuote);
     } else if (item.action == @selector(toggleAutomaticDashSubstitution:)) {
       menuItem.state = self.automaticDashSubstitutionEnabled;
       return !!(self.allowedTextCheckingTypes & NSTextCheckingTypeDash);
     } else if (item.action == @selector(toggleAutomaticTextReplacement:)) {
       menuItem.state = self.automaticTextReplacementEnabled;
       return !!(self.allowedTextCheckingTypes & NSTextCheckingTypeReplacement);
     } else if (item.action == @selector(uppercaseWord:)) {
       return self.canTransformText;
     } else if (item.action == @selector(lowercaseWord:)) {
       return self.canTransformText;
     } else if (item.action == @selector(capitalizeWord:)) {
       return self.canTransformText;
     }
   }

   if (_responderDelegate &&
       [_responderDelegate respondsToSelector:@selector
                           (validateUserInterfaceItem:isValidItem:)]) {
     BOOL valid;
     BOOL known =
         [_responderDelegate validateUserInterfaceItem:item isValidItem:&valid];
     if (known)
       return valid;
   }

   bool isForMainFrame = false;
   _host->SyncIsWidgetForMainFrame(&isForMainFrame);

   SEL action = [item action];

   if (action == @selector(stopSpeaking:)) {
     if (!isForMainFrame) {
       return NO;
     }
     bool isSpeaking = false;
     _host->SyncIsSpeaking(&isSpeaking);
     return isSpeaking;
   }

   if (action == @selector(startSpeaking:))
     return isForMainFrame;

   // For now, these actions are always enabled for render view,
   // this is sub-optimal.
   // TODO(suzhe): Plumb the "can*" methods up from WebCore.
   if (action == @selector(undo:) || action == @selector(redo:) ||
       action == @selector(cut:) || action == @selector(copy:) ||
       action == @selector(centerSelectionInVisibleArea:) ||
       action == @selector(copyToFindPboard:) || action == @selector(paste:) ||
       action == @selector(pasteAndMatchStyle:)) {
     return isForMainFrame;
   }

   return _editCommandHelper->IsMenuItemEnabled(action, self);
 }

 - (RenderWidgetHostNSViewHost*)renderWidgetHostNSViewHost {
   return _host;
 }

 - (void)setAccessibilityParentElement:(id)accessibilityParent {
   _accessibilityParent = accessibilityParent;
 }

 - (void)setPopupParentNSViewId:(uint64_t)viewId {
   _popupParentNSViewId = viewId;
 }

 - (id)accessibilityHitTest:(NSPoint)point {
   id rootElement = _hostHelper->GetRootBrowserAccessibilityElement();
   if (!rootElement) {
     return self;
   }

   // Calling accessibilityHitTest on the BrowserAccessibility element will
   // redirect the hit test request to the render side, in
   // RenderAccessibilityImpl::HitTest. This function expects the point passed by
   // parameter to be relative to the main document, not relative to the popup
   // window. In order to satisfy this requirement, we need to keep a reference
   // to the parent NSView of the popup NSView and transform the |point| using
   // that view.
   NSView* popupParentNSView =
       remote_cocoa::GetNSViewFromId(_popupParentNSViewId);

   NSView* view = popupParentNSView ? popupParentNSView : self;

   NSPoint pointInWindow = [view.window convertPointFromScreen:point];
   NSPoint localPoint = [view convertPoint:pointInWindow fromView:nil];
   localPoint.y = NSHeight([view bounds]) - localPoint.y;

   return [rootElement accessibilityHitTest:localPoint];
 }

 - (id)accessibilityFocusedUIElement {
   return _hostHelper->GetFocusedBrowserAccessibilityElement();
 }

 // NSAccessibility formal protocol:

 - (NSArray*)accessibilityChildren {
   id root = _hostHelper->GetRootBrowserAccessibilityElement();
   if (root)
     return @[ root ];
   return nil;
 }

 - (NSArray*)accessibilityContents {
   return self.accessibilityChildren;
 }

 - (id)accessibilityParent {
   if (_accessibilityParent)
     return NSAccessibilityUnignoredAncestor(_accessibilityParent);
   return [super accessibilityParent];
 }

 - (NSAccessibilityRole)accessibilityRole {
   return NSAccessibilityScrollAreaRole;
 }

 // Below is our NSTextInputClient implementation.
 //
 // When WebHTMLView receives a NSEventTypeKeyDown event, WebHTMLView calls the
 // following functions to process this event.
 //
 // [WebHTMLView keyDown] ->
 //     EventHandler::keyEvent() ->
 //     ...
 //     [WebEditorHost handleKeyboardEvent] ->
 //     [WebHTMLView _interceptEditingKeyEvent] ->
 //     [NSResponder interpretKeyEvents] ->
 //     [WebHTMLView insertText] ->
 //     Editor::insertText()
 //
 // Unfortunately, it is hard for Chromium to use this implementation because
 // it causes key-typing jank.
 // RenderWidgetHostViewMac is running in a browser process. On the other
 // hand, Editor and EventHandler are running in a renderer process.
 // So, if we used this implementation, a NSEventTypeKeyDown event is dispatched
 // to the following functions of Chromium.
 //
 // [RenderWidgetHostViewMac keyEvent] (browser) ->
 //     |Sync IPC (KeyDown)| (*1) ->
 //     EventHandler::keyEvent() (renderer) ->
 //     ...
 //     EditorHostImpl::handleKeyboardEvent() (renderer) ->
 //     |Sync IPC| (*2) ->
 //     [RenderWidgetHostViewMac _interceptEditingKeyEvent] (browser) ->
 //     [self interpretKeyEvents] ->
 //     [RenderWidgetHostViewMac insertText] (browser) ->
 //     |Async IPC| ->
 //     Editor::insertText() (renderer)
 //
 // (*1) we need to wait until this call finishes since WebHTMLView uses the
 // result of EventHandler::keyEvent().
 // (*2) we need to wait until this call finishes since WebEditorHost uses
 // the result of [WebHTMLView _interceptEditingKeyEvent].
 //
 // This needs many sync IPC messages sent between a browser and a renderer for
 // each key event, which would probably result in key-typing jank.
 // To avoid this problem, this implementation processes key events (and input
 // method events) totally in a browser process and sends asynchronous input
 // events, almost same as KeyboardEvents (and TextEvents) of DOM Level 3, to a
 // renderer process.
 //
 // [RenderWidgetHostViewMac keyEvent] (browser) ->
 //     |Async IPC (RawKeyDown)| ->
 //     [self interpretKeyEvents] ->
 //     [RenderWidgetHostViewMac insertText] (browser) ->
 //     |Async IPC (Char)| ->
 //     Editor::insertText() (renderer)
 //
 // Since this implementation doesn't have to wait any IPC calls, this doesn't
 // make any key-typing jank. --hbono 7/23/09
 //
 extern "C" {
 extern NSString* NSTextInputReplacementRangeAttributeName;
 }

 - (NSArray*)validAttributesForMarkedText {
   // This code is just copied from WebKit except renaming variables.
   static NSArray* const kAttributes = @[
     NSUnderlineStyleAttributeName, NSUnderlineColorAttributeName,
     NSMarkedClauseSegmentAttributeName, NSTextInputReplacementRangeAttributeName
   ];
   return kAttributes;
 }

 - (NSUInteger)characterIndexForPoint:(NSPoint)thePoint {
   DCHECK([self window]);
   // |thePoint| is in screen coordinates, but needs to be converted to WebKit
   // coordinates (upper left origin). Scroll offsets will be taken care of in
   // the renderer.
   thePoint = [self.window convertPointFromScreen:thePoint];
   thePoint = [self convertPoint:thePoint fromView:nil];
   thePoint.y = NSHeight([self frame]) - thePoint.y;
   gfx::PointF rootPoint(thePoint.x, thePoint.y);

   uint32_t index = UINT32_MAX;
   _host->SyncGetCharacterIndexAtPoint(rootPoint, &index);
   // |index| could be WTF::notFound (-1) and its value is different from
   // NSNotFound so we need to convert it.
   if (index == UINT32_MAX)
     return NSNotFound;
   size_t charIndex = index;
   return NSUInteger(charIndex);
 }

 - (BOOL)drawsVerticallyForCharacterAtIndex:(NSUInteger)charIndex {
   return !!(_textInputFlags & blink::kWebTextInputFlagVertical);
 }

 - (NSRect)firstRectForCharacterRange:(NSRange)theRange
                          actualRange:(NSRangePointer)actualRange {
   gfx::Rect gfxRect;
   gfx::Range gfxActualRange;
   bool success = false;
   if (actualRange)
     gfxActualRange = gfx::Range::FromPossiblyInvalidNSRange(*actualRange);
   _host->SyncGetFirstRectForRange(
       gfx::Range::FromPossiblyInvalidNSRange(theRange), &gfxRect,
       &gfxActualRange, &success);
   if (!success) {
     // The call to cancelComposition comes from https://crrev.com/350261.
     [self cancelComposition];
     return NSZeroRect;
   }
   if (actualRange)
     *actualRange = gfxActualRange.ToNSRange();

   // The returned rectangle is in WebKit coordinates (upper left origin), so
   // flip the coordinate system.
   NSRect viewFrame = [self frame];
   NSRect rect = NSRectFromCGRect(gfxRect.ToCGRect());
   rect.origin.y = NSHeight(viewFrame) - NSMaxY(rect);

   // Convert into screen coordinates for return.
   rect = [self convertRect:rect toView:nil];
   rect = [[self window] convertRectToScreen:rect];

   if (_textInputFlags & blink::kWebTextInputFlagVertical) {
     // Google Japanese Input doesn't use the result of
     // drawsVerticallyForCharacterAtIndex. So we'd like to ask it to show its
     // horizontal candidate window at the right side of the caret if the text
     // is vertical.
     NSString* inputSourceName =
         [[self inputContext] selectedKeyboardInputSource];
     if ([inputSourceName hasPrefix:kGoogleJapaneseInputPrefix])
       rect.origin.x += rect.size.width;
   }

   return rect;
 }

 - (NSRange)selectedRange {
   return _textSelectionRange.ToNSRange();
 }

 - (NSRange)markedRange {
   // An input method calls this method to check if an application really has
   // a text being composed when hasMarkedText call returns true.
   // Returns the range saved in the setMarkedText method so the input method
   // calls the setMarkedText method and we can update the composition node
   // there. (When this method returns an empty range, the input method doesn't
   // call the setMarkedText method.)
   return _hasMarkedText ? _markedRange : NSMakeRange(NSNotFound, 0);
 }

 - (NSAttributedString*)attributedSubstringForProposedRange:(NSRange)range
                                                actualRange:
                                                    (NSRangePointer)actualRange {
   // Prepare |actualRange| as if the proposed range is invalid. If it is valid,
   // then |actualRange| will be updated again.
   if (actualRange)
     *actualRange = NSMakeRange(NSNotFound, 0);

   // The caller of this method is allowed to pass nonsensical ranges. These
   // can't even be converted into gfx::Ranges.
   if (range.location == NSNotFound || range.length == 0)
     return nil;
   if (range.length >= std::numeric_limits<NSUInteger>::max() - range.location)
     return nil;

   const gfx::Range requestedRange =
       gfx::Range::FromPossiblyInvalidNSRange(range);
   if (requestedRange.is_reversed())
     return nil;

   gfx::Range expectedRange;
   const std::u16string* expectedText;

   expectedText = &_availableText;
   size_t offset = _availableTextOffset;
   expectedRange = gfx::Range(offset, offset + expectedText->size());

   gfx::Range gfxActualRange = expectedRange.Intersect(requestedRange);
   if (!gfxActualRange.IsValid())
     return nil;
   if (actualRange)
     *actualRange = gfxActualRange.ToNSRange();

   std::u16string string = expectedText->substr(
       gfxActualRange.start() - expectedRange.start(), gfxActualRange.length());
   return [[NSAttributedString alloc]
       initWithString:base::SysUTF16ToNSString(string)];
 }

 - (NSInteger)conversationIdentifier {
   return reinterpret_cast<NSInteger>(self);
 }

 // Each RenderWidgetHostViewCocoa has its own input context, but we return
 // nil when the caret is in non-editable content or password box to avoid
 // making input methods do their work.
 // We disable input method inside password field as it is normal for Mac OS X
 // password input fields to not allow dead keys or non ASCII input methods.
 // There is also a privacy risk if the composition candidate window shows your
 // password when the user is "composing" inside a password field. See
 // crbug.com/1196101 for more info.
 - (NSTextInputContext*)inputContext {
   switch (_textInputType) {
     case ui::TEXT_INPUT_TYPE_NONE:
     case ui::TEXT_INPUT_TYPE_PASSWORD:
       return nil;
     default:
       return [super inputContext];
   }
 }

 - (BOOL)hasMarkedText {
   // An input method calls this function to figure out whether or not an
   // application is really composing a text. If it is composing, it calls
   // the markedRange method, and maybe calls the setMarkedText method.
   // It seems an input method usually calls this function when it is about to
   // cancel an ongoing composition. If an application has a non-empty marked
   // range, it calls the setMarkedText method to delete the range.
   return _hasMarkedText;
 }

 - (void)unmarkText {
   // Delete the composition node of the renderer and finish an ongoing
   // composition.
   // It seems an input method calls the setMarkedText method and set an empty
   // text when it cancels an ongoing composition, i.e. I have never seen an
   // input method calls this method.
   _hasMarkedText = NO;
   _markedText.clear();
   _markedTextSelectedRange = NSMakeRange(NSNotFound, 0);
   _imeTextSpans.clear();

   // If we are handling a key down event, then FinishComposingText() will be
   // called in keyEvent: method.
   if (![self isHandlingKeyDown]) {
     _host->ImeFinishComposingText();
   } else {
     _unmarkTextCalled = YES;
   }
 }

 - (void)setMarkedText:(id)string
         selectedRange:(NSRange)newSelRange
      replacementRange:(NSRange)replacementRange {
   // An input method updates the composition string.
   // We send the given text and range to the renderer so it can update the
   // composition node of WebKit.
   // TODO(suzhe): It's hard for us to support replacementRange without accessing
   // the full web content.
   BOOL isAttributedString = [string isKindOfClass:[NSAttributedString class]];
   NSString* imText = isAttributedString ? [string string] : string;
   int length = [imText length];
   const BOOL fixLiveConversion =
       base::FeatureList::IsEnabled(features::kMacImeLiveConversionFix);

   // |markedRange_| will get set on a callback from ImeSetComposition().
   _markedTextSelectedRange = newSelRange;
   _markedText = base::SysNSStringToUTF16(imText);

   // Update markedRange/textSelectionRange assuming blink sets composition text
   // as is. We need this because the IME checks markedRange/textSelectionRange
   // before IPC to blink. If markedRange/textSelectionRange is not updated, IME
   // will behave incorrectly, e.g., wrong popup window position or duplicate
   // characters.
   if (length > 0) {
     _hasMarkedText = YES;
     if (!fixLiveConversion) {
       length = [string length];
     }
     if (replacementRange.location != NSNotFound) {
       // If the replacement range is valid, the range should be replaced with
       // the new text.
       _markedRange = NSMakeRange(replacementRange.location, length);
     } else if (fixLiveConversion && _markedRange.location == NSNotFound) {
       // If no replacement range and no marked range, the current selection
       // should be replaced.
       _markedRange = NSMakeRange(_textSelectionRange.start(), length);
     } else {
       // If no replacement range and the marked range is valid, the current
       // marked text should be replaced.
       _markedRange.length = length;
     }

     if (fixLiveConversion) {
       CHECK_LE(_markedRange.location + newSelRange.location,
                std::numeric_limits<uint32_t>::max())
           << "`start` is too large; _markedRange.location="
           << _markedRange.location
           << "; newSelRange.location=" << newSelRange.location;
       CHECK_LE(_markedRange.location + NSMaxRange(newSelRange),
                std::numeric_limits<uint32_t>::max())
           << "`end` is too large; _markedRange.location="
           << _markedRange.location
           << "; NSMaxRange(newSelRange)=" << NSMaxRange(newSelRange);
       _textSelectionRange =
           gfx::Range(_markedRange.location + newSelRange.location,
                      _markedRange.location + NSMaxRange(newSelRange));
     }
   } else {
     // An empty text means the composition is about to be cancelled,
     // collapse the selection to the beginning of the current marked range.
     if (fixLiveConversion && _hasMarkedText) {
       CHECK_LE(_markedRange.location, std::numeric_limits<uint32_t>::max())
           << "_markedRange.location is too large.";
       _textSelectionRange =
           gfx::Range(_markedRange.location, _markedRange.location);
     }
     _markedRange = NSMakeRange(NSNotFound, 0);
     _hasMarkedText = NO;
   }

   _imeTextSpans.clear();
   if (isAttributedString) {
     ExtractUnderlines(string, &_imeTextSpans);
   } else {
     // Use a thin black underline by default.
     _imeTextSpans.emplace_back(ui::ImeTextSpan::Type::kComposition, 0, length,
                                ui::ImeTextSpan::Thickness::kThin,
                                ui::ImeTextSpan::UnderlineStyle::kSolid,
                                SK_ColorTRANSPARENT);
   }

   // If we are handling a key down event and the reconversion is not triggered,
   // SetComposition() will be called in keyEvent: method.
   // Input methods of Mac use setMarkedText calls with an empty text to cancel
   // an ongoing composition. So, we should check whether or not the given text
   // is empty to update the input method state. (Our input method backend
   // automatically cancels an ongoing composition when we send an empty text.
   // So, it is OK to send an empty text to the renderer.)
   if ([self isHandlingKeyDown] && !_isReconversionTriggered) {
     _setMarkedTextReplacementRange = gfx::Range(replacementRange);
   } else {
     _host->ImeSetComposition(_markedText, _imeTextSpans,
                              gfx::Range(replacementRange), newSelRange.location,
                              NSMaxRange(newSelRange));
   }

   [[self inputContext] invalidateCharacterCoordinates];
   [self setNeedsDisplay:YES];
 }

 - (void)doCommandBySelector:(SEL)selector {
   // An input method calls this function to dispatch an editing command to be
   // handled by this view.
   if (selector == @selector(noop:))
     return;

   std::string command(base::SysNSStringToUTF8(
       RenderWidgetHostViewMacEditCommandHelper::CommandNameForSelector(
           selector)));

   // If this method is called when handling a key down event, then we need to
   // handle the command in the key event handler. Otherwise we can just handle
   // it here.
   if ([self isHandlingKeyDown]) {
     if ((_textInputFlags & blink::kWebTextInputFlagVertical)) {
       // Commands assigned to arrow keys are ignored and Blink handles key down
       // events because macOS doesn't work well with some vertical writing
       // modes. See editing_behavior.cc.
       //
       // The following bindings are affected:
       //                 Left: moveLeft
       //           Shift-Left: moveLeftAndModifySelection
       //          Option-Left: moveWordLeft
       //    Option-Shift-Left: moveWordLeftAndModifySelection
       //                Right: moveRight
       //          Shift-Right: moveRightAndModifySelection
       //         Option-Right: moveWordRight
       //   Option-Shift-Right: moveWordRightAndModifySelection
       //                   Up: moveUp
       //             Shift-Up: moveUpAndModifySelection
       //            Option-Up: moveBackward + moveToBeginningOfParagraph
       //                 Down: moveDown
       //           Shift-Down: moveDownAndModifySelection
       //          Option-Down: moveForward + moveToEndOfParagraph:
       //
       // This doesn't affect Fn + an arrow key, which produces a keyCode for
       // PageUp, PageDown, Home, or End.
       unsigned short keyCode = *_currentKeyDownCode;
       if (keyCode == kVK_LeftArrow || keyCode == kVK_RightArrow ||
           keyCode == kVK_DownArrow || keyCode == kVK_UpArrow) {
         return;
       }
     }
     _hasEditCommands = YES;
     // We ignore commands that insert characters, because this was causing
     // strange behavior (e.g. tab always inserted a tab rather than moving to
     // the next field on the page).
     if (!base::StartsWith(command, "insert",
                           base::CompareCase::INSENSITIVE_ASCII))
       _editCommands.push_back(blink::mojom::EditCommand::New(command, ""));
   } else {
     _host->ExecuteEditCommand(command);
   }
 }

 - (void)insertText:(id)string replacementRange:(NSRange)replacementRange {
   // An input method has characters to be inserted.
   // Same as Linux, Mac calls this method not only:
   // * when an input method finishes composing text, but also;
   // * when we type an ASCII character (without using input methods).
   // When we aren't using input methods, we should send the given character as
   // a Char event so it is dispatched to an onkeypress() event handler of
   // JavaScript.
   // On the other hand, when we are using input methods, we should send the
   // given characters as an input method event and prevent the characters from
   // being dispatched to onkeypress() event handlers.
   // Text inserting might be initiated by other source instead of keyboard
   // events, such as the Characters dialog. In this case the text should be
   // sent as an input method event as well.
   BOOL isAttributedString = [string isKindOfClass:[NSAttributedString class]];
   NSString* imText = isAttributedString ? [string string] : string;
   if ([self isHandlingKeyDown] && replacementRange.location == NSNotFound) {
     // The user uses keyboard to type in a char without an IME or select a word
     // on the IME. Don't commit the change to the render, because the event is
     // being processed in |keyEvent:|. The commit will happen later after
     // |interpretKeyEvents:| returns.
     _textToBeInserted.append(base::SysNSStringToUTF16(imText));
     _shouldRequestTextSubstitutions = YES;
   } else {
     // The user uses mouse or touch bar to select a word on the IME.
     gfx::Range replacementGfxRange =
         gfx::Range::FromPossiblyInvalidNSRange(replacementRange);
     _host->ImeCommitText(base::SysNSStringToUTF16(imText), replacementGfxRange);
   }

   if (replacementRange.location == NSNotFound) {
     // Cancel selection after a IME commit by setting a zero-length selection
     // at the end of insertion point.
     // This is required for macOS 10.12+, otherwise the predictive completions
     // of IMEs won't work. See crbug.com/710101.
     int insertEndpoint = _markedRange.location + [imText length];
     _textSelectionRange = gfx::Range(insertEndpoint, insertEndpoint);
     // IMEs read |_availableText| preceding the insertion point as the context
     // for predictive completion. Unfortunately by the moment IME reads the
     // text, Blink likely hasn't finished the commit so the IME will read a
     // wrong context. We hack it by temporarily inserting the committed text
     // into
     // |_availableText|. This variable will ultimately be asynchronously updated
     // by Blink.
     // TODO(crbug.com/1169288): Mac's IME API is synchronous and it plays badly
     // with async APIs between the browser and the renderer. Probably replace
     // the sync |interpretKeyEvents:| with the async
     // |handleEventByInputMethod:|, which is an undocumented API used in
     // Webkit2.
     if (_markedRange.location >= _availableTextOffset &&
         _markedRange.location <= _availableTextOffset + _availableText.length())
       _availableText.insert(_markedRange.location - _availableTextOffset,
                             base::SysNSStringToUTF16(imText));
   }

   // Inserting text will delete all marked text automatically.
   _hasMarkedText = NO;
 }

 - (void)insertText:(id)string {
   [self insertText:string replacementRange:NSMakeRange(NSNotFound, 0)];
 }

 - (void)viewDidMoveToWindow {
   // Update the window's frame, the view's bounds, focus, and the display info,
   // as they have not been updated while unattached to a window.
   [self sendWindowFrameInScreenToHost];
   [self sendViewBoundsInWindowToHost];
   [self updateScreenProperties];
   _host->OnWindowIsKeyChanged([[self window] isKeyWindow]);
   _host->OnFirstResponderChanged([[self window] firstResponder] == self);

   // If we switch windows (or are removed from the view hierarchy), cancel any
   // open mouse-downs.
   if (_hasOpenMouseDown) {
     WebMouseEvent event(WebInputEvent::Type::kMouseUp,
                         WebInputEvent::kNoModifiers, ui::EventTimeForNow());
     event.button = WebMouseEvent::Button::kLeft;
     _hostHelper->ForwardMouseEvent(event);
     _hasOpenMouseDown = NO;
   }
 }

 - (void)undo:(id)sender {
   _host->Undo();
 }

 - (void)redo:(id)sender {
   _host->Redo();
 }

 - (void)cut:(id)sender {
   _host->Cut();
 }

 - (void)copy:(id)sender {
   _host->Copy();
 }

 - (void)copyToFindPboard:(id)sender {
   _host->CopyToFindPboard();
 }

 - (void)centerSelectionInVisibleArea:(id)sender {
   _host->CenterSelection();
 }

 - (void)paste:(id)sender {
   _host->Paste();
 }

 - (void)pasteAndMatchStyle:(id)sender {
   _host->PasteAndMatchStyle();
 }

 - (void)selectAll:(id)sender {
   // editCommandHelper_ adds implementations for most NSResponder methods
   // dynamically. But the renderer side only sends selection results back to
   // the browser if they were triggered by a keyboard event or went through
   // one of the Select methods on RWH. Since selectAll: is called from the
   // menu handler, neither is true.
   // Explicitly call SelectAll() here to make sure the renderer returns
   // selection results.
   _host->SelectAll();
 }

 - (void)startSpeaking:(id)sender {
   _host->StartSpeaking();
 }

 - (void)stopSpeaking:(id)sender {
   _host->StopSpeaking();
 }

 - (void)cancelComposition {
   [NSSpellChecker.sharedSpellChecker dismissCorrectionIndicatorForView:self];

   if (!_hasMarkedText)
     return;

   NSTextInputContext* inputContext = [self inputContext];
   [inputContext discardMarkedText];

   _hasMarkedText = NO;
   // Should not call [self unmarkText] here, because it'll send unnecessary
   // cancel composition IPC message to the renderer.
 }

 - (void)finishComposingText {
   if (!_hasMarkedText)
     return;

   _host->ImeFinishComposingText();
   [self cancelComposition];
 }

 // Overriding a NSResponder method to support application services.

 - (id)validRequestorForSendType:(NSString*)sendType
                      returnType:(NSString*)returnType {
   id requestor = nil;
   BOOL sendTypeIsString = [sendType isEqualToString:NSPasteboardTypeString];
   BOOL returnTypeIsString = [returnType isEqualToString:NSPasteboardTypeString];
   BOOL hasText = !_textSelectionRange.is_empty();
   BOOL takesText = _textInputType != ui::TEXT_INPUT_TYPE_NONE;

   if (sendTypeIsString && hasText && !returnType) {
     requestor = self;
   } else if (!sendType && returnTypeIsString && takesText) {
     requestor = self;
   } else if (sendTypeIsString && returnTypeIsString && hasText && takesText) {
     requestor = self;
   } else {
     requestor =
         [super validRequestorForSendType:sendType returnType:returnType];
   }
   return requestor;
 }

 - (BOOL)shouldChangeCurrentCursor {
   // |updateCursor:| might be called outside the view bounds. Check the mouse
   // location before setting the cursor. Also, do not set cursor if it's not a
   // key window.
   NSPoint location = [self.window convertPointFromScreen:NSEvent.mouseLocation];
   location = [self convertPoint:location fromView:nil];
   if (![self mouse:location inRect:[self bounds]] ||
       ![[self window] isKeyWindow])
     return NO;

   if (_cursorHidden || _showingContextMenu)
     return NO;

   return YES;
 }

 - (void)updateCursor:(NSCursor*)cursor {
   if (_currentCursor == cursor)
     return;

   _currentCursor = cursor;
   [[self window] invalidateCursorRectsForView:self];

   // NSWindow's invalidateCursorRectsForView: resets cursor rects but does not
   // update the cursor instantly. The cursor is updated when the mouse moves.
   // Update the cursor instantly by setting the current cursor.
   if ([self shouldChangeCurrentCursor])
     [_currentCursor set];
 }

 - (void)popupWindowWillClose:(NSNotification*)notification {
   [self setHidden:YES];
   _host->RequestShutdown();
 }

 - (void)invalidateTouchBar {
   // Work around a crash (https://crbug.com/822427).
   [_candidateListTouchBarItem setCandidates:@[]
                            forSelectedRange:NSMakeRange(NSNotFound, 0)
                                    inString:nil];
   _candidateListTouchBarItem = nil;
   self.touchBar = nil;
 }

 - (NSTouchBar*)makeTouchBar {
   if (_textInputType != ui::TEXT_INPUT_TYPE_NONE) {
     _candidateListTouchBarItem = [[NSCandidateListTouchBarItem alloc]
         initWithIdentifier:NSTouchBarItemIdentifierCandidateList];

     _candidateListTouchBarItem.delegate = self;
     _candidateListTouchBarItem.client = self;
     [self requestTextSuggestions];

     auto* touchBar = [[NSTouchBar alloc] init];
     touchBar.customizationIdentifier = ui::GetTouchBarId(kWebContentTouchBarId);
     touchBar.templateItems = [NSSet setWithObject:_candidateListTouchBarItem];
     bool includeEmojiPicker =
         _textInputType == ui::TEXT_INPUT_TYPE_TEXT ||
         _textInputType == ui::TEXT_INPUT_TYPE_SEARCH ||
         _textInputType == ui::TEXT_INPUT_TYPE_TEXT_AREA ||
         _textInputType == ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE;
     if (includeEmojiPicker) {
       touchBar.defaultItemIdentifiers = @[
         NSTouchBarItemIdentifierCharacterPicker,
         NSTouchBarItemIdentifierCandidateList
       ];
     } else {
       touchBar.defaultItemIdentifiers =
           @[ NSTouchBarItemIdentifierCandidateList ];
     }
     return touchBar;
   }

   return [super makeTouchBar];
 }

 - (BOOL)isHandlingKeyDown {
   return _currentKeyDownCode.has_value();
 }

 @end

 //
 // Supporting application services
 //

 @interface RenderWidgetHostViewCocoa (
     NSServicesRequests)<NSServicesMenuRequestor>
 @end

 @implementation RenderWidgetHostViewCocoa (NSServicesRequests)

 - (BOOL)writeSelectionToPasteboard:(NSPasteboard*)pboard types:(NSArray*)types {
   // /!\ Compatibility hack!
   //
   // The NSServicesMenuRequestor protocol does not pass in the correct
   // NSPasteboardType constants in the `types` array, verified through macOS 13
   // (FB11838671). To keep the code below clean, if an obsolete type is passed
   // in, rewrite the array.
   //
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
   if ([types containsObject:NSStringPboardType] &&
       ![types containsObject:NSPasteboardTypeString]) {
     types = [types arrayByAddingObject:NSPasteboardTypeString];
   }
 #pragma clang diagnostic pop
   // /!\ End compatibility hack.

   bool wasAbleToWriteAtLeastOneType = false;

   if ([types containsObject:NSPasteboardTypeString] &&
       !_textSelectionRange.is_empty()) {
     NSString* text = base::SysUTF16ToNSString([self selectedText]);
     wasAbleToWriteAtLeastOneType |= [pboard writeObjects:@[ text ]];
   }

   return wasAbleToWriteAtLeastOneType;
 }

 - (BOOL)readSelectionFromPasteboard:(NSPasteboard*)pboard {
   NSArray* objects = [pboard readObjectsForClasses:@[ [NSString class] ]
                                            options:nil];
   if (!objects.count) {
     return NO;
   }

   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self finishComposingText];

   // It's expected that there only will be one string object on the pasteboard,
   // but if there is more than one, catenate them. This is the same compat
   // technique used by the compatibility call, -[NSPasteboard stringForType:].
   NSString* allTheText = [objects componentsJoinedByString:@"\n"];
   [self insertText:allTheText];
   return YES;
 }

 // "-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