content / app_shim_remote_cocoa / render_widget_host_view_cocoa.mm [blame]

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

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/342213636): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#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/numerics/safe_conversions.h"
#include "base/strings/sys_string_conversions.h"
#include "components/input/web_input_event_builders_mac.h"
#include "components/remote_cocoa/app_shim/ns_view_ids.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/public/browser/browser_accessibility_state.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"
#include "ui/accessibility/accessibility_features.h"
#import "ui/accessibility/platform/browser_accessibility_cocoa.h"
#import "ui/accessibility/platform/browser_accessibility_mac.h"
#include "ui/accessibility/platform/browser_accessibility_manager_mac.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 blink::WebGestureEvent;
using blink::WebInputEvent;
using blink::WebMouseEvent;
using blink::WebMouseWheelEvent;
using blink::WebTouchEvent;
using content::RenderWidgetHostViewMacEditCommandHelper;
using input::NativeWebKeyboardEvent;
using input::WebGestureEventBuilder;
using input::WebMouseEventBuilder;
using input::WebMouseWheelEventBuilder;
using input::WebTouchEventBuilder;
using remote_cocoa::RenderWidgetHostNSViewHostHelper;
using remote_cocoa::mojom::RenderWidgetHostNSViewHost;

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 GetAccessibilityElement() override { return nil; }
  id GetRootBrowserAccessibilityElement() override { return nil; }
  id GetFocusedBrowserAccessibilityElement() override { return nil; }
  void SetAccessibilityWindow(NSWindow* window) override {}
  void ForwardKeyboardEvent(const input::NativeWebKeyboardEvent& key_event,
                            const ui::LatencyInfo& latency_info) override {}
  void ForwardKeyboardEventWithCommands(
      const input::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;
  bool _sonomaAccessibilityRefinementsAreActive;
}

@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;
    _sonomaAccessibilityRefinementsAreActive =
        base::mac::MacOSVersion() >= 14'00'00 &&
        base::FeatureList::IsEnabled(
            features::kSonomaAccessibilityActivationRefinements);
  }
  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;
}

- (AcceptMouseEventsOption)acceptsMouseEventsOption {
  // Always-on-top windows, e.g picture-in-picture window, accepts all mouse
  // events even if the window or the application is inactive.
  if ([[self window] level] > NSNormalWindowLevel) {
    return kAcceptMouseEventsAlways;
  }

  // By default, only active window accepts mouse events. The embedder may
  // override this to mimic the hover and click behavior of native UIs.
  if (_responderDelegate && [_responderDelegate respondsToSelector:@selector
                                                (acceptsMouseEventsOption)]) {
    return [_responderDelegate acceptsMouseEventsOption];
  }

  // By default, only active window accepts mouse events.
  return kAcceptMouseEventsInActiveWindow;
}

- (BOOL)acceptsFirstMouse:(NSEvent*)theEvent {
  // Enable "click-through" if mouse clicks are accepted in inactive windows
  return [self acceptsMouseEventsOption] > kAcceptMouseEventsInActiveWindow;
}

- (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/40276040): 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 ([theEvent type] == NSEventTypeMouseMoved) {
    bool inActiveWindow = [window isMainWindow] || [window isKeyWindow];
    bool inActiveApp = [[NSApplication sharedApplication] isActive];
    AcceptMouseEventsOption option = [self acceptsMouseEventsOption];
    // If events are accepted only in active window but this window is inactive,
    // ignore this event. This is the default behavior.
    if (option == kAcceptMouseEventsInActiveWindow && !inActiveWindow) {
      return YES;
    }
    // If events are accepted in active app but the app in active, ignore this
    // event. This only happens if the content embedder overrides the default
    // behavior.
    if (option == kAcceptMouseEventsInActiveApp && !inActiveApp) {
      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) {
    // 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;
  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);

  NS_VALID_UNTIL_END_OF_SCOPE RenderWidgetHostViewCocoa* 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;
    _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) {
    if (features::IsAccessibilityRemoteUIAppEnabled()) {
      id rwhvElement = _hostHelper->GetAccessibilityElement();
      if (rwhvElement && rwhvElement != self) {
        return [rwhvElement accessibilityHitTest:point];
      }
    }
    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 {
  if (_sonomaAccessibilityRefinementsAreActive) {
    content::BrowserAccessibilityState* accessibility_state =
        content::BrowserAccessibilityState::GetInstance();

    // When an AT asks the application object for its role, we activate
    // nativeAPI accessibility support. If the AT descends into the AX tree
    // and arrives here (the web contents container), activate basic support
    // so that the AT can descend further into the web content.
    if (!accessibility_state->GetAccessibilityMode().has_mode(
            ui::kAXModeBasic.flags())) {
      accessibility_state->AddAccessibilityModeFlags(ui::kAXModeBasic);
    }
  }

  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 && newSelRange.location != NSNotFound) {
      CHECK_NE(_markedRange.location, static_cast<NSUInteger>(NSNotFound));
      CHECK_LE(_markedRange.location, std::numeric_limits<uint32_t>::max());
      CHECK_LE(newSelRange.location, std::numeric_limits<uint32_t>::max());
      // `_markedRange.location + NSMaxRange(newSelRange)` can be larger than
      // the maximum uint32_t. See crbug.com/40060200.
      uint32_t new_end = base::saturated_cast<uint32_t>(
          _markedRange.location + NSMaxRange(newSelRange));
      _textSelectionRange =
          gfx::Range(_markedRange.location + newSelRange.location, new_end);
    }
  } 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/40165347): 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