// 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.
#include "chrome/browser/ui/ash/keyboard/chrome_keyboard_bounds_observer.h"
#include "ash/constants/ash_features.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/root_window_controller.h"
#include "chrome/browser/apps/platform_apps/app_window_registry_util.h"
#include "content/public/browser/render_widget_host.h"
#include "content/public/browser/render_widget_host_iterator.h"
#include "content/public/browser/render_widget_host_view.h"
#include "extensions/browser/app_window/app_window.h"
#include "ui/aura/window.h"
#include "ui/base/ime/ash/ime_bridge.h"
#include "ui/base/ime/input_method.h"
#include "ui/base/ime/mojom/virtual_keyboard_types.mojom.h"
#include "ui/base/ime/text_input_client.h"
#include "ui/base/ui_base_features.h"
#include "ui/display/display.h"
#include "ui/display/screen.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/views/view.h"
#include "ui/views/widget/widget.h"
namespace {
// Returns the RenderWidgetHostView contained by |window|.
content::RenderWidgetHostView* GetHostViewForWindow(aura::Window* window) {
std::unique_ptr<content::RenderWidgetHostIterator> hosts(
content::RenderWidgetHost::GetRenderWidgetHosts());
while (content::RenderWidgetHost* host = hosts->GetNextHost()) {
content::RenderWidgetHostView* view = host->GetView();
if (view && window->Contains(view->GetNativeView()))
return view;
}
return nullptr;
}
ui::InputMethod* GetCurrentInputMethod() {
ash::IMEBridge* bridge = ash::IMEBridge::Get();
if (bridge && bridge->GetInputContextHandler())
return bridge->GetInputContextHandler()->GetInputMethod();
return nullptr;
}
} // namespace
ChromeKeyboardBoundsObserver::ChromeKeyboardBoundsObserver(
aura::Window* keyboard_window)
: keyboard_window_(keyboard_window) {
DCHECK(keyboard_window_);
ChromeKeyboardControllerClient::Get()->AddObserver(this);
}
ChromeKeyboardBoundsObserver::~ChromeKeyboardBoundsObserver() {
UpdateOccludedBounds(gfx::Rect());
RemoveAllObservedWindows();
ChromeKeyboardControllerClient::Get()->RemoveObserver(this);
CHECK(!views::WidgetObserver::IsInObserverList());
}
void ChromeKeyboardBoundsObserver::OnKeyboardVisibleBoundsChanged(
const gfx::Rect& screen_bounds) {
std::unique_ptr<content::RenderWidgetHostIterator> hosts(
content::RenderWidgetHost::GetRenderWidgetHosts());
while (content::RenderWidgetHost* host = hosts->GetNextHost()) {
content::RenderWidgetHostView* view = host->GetView();
if (view)
view->NotifyVirtualKeyboardOverlayRect(screen_bounds);
}
}
void ChromeKeyboardBoundsObserver::OnKeyboardOccludedBoundsChanged(
const gfx::Rect& screen_bounds) {
DVLOG(1) << "OnKeyboardOccludedBoundsChanged: " << screen_bounds.ToString();
UpdateOccludedBounds(
ChromeKeyboardControllerClient::Get()->IsKeyboardOverscrollEnabled()
? screen_bounds
: gfx::Rect());
}
void ChromeKeyboardBoundsObserver::UpdateOccludedBounds(
const gfx::Rect& screen_bounds) {
DVLOG(1) << "UpdateOccludedBounds: " << screen_bounds.ToString();
occluded_bounds_in_screen_ = screen_bounds;
std::unique_ptr<content::RenderWidgetHostIterator> hosts(
content::RenderWidgetHost::GetRenderWidgetHosts());
// If the keyboard is hidden or floating then reset the insets for all
// RenderWidgetHosts and remove observers.
if (occluded_bounds_in_screen_.IsEmpty()) {
while (content::RenderWidgetHost* host = hosts->GetNextHost()) {
content::RenderWidgetHostView* view = host->GetView();
if (view)
view->SetInsets(gfx::Insets());
}
RemoveAllObservedWindows();
return;
}
// Adjust the height of the viewport for visible windows on the primary
// display. TODO(kevers): Add EnvObserver to properly initialize insets if a
// window is created while the keyboard is visible.
while (content::RenderWidgetHost* host = hosts->GetNextHost()) {
content::RenderWidgetHostView* view = host->GetView();
// Can be null, e.g. if the RenderWidget is being destroyed or
// the render process crashed.
if (!view)
continue;
aura::Window* window = view->GetNativeView();
// Added while we determine if RenderWidgetHostViewChildFrame can be
// changed to always return a non-null value: https://crbug.com/644726.
// If we cannot guarantee a non-null value, then this may need to stay.
if (!window)
continue;
if (!ShouldWindowOverscroll(window))
continue;
UpdateInsets(window, view);
AddObservedWindow(window);
}
// Window reshape can race with the IME trying to keep the text input caret
// visible. Do this here because the widget bounds change happens before the
// occluded bounds are updated. https://crbug.com/937722
ui::InputMethod* ime = GetCurrentInputMethod();
if (ime && ime->GetTextInputClient())
ime->GetTextInputClient()->EnsureCaretNotInRect(occluded_bounds_in_screen_);
}
void ChromeKeyboardBoundsObserver::AddObservedWindow(aura::Window* window) {
// Only observe top level widget.
views::Widget* widget =
views::Widget::GetWidgetForNativeView(window->GetToplevelWindow());
if (!widget || widget->HasObserver(this))
return;
widget->AddObserver(this);
observed_widgets_.insert(widget);
}
void ChromeKeyboardBoundsObserver::RemoveAllObservedWindows() {
for (views::Widget* widget : observed_widgets_)
widget->RemoveObserver(this);
observed_widgets_.clear();
}
void ChromeKeyboardBoundsObserver::OnWidgetBoundsChanged(
views::Widget* widget,
const gfx::Rect& new_bounds) {
DVLOG(1) << "OnWidgetBoundsChanged: " << widget->GetName() << " "
<< new_bounds.ToString();
aura::Window* window = widget->GetNativeView();
if (!ShouldWindowOverscroll(window))
return;
content::RenderWidgetHostView* host_view = GetHostViewForWindow(window);
if (!host_view)
return; // Transition edge case
UpdateInsets(window, host_view);
}
void ChromeKeyboardBoundsObserver::OnWidgetDestroying(views::Widget* widget) {
if (widget->HasObserver(this))
widget->RemoveObserver(this);
observed_widgets_.erase(widget);
}
void ChromeKeyboardBoundsObserver::UpdateInsets(
aura::Window* window,
content::RenderWidgetHostView* view) {
if (view->GetVirtualKeyboardMode() ==
ui::mojom::VirtualKeyboardMode::kOverlaysContent) {
view->SetInsets(gfx::Insets());
return;
}
gfx::Rect view_bounds_in_screen = view->GetViewBounds();
if (!ShouldEnableInsets(window)) {
DVLOG(2) << "ResetInsets: " << window->GetName()
<< " Bounds: " << view_bounds_in_screen.ToString();
view->SetInsets(gfx::Insets());
return;
}
gfx::Rect intersect =
gfx::IntersectRects(view_bounds_in_screen, occluded_bounds_in_screen_);
int overlap = intersect.height();
DVLOG(2) << "SetInsets: " << window->GetName()
<< " Bounds: " << view_bounds_in_screen.ToString()
<< " Overlap: " << overlap;
if (overlap > 0 && overlap < view_bounds_in_screen.height())
view->SetInsets(gfx::Insets::TLBR(0, 0, overlap, 0));
else
view->SetInsets(gfx::Insets());
}
bool ChromeKeyboardBoundsObserver::ShouldWindowOverscroll(
aura::Window* window) {
// The virtual keyboard should not overscroll.
if (window->GetToplevelWindow() == keyboard_window_->GetToplevelWindow())
return false;
// IME windows should not overscroll.
extensions::AppWindow* app_window =
AppWindowRegistryUtil::GetAppWindowForNativeWindowAnyProfile(
window->GetToplevelWindow());
if (app_window && app_window->is_ime_window())
return false;
return true;
}
bool ChromeKeyboardBoundsObserver::ShouldEnableInsets(aura::Window* window) {
if (!keyboard_window_->IsVisible() ||
!ChromeKeyboardControllerClient::Get()->IsKeyboardOverscrollEnabled()) {
return false;
}
const auto* screen = display::Screen::GetScreen();
return screen->GetDisplayNearestWindow(window).id() ==
screen->GetDisplayNearestWindow(keyboard_window_).id();
}
Codebase Browser
chromium