tree e03c2187f9012a67c98700589a4107c56a60d49b
parent 5f85983453d280367fc83e99f94690203352956f
author Mahesh Machavolu <mahesh.ma@samsung.com> 1681970980 +0000
committer Chromium LUCI CQ <chromium-scoped@luci-project-accounts.iam.gserviceaccount.com> 1681970980 +0000

Update Direct writing service callback aidl and implement new methods

Update service callback aidl to reflect two new methods requested
by service and provide Chrome side implementation for the same:
1. void updateBoundedEditTextRect()
2. boolean isHoverIconShowing()

Bug: 1433185
Change-Id: I128beb5a62a3354b61dff630277568e60dbf6dc9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4422017
Reviewed-by: Peter Conn <peconn@chromium.org>
Reviewed-by: Jinsuk Kim <jinsukkim@chromium.org>
Reviewed-by: Mustafa Emre Acer <meacer@chromium.org>
Commit-Queue: Mahesh Machavolu <mahesh.ma@samsung.com>
Cr-Commit-Position: refs/heads/main@{#1132942}
