From 62cfbad7377b4db2497fec6e88821a36a1b767fe Mon Sep 17 00:00:00 2001
From: "erg@google.com" <erg@google.com@0039d316-1c4b-4281-b951-d872f2087c98>
Date: Mon, 22 Aug 2011 22:26:53 +0000
Subject: (shlib failure) Revert 97750 - content: Move
render_widget_host_view_gtk to content/
This also moves some other files:
- OwnedWidgetGtk now goes in ui/base/gtk/
- TruncateString moved from l10n_util:: to ui::
- GtkIMContextWrapper has part of its code split into chrome/ (IDC using code goes in RenderViewContextMenu) and the rest go in content/ (gtk using code goes with GtkIMContextWrapper).
- gtk_key_bindings_handler[_unittest] now goes in content, as it's a utility class to RenderWidgetHostGtk.
BUG=93804
TEST=existing unit tests
Review URL: http://codereview.chromium.org/7669040
TBR=erg@google.com
Review URL: http://codereview.chromium.org/7708017
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@97756 0039d316-1c4b-4281-b951-d872f2087c98
---
.../renderer_host/gtk_im_context_wrapper.cc | 619 ----------
.../browser/renderer_host/gtk_im_context_wrapper.h | 197 ----
.../renderer_host/gtk_key_bindings_handler.cc | 325 ------
.../renderer_host/gtk_key_bindings_handler.h | 128 ---
.../gtk_key_bindings_handler_unittest.cc | 222 ----
.../renderer_host/render_widget_host_view_gtk.cc | 1210 --------------------
.../renderer_host/render_widget_host_view_gtk.h | 273 -----
7 files changed, 2974 deletions(-)
delete mode 100644 content/browser/renderer_host/gtk_im_context_wrapper.cc
delete mode 100644 content/browser/renderer_host/gtk_im_context_wrapper.h
delete mode 100644 content/browser/renderer_host/gtk_key_bindings_handler.cc
delete mode 100644 content/browser/renderer_host/gtk_key_bindings_handler.h
delete mode 100644 content/browser/renderer_host/gtk_key_bindings_handler_unittest.cc
delete mode 100644 content/browser/renderer_host/render_widget_host_view_gtk.cc
delete mode 100644 content/browser/renderer_host/render_widget_host_view_gtk.h
(limited to 'content/browser/renderer_host')
diff --git a/content/browser/renderer_host/gtk_im_context_wrapper.cc b/content/browser/renderer_host/gtk_im_context_wrapper.cc
deleted file mode 100644
index c5c4e03..0000000
--- a/content/browser/renderer_host/gtk_im_context_wrapper.cc
+++ /dev/null
@@ -1,619 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/browser/renderer_host/gtk_im_context_wrapper.h"
-
-#include <gdk/gdk.h>
-#include <gdk/gdkkeysyms.h>
-#include <gtk/gtk.h>
-
-#include <algorithm>
-
-#include "base/logging.h"
-#include "base/string_util.h"
-#include "base/utf_string_conversions.h"
-#include "content/browser/renderer_host/render_widget_host.h"
-#include "content/browser/renderer_host/render_widget_host_view_gtk.h"
-#include "content/common/native_web_keyboard_event.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
-#include "ui/base/gtk/gtk_im_context_util.h"
-#include "ui/gfx/gtk_util.h"
-#include "ui/gfx/rect.h"
-
-namespace {
-// Copied from third_party/WebKit/Source/WebCore/page/EventHandler.cpp
-//
-// Match key code of composition keydown event on windows.
-// IE sends VK_PROCESSKEY which has value 229;
-//
-// Please refer to following documents for detals:
-// - Virtual-Key Codes
-// http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx
-// - How the IME System Works
-// http://msdn.microsoft.com/en-us/library/cc194848.aspx
-// - ImmGetVirtualKey Function
-// http://msdn.microsoft.com/en-us/library/dd318570(VS.85).aspx
-const int kCompositionEventKeyCode = 229;
-} // namespace
-
-// ui::CompositionUnderline should be identical to
-// WebKit::WebCompositionUnderline, so that we can do reinterpret_cast safely.
-// TODO(suzhe): remove it after migrating all code in chrome to use
-// ui::CompositionUnderline.
-COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
- sizeof(WebKit::WebCompositionUnderline),
- ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
-
-GtkIMContextWrapper::GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view)
- : host_view_(host_view),
- context_(gtk_im_multicontext_new()),
- context_simple_(gtk_im_context_simple_new()),
- is_focused_(false),
- is_composing_text_(false),
- is_enabled_(false),
- is_in_key_event_handler_(false),
- is_composition_changed_(false),
- suppress_next_commit_(false),
- last_key_code_(0),
- last_key_was_up_(false),
- last_key_filtered_no_result_(false) {
- DCHECK(context_);
- DCHECK(context_simple_);
-
- // context_ and context_simple_ share the same callback handlers.
- // All data come from them are treated equally.
- // context_ is for full input method support.
- // context_simple_ is for supporting dead/compose keys when input method is
- // disabled by webkit, eg. in password input box.
- g_signal_connect(context_, "preedit_start",
- G_CALLBACK(HandlePreeditStartThunk), this);
- g_signal_connect(context_, "preedit_end",
- G_CALLBACK(HandlePreeditEndThunk), this);
- g_signal_connect(context_, "preedit_changed",
- G_CALLBACK(HandlePreeditChangedThunk), this);
- g_signal_connect(context_, "commit",
- G_CALLBACK(HandleCommitThunk), this);
-
- g_signal_connect(context_simple_, "preedit_start",
- G_CALLBACK(HandlePreeditStartThunk), this);
- g_signal_connect(context_simple_, "preedit_end",
- G_CALLBACK(HandlePreeditEndThunk), this);
- g_signal_connect(context_simple_, "preedit_changed",
- G_CALLBACK(HandlePreeditChangedThunk), this);
- g_signal_connect(context_simple_, "commit",
- G_CALLBACK(HandleCommitThunk), this);
-
- GtkWidget* widget = host_view->native_view();
- DCHECK(widget);
-
- g_signal_connect(widget, "realize",
- G_CALLBACK(HandleHostViewRealizeThunk), this);
- g_signal_connect(widget, "unrealize",
- G_CALLBACK(HandleHostViewUnrealizeThunk), this);
-
- // Set client window if the widget is already realized.
- HandleHostViewRealize(widget);
-}
-
-GtkIMContextWrapper::~GtkIMContextWrapper() {
- if (context_)
- g_object_unref(context_);
- if (context_simple_)
- g_object_unref(context_simple_);
-}
-
-void GtkIMContextWrapper::ProcessKeyEvent(GdkEventKey* event) {
- suppress_next_commit_ = false;
-
- // Indicates preedit-changed and commit signal handlers that we are
- // processing a key event.
- is_in_key_event_handler_ = true;
- // Reset this flag so that we can know if preedit is changed after
- // processing this key event.
- is_composition_changed_ = false;
- // Clear it so that we can know if something needs committing after
- // processing this key event.
- commit_text_.clear();
-
- // According to Document Object Model (DOM) Level 3 Events Specification
- // Appendix A: Keyboard events and key identifiers
- // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html:
- // The event sequence would be:
- // 1. keydown
- // 2. textInput
- // 3. keyup
- //
- // So keydown must be sent to webkit before sending input method result,
- // while keyup must be sent afterwards.
- // However on Windows, if a keydown event has been processed by IME, its
- // virtual keycode will be changed to VK_PROCESSKEY(0xE5) before being sent
- // to application.
- // To emulate the windows behavior as much as possible, we need to send the
- // key event to the GtkIMContext object first, and decide whether or not to
- // send the original key event to webkit according to the result from IME.
- //
- // If IME is enabled by WebKit, this event will be dispatched to context_
- // to get full IME support. Otherwise it'll be dispatched to
- // context_simple_, so that dead/compose keys can still work.
- //
- // It sends a "commit" signal when it has a character to be inserted
- // even when we use a US keyboard so that we can send a Char event
- // (or an IME event) to the renderer in our "commit"-signal handler.
- // We should send a KeyDown (or a KeyUp) event before dispatching this
- // event to the GtkIMContext object (and send a Char event) so that WebKit
- // can dispatch the JavaScript events in the following order: onkeydown(),
- // onkeypress(), and onkeyup(). (Many JavaScript pages assume this.)
- gboolean filtered = false;
- if (is_enabled_) {
- filtered = gtk_im_context_filter_keypress(context_, event);
- } else {
- filtered = gtk_im_context_filter_keypress(context_simple_, event);
- }
-
- // Reset this flag here, as it's only used in input method callbacks.
- is_in_key_event_handler_ = false;
-
- NativeWebKeyboardEvent wke(event);
-
- // If the key event was handled by the input method, then we need to prevent
- // RenderView::UnhandledKeyboardEvent() from processing it.
- // Otherwise unexpected result may occur. For example if it's a
- // Backspace key event, the browser may go back to previous page.
- // We just send all keyup events to the browser to avoid breaking the
- // browser's MENU key function, which is actually the only keyup event
- // handled in the browser.
- if (filtered && event->type == GDK_KEY_PRESS)
- wke.skip_in_browser = true;
-
- const int key_code = wke.windowsKeyCode;
- const bool has_result = HasInputMethodResult();
-
- // Send filtered keydown event before sending IME result.
- // In order to workaround http://crosbug.com/6582, we only send a filtered
- // keydown event if it generated any input method result.
- if (event->type == GDK_KEY_PRESS && filtered && has_result)
- ProcessFilteredKeyPressEvent(&wke);
-
- // Send IME results. In most cases, it's only available if the key event
- // is filtered by IME. But in rare cases, an unfiltered key event may also
- // generate IME results.
- // Any IME results generated by a unfiltered key down event must be sent
- // before the key down event, to avoid some tricky issues. For example,
- // when using latin-post input method, pressing 'a' then Backspace, may
- // generate following events in sequence:
- // 1. keydown 'a' (filtered)
- // 2. preedit changed to "a"
- // 3. keyup 'a' (unfiltered)
- // 4. keydown Backspace (unfiltered)
- // 5. commit "a"
- // 6. preedit end
- // 7. keyup Backspace (unfiltered)
- //
- // In this case, the input box will be in a strange state if keydown
- // Backspace is sent to webkit before commit "a" and preedit end.
- if (has_result)
- ProcessInputMethodResult(event, filtered);
-
- // Send unfiltered keydown and keyup events after sending IME result.
- if (event->type == GDK_KEY_PRESS && !filtered) {
- ProcessUnfilteredKeyPressEvent(&wke);
- } else if (event->type == GDK_KEY_RELEASE) {
- // In order to workaround http://crosbug.com/6582, we need to suppress
- // the keyup event if corresponding keydown event was suppressed, or
- // the last key event was a keyup event with the same keycode.
- const bool suppress = (last_key_code_ == key_code) &&
- (last_key_was_up_ || last_key_filtered_no_result_);
-
- if (!suppress)
- host_view_->ForwardKeyboardEvent(wke);
- }
-
- last_key_code_ = key_code;
- last_key_was_up_ = (event->type == GDK_KEY_RELEASE);
- last_key_filtered_no_result_ = (filtered && !has_result);
-}
-
-void GtkIMContextWrapper::UpdateInputMethodState(
- ui::TextInputType type,
- bool can_compose_inline,
- const gfx::Rect& caret_rect) {
- suppress_next_commit_ = false;
-
- // The renderer has updated its IME status.
- // Control the GtkIMContext object according to this status.
- if (!context_ || !is_focused_)
- return;
-
- DCHECK(!is_in_key_event_handler_);
-
- bool is_enabled = (type != ui::TEXT_INPUT_TYPE_NONE &&
- type != ui::TEXT_INPUT_TYPE_PASSWORD);
- if (is_enabled_ != is_enabled) {
- is_enabled_ = is_enabled;
- if (is_enabled)
- gtk_im_context_focus_in(context_);
- else
- gtk_im_context_focus_out(context_);
- }
-
- if (is_enabled) {
- // If the focused element supports inline rendering of composition text,
- // we receive and send related events to it. Otherwise, the events related
- // to the updates of composition text are directed to the candidate window.
- gtk_im_context_set_use_preedit(context_, can_compose_inline);
- // Updates the position of the IME candidate window.
- // The position sent from the renderer is a relative one, so we need to
- // attach the GtkIMContext object to this window before changing the
- // position.
- GdkRectangle cursor_rect(caret_rect.ToGdkRectangle());
- gtk_im_context_set_cursor_location(context_, &cursor_rect);
- }
-}
-
-void GtkIMContextWrapper::OnFocusIn() {
- if (is_focused_)
- return;
-
- // Tracks the focused state so that we can give focus to the
- // GtkIMContext object correctly later when IME is enabled by WebKit.
- is_focused_ = true;
-
- last_key_code_ = 0;
- last_key_was_up_ = false;
- last_key_filtered_no_result_ = false;
-
- // Notify the GtkIMContext object of this focus-in event only if IME is
- // enabled by WebKit.
- if (is_enabled_)
- gtk_im_context_focus_in(context_);
-
- // context_simple_ is always enabled.
- // Actually it doesn't care focus state at all.
- gtk_im_context_focus_in(context_simple_);
-
- // Enables RenderWidget's IME related events, so that we can be notified
- // when WebKit wants to enable or disable IME.
- if (host_view_->GetRenderWidgetHost())
- host_view_->GetRenderWidgetHost()->SetInputMethodActive(true);
-}
-
-void GtkIMContextWrapper::OnFocusOut() {
- if (!is_focused_)
- return;
-
- // Tracks the focused state so that we won't give focus to the
- // GtkIMContext object unexpectly.
- is_focused_ = false;
-
- // Notify the GtkIMContext object of this focus-out event only if IME is
- // enabled by WebKit.
- if (is_enabled_) {
- // To reset the GtkIMContext object and prevent data loss.
- ConfirmComposition();
- gtk_im_context_focus_out(context_);
- }
-
- // To make sure it'll be in correct state when focused in again.
- gtk_im_context_reset(context_simple_);
- gtk_im_context_focus_out(context_simple_);
-
- is_composing_text_ = false;
-
- // Disable RenderWidget's IME related events to save bandwidth.
- if (host_view_->GetRenderWidgetHost())
- host_view_->GetRenderWidgetHost()->SetInputMethodActive(false);
-}
-
-#if !defined(TOOLKIT_VIEWS)
-// Not defined for views because the views context menu doesn't
-// implement input methods yet.
-GtkWidget* GtkIMContextWrapper::BuildInputMethodsGtkMenu() {
- GtkWidget* submenu = gtk_menu_new();
- gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(context_),
- GTK_MENU_SHELL(submenu));
- return submenu;
-}
-#endif
-
-void GtkIMContextWrapper::CancelComposition() {
- if (!is_enabled_)
- return;
-
- DCHECK(!is_in_key_event_handler_);
-
- // To prevent any text from being committed when resetting the |context_|;
- is_in_key_event_handler_ = true;
- suppress_next_commit_ = true;
-
- gtk_im_context_reset(context_);
- gtk_im_context_reset(context_simple_);
-
- if (is_focused_) {
- // Some input methods may not honour the reset call. Focusing out/in the
- // |context_| to make sure it gets reset correctly.
- gtk_im_context_focus_out(context_);
- gtk_im_context_focus_in(context_);
- }
-
- is_composing_text_ = false;
- composition_.Clear();
- commit_text_.clear();
-
- is_in_key_event_handler_ = false;
-}
-
-bool GtkIMContextWrapper::NeedCommitByForwardingCharEvent() const {
- // If there is no composition text and has only one character to be
- // committed, then the character will be send to webkit as a Char event
- // instead of a confirmed composition text.
- // It should be fine to handle BMP character only, as non-BMP characters
- // can always be committed as confirmed composition text.
- return !is_composing_text_ && commit_text_.length() == 1;
-}
-
-bool GtkIMContextWrapper::HasInputMethodResult() const {
- return commit_text_.length() || is_composition_changed_;
-}
-
-void GtkIMContextWrapper::ProcessFilteredKeyPressEvent(
- NativeWebKeyboardEvent* wke) {
- // If IME has filtered this event, then replace virtual key code with
- // VK_PROCESSKEY. See comment in ProcessKeyEvent() for details.
- // It's only required for keydown events.
- // To emulate windows behavior, when input method is enabled, if the commit
- // text can be emulated by a Char event, then don't do this replacement.
- if (!NeedCommitByForwardingCharEvent()) {
- wke->windowsKeyCode = kCompositionEventKeyCode;
- // keyidentifier must be updated accordingly, otherwise this key event may
- // still be processed by webkit.
- wke->setKeyIdentifierFromWindowsKeyCode();
- }
- host_view_->ForwardKeyboardEvent(*wke);
-}
-
-void GtkIMContextWrapper::ProcessUnfilteredKeyPressEvent(
- NativeWebKeyboardEvent* wke) {
- // Send keydown event as it, because it's not filtered by IME.
- host_view_->ForwardKeyboardEvent(*wke);
-
- // IME is disabled by WebKit or the GtkIMContext object cannot handle
- // this key event.
- // This case is caused by two reasons:
- // 1. The given key event is a control-key event, (e.g. return, page up,
- // page down, tab, arrows, etc.) or;
- // 2. The given key event is not a control-key event but printable
- // characters aren't assigned to the event, (e.g. alt+d, etc.)
- // Create a Char event manually from this key event and send it to the
- // renderer when this Char event contains a printable character which
- // should be processed by WebKit.
- // isSystemKey will be set to true if this key event has Alt modifier,
- // see WebInputEventFactory::keyboardEvent() for details.
- if (wke->text[0]) {
- wke->type = WebKit::WebInputEvent::Char;
- wke->skip_in_browser = true;
- host_view_->ForwardKeyboardEvent(*wke);
- }
-}
-
-void GtkIMContextWrapper::ProcessInputMethodResult(const GdkEventKey* event,
- bool filtered) {
- RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
- if (!host)
- return;
-
- bool committed = false;
- // We do commit before preedit change, so that we can optimize some
- // unnecessary preedit changes.
- if (commit_text_.length()) {
- if (filtered && NeedCommitByForwardingCharEvent()) {
- // Send a Char event when we input a composed character without IMEs
- // so that this event is to be dispatched to onkeypress() handlers,
- // autofill, etc.
- // Only commit text generated by a filtered key down event can be sent
- // as a Char event, because a unfiltered key down event will probably
- // generate another Char event.
- // TODO(james.su@gmail.com): Is it necessary to support non BMP chars
- // here?
- NativeWebKeyboardEvent char_event(commit_text_[0],
- event->state,
- base::Time::Now().ToDoubleT());
- char_event.skip_in_browser = true;
- host_view_->ForwardKeyboardEvent(char_event);
- } else {
- committed = true;
- // Send an IME event.
- // Unlike a Char event, an IME event is NOT dispatched to onkeypress()
- // handlers or autofill.
- host->ImeConfirmComposition(commit_text_);
- // Set this flag to false, as this composition session has been
- // finished.
- is_composing_text_ = false;
- }
- }
-
- // Send preedit text only if it's changed.
- // If a text has been committed, then we don't need to send the empty
- // preedit text again.
- if (is_composition_changed_) {
- if (composition_.text.length()) {
- // Another composition session has been started.
- is_composing_text_ = true;
- // TODO(suzhe): convert both renderer_host and renderer to use
- // ui::CompositionText.
- const std::vector<WebKit::WebCompositionUnderline>& underlines =
- reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
- composition_.underlines);
- host->ImeSetComposition(composition_.text, underlines,
- composition_.selection.start(),
- composition_.selection.end());
- } else if (!committed) {
- host->ImeCancelComposition();
- }
- }
-}
-
-void GtkIMContextWrapper::ConfirmComposition() {
- if (!is_enabled_)
- return;
-
- DCHECK(!is_in_key_event_handler_);
-
- if (is_composing_text_) {
- if (host_view_->GetRenderWidgetHost())
- host_view_->GetRenderWidgetHost()->ImeConfirmComposition();
-
- // Reset the input method.
- CancelComposition();
- }
-}
-
-void GtkIMContextWrapper::HandleCommit(const string16& text) {
- if (suppress_next_commit_) {
- suppress_next_commit_ = false;
- return;
- }
-
- // Append the text to the buffer, because commit signal might be fired
- // multiple times when processing a key event.
- commit_text_.append(text);
- // Nothing needs to do, if it's currently in ProcessKeyEvent()
- // handler, which will send commit text to webkit later. Otherwise,
- // we need send it here.
- // It's possible that commit signal is fired without a key event, for
- // example when user input via a voice or handwriting recognition software.
- // In this case, the text must be committed directly.
- if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost()) {
- // Workaround http://crbug.com/45478 by sending fake key down/up events.
- SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
- host_view_->GetRenderWidgetHost()->ImeConfirmComposition(text);
- SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
- }
-}
-
-void GtkIMContextWrapper::HandlePreeditStart() {
- // Ignore preedit related signals triggered by CancelComposition() method.
- if (suppress_next_commit_)
- return;
- is_composing_text_ = true;
-}
-
-void GtkIMContextWrapper::HandlePreeditChanged(const gchar* text,
- PangoAttrList* attrs,
- int cursor_position) {
- // Ignore preedit related signals triggered by CancelComposition() method.
- if (suppress_next_commit_)
- return;
-
- // Don't set is_composition_changed_ to false if there is no change, because
- // this handler might be called multiple times with the same data.
- is_composition_changed_ = true;
- composition_.Clear();
-
- ui::ExtractCompositionTextFromGtkPreedit(text, attrs, cursor_position,
- &composition_);
-
- // TODO(suzhe): due to a bug of webkit, we currently can't use selection range
- // with composition string. See: https://bugs.webkit.org/show_bug.cgi?id=40805
- composition_.selection = ui::Range(cursor_position);
-
- // In case we are using a buggy input method which doesn't fire
- // "preedit_start" signal.
- if (composition_.text.length())
- is_composing_text_ = true;
-
- // Nothing needs to do, if it's currently in ProcessKeyEvent()
- // handler, which will send preedit text to webkit later.
- // Otherwise, we need send it here if it's been changed.
- if (!is_in_key_event_handler_ && is_composing_text_ &&
- host_view_->GetRenderWidgetHost()) {
- // Workaround http://crbug.com/45478 by sending fake key down/up events.
- SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
- // TODO(suzhe): convert both renderer_host and renderer to use
- // ui::CompositionText.
- const std::vector<WebKit::WebCompositionUnderline>& underlines =
- reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
- composition_.underlines);
- host_view_->GetRenderWidgetHost()->ImeSetComposition(
- composition_.text, underlines, composition_.selection.start(),
- composition_.selection.end());
- SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
- }
-}
-
-void GtkIMContextWrapper::HandlePreeditEnd() {
- if (composition_.text.length()) {
- // The composition session has been finished.
- composition_.Clear();
- is_composition_changed_ = true;
-
- // If there is still a preedit text when firing "preedit-end" signal,
- // we need inform webkit to clear it.
- // It's only necessary when it's not in ProcessKeyEvent ().
- if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost())
- host_view_->GetRenderWidgetHost()->ImeCancelComposition();
- }
-
- // Don't set is_composing_text_ to false here, because "preedit_end"
- // signal may be fired before "commit" signal.
-}
-
-void GtkIMContextWrapper::HandleHostViewRealize(GtkWidget* widget) {
- // We should only set im context's client window once, because when setting
- // client window.im context may destroy and recreate its internal states and
- // objects.
- if (widget->window) {
- gtk_im_context_set_client_window(context_, widget->window);
- gtk_im_context_set_client_window(context_simple_, widget->window);
- }
-}
-
-void GtkIMContextWrapper::HandleHostViewUnrealize() {
- gtk_im_context_set_client_window(context_, NULL);
- gtk_im_context_set_client_window(context_simple_, NULL);
-}
-
-void GtkIMContextWrapper::SendFakeCompositionKeyEvent(
- WebKit::WebInputEvent::Type type) {
- NativeWebKeyboardEvent fake_event;
- fake_event.windowsKeyCode = kCompositionEventKeyCode;
- fake_event.skip_in_browser = true;
- fake_event.type = type;
- host_view_->ForwardKeyboardEvent(fake_event);
-}
-
-void GtkIMContextWrapper::HandleCommitThunk(
- GtkIMContext* context, gchar* text, GtkIMContextWrapper* self) {
- self->HandleCommit(UTF8ToUTF16(text));
-}
-
-void GtkIMContextWrapper::HandlePreeditStartThunk(
- GtkIMContext* context, GtkIMContextWrapper* self) {
- self->HandlePreeditStart();
-}
-
-void GtkIMContextWrapper::HandlePreeditChangedThunk(
- GtkIMContext* context, GtkIMContextWrapper* self) {
- gchar* text = NULL;
- PangoAttrList* attrs = NULL;
- gint cursor_position = 0;
- gtk_im_context_get_preedit_string(context, &text, &attrs, &cursor_position);
- self->HandlePreeditChanged(text, attrs, cursor_position);
- g_free(text);
- pango_attr_list_unref(attrs);
-}
-
-void GtkIMContextWrapper::HandlePreeditEndThunk(
- GtkIMContext* context, GtkIMContextWrapper* self) {
- self->HandlePreeditEnd();
-}
-
-void GtkIMContextWrapper::HandleHostViewRealizeThunk(
- GtkWidget* widget, GtkIMContextWrapper* self) {
- self->HandleHostViewRealize(widget);
-}
-
-void GtkIMContextWrapper::HandleHostViewUnrealizeThunk(
- GtkWidget* widget, GtkIMContextWrapper* self) {
- self->HandleHostViewUnrealize();
-}
diff --git a/content/browser/renderer_host/gtk_im_context_wrapper.h b/content/browser/renderer_host/gtk_im_context_wrapper.h
deleted file mode 100644
index a783296..0000000
--- a/content/browser/renderer_host/gtk_im_context_wrapper.h
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CONTENT_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
-#define CONTENT_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
-#pragma once
-
-#include <gdk/gdk.h>
-#include <pango/pango-attributes.h>
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/gtest_prod_util.h"
-#include "base/string16.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
-#include "ui/base/ime/composition_text.h"
-#include "ui/base/ime/text_input_type.h"
-
-namespace gfx {
-class Rect;
-}
-
-class RenderWidgetHostViewGtk;
-struct NativeWebKeyboardEvent;
-typedef struct _GtkIMContext GtkIMContext;
-typedef struct _GtkWidget GtkWidget;
-
-// This class is a convenience wrapper for GtkIMContext.
-// It creates and manages two GtkIMContext instances, one is GtkIMMulticontext,
-// for plain text input box, another is GtkIMContextSimple, for password input
-// box.
-//
-// This class is in charge of dispatching key events to these two GtkIMContext
-// instances and handling signals emitted by them. Key events then will be
-// forwarded to renderer along with input method results via corresponding host
-// view.
-//
-// This class is used solely by RenderWidgetHostViewGtk.
-class GtkIMContextWrapper {
- public:
- explicit GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view);
- ~GtkIMContextWrapper();
-
- // Processes a gdk key event received by |host_view|.
- void ProcessKeyEvent(GdkEventKey* event);
-
- void UpdateInputMethodState(ui::TextInputType type,
- bool can_compose_inline,
- const gfx::Rect& caret_rect);
- void OnFocusIn();
- void OnFocusOut();
- bool is_focused() const { return is_focused_; }
-
-#if !defined(TOOLKIT_VIEWS)
- // Not defined for views because the views context menu doesn't
- // implement input methods yet.
- GtkWidget* BuildInputMethodsGtkMenu();
-#endif
-
- void CancelComposition();
-
- void ConfirmComposition();
-
- private:
- // Check if a text needs commit by forwarding a char event instead of
- // by confirming as a composition text.
- bool NeedCommitByForwardingCharEvent() const;
-
- // Check if the input method returned any result, eg. preedit and commit text.
- bool HasInputMethodResult() const;
-
- void ProcessFilteredKeyPressEvent(NativeWebKeyboardEvent* wke);
- void ProcessUnfilteredKeyPressEvent(NativeWebKeyboardEvent* wke);
-
- // Processes result returned from input method after filtering a key event.
- // |filtered| indicates if the key event was filtered by the input method.
- void ProcessInputMethodResult(const GdkEventKey* event, bool filtered);
-
- // Real code of "commit" signal handler.
- void HandleCommit(const string16& text);
-
- // Real code of "preedit-start" signal handler.
- void HandlePreeditStart();
-
- // Real code of "preedit-changed" signal handler.
- void HandlePreeditChanged(const gchar* text,
- PangoAttrList* attrs,
- int cursor_position);
-
- // Real code of "preedit-end" signal handler.
- void HandlePreeditEnd();
-
- // Real code of "realize" signal handler, used for setting im context's client
- // window.
- void HandleHostViewRealize(GtkWidget* widget);
-
- // Real code of "unrealize" signal handler, used for unsetting im context's
- // client window.
- void HandleHostViewUnrealize();
-
- // Sends a fake composition key event with specified event type. A composition
- // key event is a key event with special key code 229.
- void SendFakeCompositionKeyEvent(WebKit::WebInputEvent::Type type);
-
- // Signal handlers of GtkIMContext object.
- static void HandleCommitThunk(GtkIMContext* context, gchar* text,
- GtkIMContextWrapper* self);
- static void HandlePreeditStartThunk(GtkIMContext* context,
- GtkIMContextWrapper* self);
- static void HandlePreeditChangedThunk(GtkIMContext* context,
- GtkIMContextWrapper* self);
- static void HandlePreeditEndThunk(GtkIMContext* context,
- GtkIMContextWrapper* self);
-
- // Signal handlers connecting to |host_view_|'s native view widget.
- static void HandleHostViewRealizeThunk(GtkWidget* widget,
- GtkIMContextWrapper* self);
- static void HandleHostViewUnrealizeThunk(GtkWidget* widget,
- GtkIMContextWrapper* self);
-
- // The parent object.
- RenderWidgetHostViewGtk* host_view_;
-
- // The GtkIMContext object.
- // In terms of the DOM event specification Appendix A
- // <http://www.w3.org/TR/DOM-Level-3-Events/keyset.html>,
- // GTK uses a GtkIMContext object for the following two purposes:
- // 1. Composing Latin characters (A.1.2), and;
- // 2. Composing CJK characters with an IME (A.1.3).
- // Many JavaScript pages assume composed Latin characters are dispatched to
- // their onkeypress() handlers but not dispatched CJK characters composed
- // with an IME. To emulate this behavior, we should monitor the status of
- // this GtkIMContext object and prevent sending Char events when a
- // GtkIMContext object sends a "commit" signal with the CJK characters
- // composed by an IME.
- GtkIMContext* context_;
-
- // A GtkIMContextSimple object, for supporting dead/compose keys when input
- // method is disabled, eg. in password input box.
- GtkIMContext* context_simple_;
-
- // Whether or not this widget is focused.
- bool is_focused_;
-
- // Whether or not the above GtkIMContext is composing a text with an IME.
- // This flag is used in "commit" signal handler of the GtkIMContext object,
- // which determines how to submit the result text to WebKit according to this
- // flag.
- // If this flag is true or there are more than one characters in the result,
- // then the result text will be committed to WebKit as a confirmed
- // composition. Otherwise, it'll be forwarded as a key event.
- //
- // The GtkIMContext object sends a "preedit_start" before it starts composing
- // a text and a "preedit_end" signal after it finishes composing it.
- // "preedit_start" signal is monitored to turn it on.
- // We don't monitor "preedit_end" signal to turn it off, because an input
- // method may fire "preedit_end" signal before "commit" signal.
- // A buggy input method may not fire "preedit_start" and/or "preedit_end"
- // at all, so this flag will also be set to true when "preedit_changed" signal
- // is fired with non-empty preedit text.
- bool is_composing_text_;
-
- // Whether or not the IME is enabled.
- bool is_enabled_;
-
- // Whether or not it's currently running inside key event handler.
- // If it's true, then preedit-changed and commit handler will backup the
- // preedit or commit text instead of sending them down to webkit.
- // key event handler will send them later.
- bool is_in_key_event_handler_;
-
- // The most recent composition text information retrieved from context_;
- ui::CompositionText composition_;
-
- // Whether or not the composition has been changed since last key event.
- bool is_composition_changed_;
-
- // Stores a copy of the most recent commit text received by commit signal
- // handler.
- string16 commit_text_;
-
- // If it's true then the next "commit" signal will be suppressed.
- // It's only used to workaround http://crbug.com/50485.
- // TODO(suzhe): Remove it after input methods get fixed.
- bool suppress_next_commit_;
-
- // Information of the last key event, for working around
- // http://crosbug.com/6582
- int last_key_code_;
- bool last_key_was_up_;
- bool last_key_filtered_no_result_;
-
- DISALLOW_COPY_AND_ASSIGN(GtkIMContextWrapper);
-};
-
-#endif // CONTENT_BROWSER_RENDERER_HOST_GTK_IM_CONTEXT_WRAPPER_H_
diff --git a/content/browser/renderer_host/gtk_key_bindings_handler.cc b/content/browser/renderer_host/gtk_key_bindings_handler.cc
deleted file mode 100644
index 94e3234..0000000
--- a/content/browser/renderer_host/gtk_key_bindings_handler.cc
+++ /dev/null
@@ -1,325 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/browser/renderer_host/gtk_key_bindings_handler.h"
-
-#include <gdk/gdkkeysyms.h>
-
-#include <string>
-
-#include "base/logging.h"
-#include "base/string_util.h"
-#include "content/common/native_web_keyboard_event.h"
-
-GtkKeyBindingsHandler::GtkKeyBindingsHandler(GtkWidget* parent_widget)
- : handler_(CreateNewHandler()) {
- DCHECK(GTK_IS_FIXED(parent_widget));
- // We need add the |handler_| object into gtk widget hierarchy, so that
- // gtk_bindings_activate_event() can find correct display and keymaps from
- // the |handler_| object.
- gtk_fixed_put(GTK_FIXED(parent_widget), handler_.get(), -1, -1);
-}
-
-GtkKeyBindingsHandler::~GtkKeyBindingsHandler() {
- handler_.Destroy();
-}
-
-bool GtkKeyBindingsHandler::Match(const NativeWebKeyboardEvent& wke,
- EditCommands* edit_commands) {
- if (wke.type == WebKit::WebInputEvent::Char || !wke.os_event)
- return false;
-
- edit_commands_.clear();
- // If this key event matches a predefined key binding, corresponding signal
- // will be emitted.
- gtk_bindings_activate_event(GTK_OBJECT(handler_.get()), wke.os_event);
-
- bool matched = !edit_commands_.empty();
- if (edit_commands)
- edit_commands->swap(edit_commands_);
- return matched;
-}
-
-GtkWidget* GtkKeyBindingsHandler::CreateNewHandler() {
- Handler* handler =
- static_cast<Handler*>(g_object_new(HandlerGetType(), NULL));
-
- handler->owner = this;
-
- // We don't need to show the |handler| object on screen, so set its size to
- // zero.
- gtk_widget_set_size_request(GTK_WIDGET(handler), 0, 0);
-
- // Prevents it from handling any events by itself.
- gtk_widget_set_sensitive(GTK_WIDGET(handler), FALSE);
- gtk_widget_set_events(GTK_WIDGET(handler), 0);
- gtk_widget_set_can_focus(GTK_WIDGET(handler), TRUE);
-
-#if !GTK_CHECK_VERSION(2, 14, 0)
- // "move-focus", "move-viewport", "select-all" and "toggle-cursor-visible"
- // have no corresponding virtual methods. Prior to glib 2.18 (gtk 2.14),
- // there is no way to override the default class handler of a signal.
- // So we need hook these signal explicitly.
- g_signal_connect(handler, "move-focus", G_CALLBACK(MoveFocus), NULL);
- g_signal_connect(handler, "move-viewport", G_CALLBACK(MoveViewport), NULL);
- g_signal_connect(handler, "select-all", G_CALLBACK(SelectAll), NULL);
- g_signal_connect(handler, "toggle-cursor-visible",
- G_CALLBACK(ToggleCursorVisible), NULL);
-#endif
- return GTK_WIDGET(handler);
-}
-
-void GtkKeyBindingsHandler::EditCommandMatched(
- const std::string& name, const std::string& value) {
- edit_commands_.push_back(EditCommand(name, value));
-}
-
-void GtkKeyBindingsHandler::HandlerInit(Handler *self) {
- self->owner = NULL;
-}
-
-void GtkKeyBindingsHandler::HandlerClassInit(HandlerClass *klass) {
- GtkTextViewClass* text_view_class = GTK_TEXT_VIEW_CLASS(klass);
- GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
-
- // Overrides all virtual methods related to editor key bindings.
- text_view_class->backspace = BackSpace;
- text_view_class->copy_clipboard = CopyClipboard;
- text_view_class->cut_clipboard = CutClipboard;
- text_view_class->delete_from_cursor = DeleteFromCursor;
- text_view_class->insert_at_cursor = InsertAtCursor;
- text_view_class->move_cursor = MoveCursor;
- text_view_class->paste_clipboard = PasteClipboard;
- text_view_class->set_anchor = SetAnchor;
- text_view_class->toggle_overwrite = ToggleOverwrite;
- widget_class->show_help = ShowHelp;
-
-#if GTK_CHECK_VERSION(2, 14, 0)
- // "move-focus", "move-viewport", "select-all" and "toggle-cursor-visible"
- // have no corresponding virtual methods. Since glib 2.18 (gtk 2.14),
- // g_signal_override_class_handler() is introduced to override a signal
- // handler.
- g_signal_override_class_handler("move-focus",
- G_TYPE_FROM_CLASS(klass),
- G_CALLBACK(MoveFocus));
-
- g_signal_override_class_handler("move-viewport",
- G_TYPE_FROM_CLASS(klass),
- G_CALLBACK(MoveViewport));
-
- g_signal_override_class_handler("select-all",
- G_TYPE_FROM_CLASS(klass),
- G_CALLBACK(SelectAll));
-
- g_signal_override_class_handler("toggle-cursor-visible",
- G_TYPE_FROM_CLASS(klass),
- G_CALLBACK(ToggleCursorVisible));
-#endif
-}
-
-GType GtkKeyBindingsHandler::HandlerGetType() {
- static volatile gsize type_id_volatile = 0;
- if (g_once_init_enter(&type_id_volatile)) {
- GType type_id = g_type_register_static_simple(
- GTK_TYPE_TEXT_VIEW,
- g_intern_static_string("GtkKeyBindingsHandler"),
- sizeof(HandlerClass),
- reinterpret_cast<GClassInitFunc>(HandlerClassInit),
- sizeof(Handler),
- reinterpret_cast<GInstanceInitFunc>(HandlerInit),
- static_cast<GTypeFlags>(0));
- g_once_init_leave(&type_id_volatile, type_id);
- }
- return type_id_volatile;
-}
-
-GtkKeyBindingsHandler* GtkKeyBindingsHandler::GetHandlerOwner(
- GtkTextView* text_view) {
- Handler* handler = G_TYPE_CHECK_INSTANCE_CAST(
- text_view, HandlerGetType(), Handler);
- DCHECK(handler);
- return handler->owner;
-}
-
-void GtkKeyBindingsHandler::BackSpace(GtkTextView* text_view) {
- GetHandlerOwner(text_view)->EditCommandMatched("DeleteBackward", "");
-}
-
-void GtkKeyBindingsHandler::CopyClipboard(GtkTextView* text_view) {
- GetHandlerOwner(text_view)->EditCommandMatched("Copy", "");
-}
-
-void GtkKeyBindingsHandler::CutClipboard(GtkTextView* text_view) {
- GetHandlerOwner(text_view)->EditCommandMatched("Cut", "");
-}
-
-void GtkKeyBindingsHandler::DeleteFromCursor(
- GtkTextView* text_view, GtkDeleteType type, gint count) {
- if (!count)
- return;
-
- const char *commands[3] = { NULL, NULL, NULL };
- switch (type) {
- case GTK_DELETE_CHARS:
- commands[0] = (count > 0 ? "DeleteForward" : "DeleteBackward");
- break;
- case GTK_DELETE_WORD_ENDS:
- commands[0] = (count > 0 ? "DeleteWordForward" : "DeleteWordBackward");
- break;
- case GTK_DELETE_WORDS:
- if (count > 0) {
- commands[0] = "MoveWordForward";
- commands[1] = "DeleteWordBackward";
- } else {
- commands[0] = "MoveWordBackward";
- commands[1] = "DeleteWordForward";
- }
- break;
- case GTK_DELETE_DISPLAY_LINES:
- commands[0] = "MoveToBeginningOfLine";
- commands[1] = "DeleteToEndOfLine";
- break;
- case GTK_DELETE_DISPLAY_LINE_ENDS:
- commands[0] = (count > 0 ? "DeleteToEndOfLine" :
- "DeleteToBeginningOfLine");
- break;
- case GTK_DELETE_PARAGRAPH_ENDS:
- commands[0] = (count > 0 ? "DeleteToEndOfParagraph" :
- "DeleteToBeginningOfParagraph");
- break;
- case GTK_DELETE_PARAGRAPHS:
- commands[0] = "MoveToBeginningOfParagraph";
- commands[1] = "DeleteToEndOfParagraph";
- break;
- default:
- // GTK_DELETE_WHITESPACE has no corresponding editor command.
- return;
- }
-
- GtkKeyBindingsHandler* owner = GetHandlerOwner(text_view);
- if (count < 0)
- count = -count;
- for (; count > 0; --count) {
- for (const char* const* p = commands; *p; ++p)
- owner->EditCommandMatched(*p, "");
- }
-}
-
-void GtkKeyBindingsHandler::InsertAtCursor(GtkTextView* text_view,
- const gchar* str) {
- if (str && *str)
- GetHandlerOwner(text_view)->EditCommandMatched("InsertText", str);
-}
-
-void GtkKeyBindingsHandler::MoveCursor(
- GtkTextView* text_view, GtkMovementStep step, gint count,
- gboolean extend_selection) {
- if (!count)
- return;
-
- std::string command;
- switch (step) {
- case GTK_MOVEMENT_LOGICAL_POSITIONS:
- command = (count > 0 ? "MoveForward" : "MoveBackward");
- break;
- case GTK_MOVEMENT_VISUAL_POSITIONS:
- command = (count > 0 ? "MoveRight" : "MoveLeft");
- break;
- case GTK_MOVEMENT_WORDS:
- command = (count > 0 ? "MoveWordForward" : "MoveWordBackward");
- break;
- case GTK_MOVEMENT_DISPLAY_LINES:
- command = (count > 0 ? "MoveDown" : "MoveUp");
- break;
- case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
- command = (count > 0 ? "MoveToEndOfLine" : "MoveToBeginningOfLine");
- break;
- case GTK_MOVEMENT_PARAGRAPH_ENDS:
- command = (count > 0 ? "MoveToEndOfParagraph" :
- "MoveToBeginningOfParagraph");
- break;
- case GTK_MOVEMENT_PAGES:
- command = (count > 0 ? "MovePageDown" : "MovePageUp");
- break;
- case GTK_MOVEMENT_BUFFER_ENDS:
- command = (count > 0 ? "MoveToEndOfDocument" :
- "MoveToBeginningOfDocument");
- break;
- default:
- // GTK_MOVEMENT_PARAGRAPHS and GTK_MOVEMENT_HORIZONTAL_PAGES have
- // no corresponding editor commands.
- return;
- }
-
- GtkKeyBindingsHandler* owner = GetHandlerOwner(text_view);
- if (extend_selection)
- command.append("AndModifySelection");
- if (count < 0)
- count = -count;
- for (; count > 0; --count)
- owner->EditCommandMatched(command, "");
-}
-
-void GtkKeyBindingsHandler::MoveViewport(
- GtkTextView* text_view, GtkScrollStep step, gint count) {
- // Not supported by webkit.
-#if !GTK_CHECK_VERSION(2, 14, 0)
- // Before gtk 2.14.0, there is no way to override a non-virtual default signal
- // handler, so we need stop the signal emission explicitly to prevent the
- // default handler from being executed.
- g_signal_stop_emission_by_name(text_view, "move-viewport");
-#endif
-}
-
-void GtkKeyBindingsHandler::PasteClipboard(GtkTextView* text_view) {
- GetHandlerOwner(text_view)->EditCommandMatched("Paste", "");
-}
-
-void GtkKeyBindingsHandler::SelectAll(GtkTextView* text_view, gboolean select) {
- if (select)
- GetHandlerOwner(text_view)->EditCommandMatched("SelectAll", "");
- else
- GetHandlerOwner(text_view)->EditCommandMatched("Unselect", "");
-#if !GTK_CHECK_VERSION(2, 14, 0)
- // Before gtk 2.14.0, there is no way to override a non-virtual default signal
- // handler, so we need stop the signal emission explicitly to prevent the
- // default handler from being executed.
- g_signal_stop_emission_by_name(text_view, "select-all");
-#endif
-}
-
-void GtkKeyBindingsHandler::SetAnchor(GtkTextView* text_view) {
- GetHandlerOwner(text_view)->EditCommandMatched("SetMark", "");
-}
-
-void GtkKeyBindingsHandler::ToggleCursorVisible(GtkTextView* text_view) {
- // Not supported by webkit.
-#if !GTK_CHECK_VERSION(2, 14, 0)
- // Before gtk 2.14.0, there is no way to override a non-virtual default signal
- // handler, so we need stop the signal emission explicitly to prevent the
- // default handler from being executed.
- g_signal_stop_emission_by_name(text_view, "toggle-cursor-visible");
-#endif
-}
-
-void GtkKeyBindingsHandler::ToggleOverwrite(GtkTextView* text_view) {
- // Not supported by webkit.
-}
-
-gboolean GtkKeyBindingsHandler::ShowHelp(GtkWidget* widget,
- GtkWidgetHelpType arg1) {
- // Just for disabling the default handler.
- return FALSE;
-}
-
-void GtkKeyBindingsHandler::MoveFocus(GtkWidget* widget,
- GtkDirectionType arg1) {
- // Just for disabling the default handler.
-#if !GTK_CHECK_VERSION(2, 14, 0)
- // Before gtk 2.14.0, there is no way to override a non-virtual default signal
- // handler, so we need stop the signal emission explicitly to prevent the
- // default handler from being executed.
- g_signal_stop_emission_by_name(widget, "move-focus");
-#endif
-}
diff --git a/content/browser/renderer_host/gtk_key_bindings_handler.h b/content/browser/renderer_host/gtk_key_bindings_handler.h
deleted file mode 100644
index 071a3b1..0000000
--- a/content/browser/renderer_host/gtk_key_bindings_handler.h
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CONTENT_BROWSER_RENDERER_HOST_GTK_KEY_BINDINGS_HANDLER_H_
-#define CONTENT_BROWSER_RENDERER_HOST_GTK_KEY_BINDINGS_HANDLER_H_
-#pragma once
-
-#include <gtk/gtk.h>
-
-#include <string>
-
-#include "content/common/edit_command.h"
-#include "ui/base/gtk/owned_widget_gtk.h"
-
-struct NativeWebKeyboardEvent;
-
-// This class is a convenience class for handling editor key bindings defined
-// in gtk keyboard theme.
-// In gtk, only GtkEntry and GtkTextView support customizing editor key bindings
-// through keyboard theme. And in gtk keyboard theme definition file, each key
-// binding must be bound to a specific class or object. So existing keyboard
-// themes only define editor key bindings exactly for GtkEntry and GtkTextView.
-// Then, the only way for us to intercept editor key bindings defined in
-// keyboard theme, is to create a GtkEntry or GtkTextView object and call
-// gtk_bindings_activate_event() against it for the key events. If a key event
-// matches a predefined key binding, corresponding signal will be emitted.
-// GtkTextView is used here because it supports more key bindings than GtkEntry,
-// but in order to minimize the side effect of using a GtkTextView object, a new
-// class derived from GtkTextView is used, which overrides all signals related
-// to key bindings, to make sure GtkTextView won't receive them.
-//
-// See third_party/WebKit/Source/WebCore/editing/EditorCommand.cpp for detailed
-// definition of webkit edit commands.
-// See webkit/glue/editor_client_impl.cc for key bindings predefined in our
-// webkit glue.
-class GtkKeyBindingsHandler {
- public:
- explicit GtkKeyBindingsHandler(GtkWidget* parent_widget);
- ~GtkKeyBindingsHandler();
-
- // Matches a key event against predefined gtk key bindings, false will be
- // returned if the key event doesn't correspond to a predefined key binding.
- // Edit commands matched with |wke| will be stored in |edit_commands|.
- bool Match(const NativeWebKeyboardEvent& wke, EditCommands* edit_commands);
-
- private:
- // Object structure of Handler class, which is derived from GtkTextView.
- struct Handler {
- GtkTextView parent_object;
- GtkKeyBindingsHandler *owner;
- };
-
- // Class structure of Handler class.
- struct HandlerClass {
- GtkTextViewClass parent_class;
- };
-
- // Creates a new instance of Handler class.
- GtkWidget* CreateNewHandler();
-
- // Adds an edit command to the key event.
- void EditCommandMatched(const std::string& name, const std::string& value);
-
- // Initializes Handler structure.
- static void HandlerInit(Handler *self);
-
- // Initializes HandlerClass structure.
- static void HandlerClassInit(HandlerClass *klass);
-
- // Registeres Handler class to GObject type system and return its type id.
- static GType HandlerGetType();
-
- // Gets the GtkKeyBindingsHandler object which owns the Handler object.
- static GtkKeyBindingsHandler* GetHandlerOwner(GtkTextView* text_view);
-
- // Handler of "backspace" signal.
- static void BackSpace(GtkTextView* text_view);
-
- // Handler of "copy-clipboard" signal.
- static void CopyClipboard(GtkTextView* text_view);
-
- // Handler of "cut-clipboard" signal.
- static void CutClipboard(GtkTextView* text_view);
-
- // Handler of "delete-from-cursor" signal.
- static void DeleteFromCursor(GtkTextView* text_view, GtkDeleteType type,
- gint count);
-
- // Handler of "insert-at-cursor" signal.
- static void InsertAtCursor(GtkTextView* text_view, const gchar* str);
-
- // Handler of "move-cursor" signal.
- static void MoveCursor(GtkTextView* text_view, GtkMovementStep step,
- gint count, gboolean extend_selection);
-
- // Handler of "move-viewport" signal.
- static void MoveViewport(GtkTextView* text_view, GtkScrollStep step,
- gint count);
-
- // Handler of "paste-clipboard" signal.
- static void PasteClipboard(GtkTextView* text_view);
-
- // Handler of "select-all" signal.
- static void SelectAll(GtkTextView* text_view, gboolean select);
-
- // Handler of "set-anchor" signal.
- static void SetAnchor(GtkTextView* text_view);
-
- // Handler of "toggle-cursor-visible" signal.
- static void ToggleCursorVisible(GtkTextView* text_view);
-
- // Handler of "toggle-overwrite" signal.
- static void ToggleOverwrite(GtkTextView* text_view);
-
- // Handler of "show-help" signal.
- static gboolean ShowHelp(GtkWidget* widget, GtkWidgetHelpType arg1);
-
- // Handler of "move-focus" signal.
- static void MoveFocus(GtkWidget* widget, GtkDirectionType arg1);
-
- OwnedWidgetGtk handler_;
-
- // Buffer to store the match results.
- EditCommands edit_commands_;
-};
-
-#endif // CONTENT_BROWSER_RENDERER_HOST_GTK_KEY_BINDINGS_HANDLER_H_
diff --git a/content/browser/renderer_host/gtk_key_bindings_handler_unittest.cc b/content/browser/renderer_host/gtk_key_bindings_handler_unittest.cc
deleted file mode 100644
index 10c824f..0000000
--- a/content/browser/renderer_host/gtk_key_bindings_handler_unittest.cc
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/browser/renderer_host/gtk_key_bindings_handler.h"
-
-#include <gdk/gdkkeysyms.h>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/file_util.h"
-#include "base/logging.h"
-#include "base/path_service.h"
-#include "base/string_util.h"
-#include "content/common/content_paths.h"
-#include "content/common/edit_command.h"
-#include "content/common/native_web_keyboard_event.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-class GtkKeyBindingsHandlerTest : public testing::Test {
- protected:
- struct EditCommand {
- const char* name;
- const char* value;
- };
-
- GtkKeyBindingsHandlerTest()
- : window_(gtk_window_new(GTK_WINDOW_TOPLEVEL)),
- handler_(NULL) {
- FilePath gtkrc;
- PathService::Get(content::DIR_TEST_DATA, >krc);
- gtkrc = gtkrc.AppendASCII("gtk_key_bindings_test_gtkrc");
- EXPECT_TRUE(file_util::PathExists(gtkrc));
-
- gtk_rc_parse(gtkrc.value().c_str());
-
- GtkWidget* fixed = gtk_fixed_new();
- handler_ = new GtkKeyBindingsHandler(fixed);
- gtk_container_add(GTK_CONTAINER(window_), fixed);
- gtk_widget_show(fixed);
- gtk_widget_show(window_);
- }
- ~GtkKeyBindingsHandlerTest() {
- gtk_widget_destroy(window_);
- delete handler_;
- }
-
- NativeWebKeyboardEvent NewNativeWebKeyboardEvent(guint keyval, guint state) {
- GdkKeymap* keymap =
- gdk_keymap_get_for_display(gtk_widget_get_display(window_));
-
- GdkKeymapKey *keys = NULL;
- gint n_keys = 0;
- if (gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &n_keys)) {
- GdkEventKey event;
- event.type = GDK_KEY_PRESS;
- event.window = NULL;
- event.send_event = 0;
- event.time = 0;
- event.state = state;
- event.keyval = keyval;
- event.length = 0;
- event.string = NULL;
- event.hardware_keycode = keys[0].keycode;
- event.group = keys[0].group;
- event.is_modifier = 0;
- g_free(keys);
- return NativeWebKeyboardEvent(&event);
- }
- LOG(ERROR) << "Failed to create key event for keyval:" << keyval;
- return NativeWebKeyboardEvent();
- }
-
- void TestKeyBinding(const NativeWebKeyboardEvent& event,
- const EditCommand expected_result[],
- size_t size) {
- EditCommands result;
- ASSERT_TRUE(handler_->Match(event, &result));
- ASSERT_EQ(size, result.size());
- for (size_t i = 0; i < size; ++i) {
- ASSERT_STREQ(expected_result[i].name, result[i].name.c_str());
- ASSERT_STREQ(expected_result[i].value, result[i].value.c_str());
- }
- }
-
- protected:
- GtkWidget* window_;
- GtkKeyBindingsHandler* handler_;
-};
-
-TEST_F(GtkKeyBindingsHandlerTest, MoveCursor) {
- static const EditCommand kEditCommands[] = {
- // "move-cursor" (logical-positions, -2, 0)
- { "MoveBackward", "" },
- { "MoveBackward", "" },
- // "move-cursor" (logical-positions, 2, 0)
- { "MoveForward", "" },
- { "MoveForward", "" },
- // "move-cursor" (visual-positions, -1, 1)
- { "MoveLeftAndModifySelection", "" },
- // "move-cursor" (visual-positions, 1, 1)
- { "MoveRightAndModifySelection", "" },
- // "move-cursor" (words, -1, 0)
- { "MoveWordBackward", "" },
- // "move-cursor" (words, 1, 0)
- { "MoveWordForward", "" },
- // "move-cursor" (display-lines, -1, 0)
- { "MoveUp", "" },
- // "move-cursor" (display-lines, 1, 0)
- { "MoveDown", "" },
- // "move-cursor" (display-line-ends, -1, 0)
- { "MoveToBeginningOfLine", "" },
- // "move-cursor" (display-line-ends, 1, 0)
- { "MoveToEndOfLine", "" },
- // "move-cursor" (paragraph-ends, -1, 0)
- { "MoveToBeginningOfParagraph", "" },
- // "move-cursor" (paragraph-ends, 1, 0)
- { "MoveToEndOfParagraph", "" },
- // "move-cursor" (pages, -1, 0)
- { "MovePageUp", "" },
- // "move-cursor" (pages, 1, 0)
- { "MovePageDown", "" },
- // "move-cursor" (buffer-ends, -1, 0)
- { "MoveToBeginningOfDocument", "" },
- // "move-cursor" (buffer-ends, 1, 0)
- { "MoveToEndOfDocument", "" }
- };
-
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_1, GDK_CONTROL_MASK),
- kEditCommands, arraysize(kEditCommands));
-}
-
-TEST_F(GtkKeyBindingsHandlerTest, DeleteFromCursor) {
- static const EditCommand kEditCommands[] = {
- // "delete-from-cursor" (chars, -2)
- { "DeleteBackward", "" },
- { "DeleteBackward", "" },
- // "delete-from-cursor" (chars, 2)
- { "DeleteForward", "" },
- { "DeleteForward", "" },
- // "delete-from-cursor" (word-ends, -1)
- { "DeleteWordBackward", "" },
- // "delete-from-cursor" (word-ends, 1)
- { "DeleteWordForward", "" },
- // "delete-from-cursor" (words, -1)
- { "MoveWordBackward", "" },
- { "DeleteWordForward", "" },
- // "delete-from-cursor" (words, 1)
- { "MoveWordForward", "" },
- { "DeleteWordBackward", "" },
- // "delete-from-cursor" (display-lines, -1)
- { "MoveToBeginningOfLine", "" },
- { "DeleteToEndOfLine", "" },
- // "delete-from-cursor" (display-lines, 1)
- { "MoveToBeginningOfLine", "" },
- { "DeleteToEndOfLine", "" },
- // "delete-from-cursor" (display-line-ends, -1)
- { "DeleteToBeginningOfLine", "" },
- // "delete-from-cursor" (display-line-ends, 1)
- { "DeleteToEndOfLine", "" },
- // "delete-from-cursor" (paragraph-ends, -1)
- { "DeleteToBeginningOfParagraph", "" },
- // "delete-from-cursor" (paragraph-ends, 1)
- { "DeleteToEndOfParagraph", "" },
- // "delete-from-cursor" (paragraphs, -1)
- { "MoveToBeginningOfParagraph", "" },
- { "DeleteToEndOfParagraph", "" },
- // "delete-from-cursor" (paragraphs, 1)
- { "MoveToBeginningOfParagraph", "" },
- { "DeleteToEndOfParagraph", "" },
- };
-
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_2, GDK_CONTROL_MASK),
- kEditCommands, arraysize(kEditCommands));
-}
-
-TEST_F(GtkKeyBindingsHandlerTest, OtherActions) {
- static const EditCommand kBackspace[] = {
- { "DeleteBackward", "" }
- };
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_3, GDK_CONTROL_MASK),
- kBackspace, arraysize(kBackspace));
-
- static const EditCommand kCopyClipboard[] = {
- { "Copy", "" }
- };
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_4, GDK_CONTROL_MASK),
- kCopyClipboard, arraysize(kCopyClipboard));
-
- static const EditCommand kCutClipboard[] = {
- { "Cut", "" }
- };
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_5, GDK_CONTROL_MASK),
- kCutClipboard, arraysize(kCutClipboard));
-
- static const EditCommand kInsertAtCursor[] = {
- { "InsertText", "hello" }
- };
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_6, GDK_CONTROL_MASK),
- kInsertAtCursor, arraysize(kInsertAtCursor));
-
- static const EditCommand kPasteClipboard[] = {
- { "Paste", "" }
- };
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_7, GDK_CONTROL_MASK),
- kPasteClipboard, arraysize(kPasteClipboard));
-
- static const EditCommand kSelectAll[] = {
- { "Unselect", "" },
- { "SelectAll", "" }
- };
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_8, GDK_CONTROL_MASK),
- kSelectAll, arraysize(kSelectAll));
-
- static const EditCommand kSetAnchor[] = {
- { "SetMark", "" }
- };
- TestKeyBinding(NewNativeWebKeyboardEvent(GDK_9, GDK_CONTROL_MASK),
- kSetAnchor, arraysize(kSetAnchor));
-}
diff --git a/content/browser/renderer_host/render_widget_host_view_gtk.cc b/content/browser/renderer_host/render_widget_host_view_gtk.cc
deleted file mode 100644
index 403ed10..0000000
--- a/content/browser/renderer_host/render_widget_host_view_gtk.cc
+++ /dev/null
@@ -1,1210 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/browser/renderer_host/render_widget_host_view_gtk.h"
-
-// If this gets included after the gtk headers, then a bunch of compiler
-// errors happen because of a "#define Status int" in Xlib.h, which interacts
-// badly with net::URLRequestStatus::Status.
-#include "content/common/view_messages.h"
-
-#include <cairo/cairo.h>
-#include <gdk/gdk.h>
-#include <gdk/gdkkeysyms.h>
-#include <gdk/gdkx.h>
-#include <gtk/gtk.h>
-
-#include <algorithm>
-#include <string>
-
-#include "base/command_line.h"
-#include "base/logging.h"
-#include "base/message_loop.h"
-#include "base/metrics/histogram.h"
-#include "base/string_number_conversions.h"
-#include "base/time.h"
-#include "base/utf_string_conversions.h"
-#include "content/browser/renderer_host/backing_store_x.h"
-#include "content/browser/renderer_host/gtk_im_context_wrapper.h"
-#include "content/browser/renderer_host/render_view_host.h"
-#include "content/browser/renderer_host/render_view_host_delegate.h"
-#include "content/browser/renderer_host/render_widget_host.h"
-#include "content/common/content_switches.h"
-#include "content/common/native_web_keyboard_event.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/gtk/WebInputEventFactory.h"
-#include "ui/base/text/text_elider.h"
-#include "ui/base/x/x11_util.h"
-#include "ui/gfx/gtk_native_view_id_manager.h"
-#include "ui/gfx/gtk_preserve_window.h"
-#include "webkit/glue/webaccessibility.h"
-#include "webkit/glue/webcursor_gtk_data.h"
-#include "webkit/plugins/npapi/webplugin.h"
-
-#if defined(OS_CHROMEOS)
-#include "views/widget/tooltip_window_gtk.h"
-#else
-#include "content/browser/renderer_host/gtk_key_bindings_handler.h"
-#endif // defined(OS_CHROMEOS)
-
-namespace {
-
-const int kMaxWindowWidth = 4000;
-const int kMaxWindowHeight = 4000;
-const char* kRenderWidgetHostViewKey = "__RENDER_WIDGET_HOST_VIEW__";
-
-// The duration of the fade-out animation. See |overlay_animation_|.
-const int kFadeEffectDuration = 300;
-
-#if defined(OS_CHROMEOS)
-// TODO(davemoore) Under Chromeos we are increasing the rate that the trackpad
-// generates events to get better precisions. Eventually we will coordinate the
-// driver and this setting to ensure they match.
-const float kDefaultScrollPixelsPerTick = 20;
-#else
-// See WebInputEventFactor.cpp for a reason for this being the default
-// scroll size for linux.
-const float kDefaultScrollPixelsPerTick = 160.0f / 3.0f;
-#endif
-
-const GdkColor kBGColor =
-#if defined(NDEBUG)
- { 0, 0xff * 257, 0xff * 257, 0xff * 257 };
-#else
- { 0, 0x00 * 257, 0xff * 257, 0x00 * 257 };
-#endif
-
-// Returns the spinning cursor used for loading state.
-GdkCursor* GetMozSpinningCursor() {
- static GdkCursor* moz_spinning_cursor = NULL;
- if (!moz_spinning_cursor) {
- const GdkColor fg = { 0, 0, 0, 0 };
- const GdkColor bg = { 65535, 65535, 65535, 65535 };
- GdkPixmap* source =
- gdk_bitmap_create_from_data(NULL, moz_spinning_bits, 32, 32);
- GdkPixmap* mask =
- gdk_bitmap_create_from_data(NULL, moz_spinning_mask_bits, 32, 32);
- moz_spinning_cursor =
- gdk_cursor_new_from_pixmap(source, mask, &fg, &bg, 2, 2);
- g_object_unref(source);
- g_object_unref(mask);
- }
- return moz_spinning_cursor;
-}
-
-} // namespace
-
-using WebKit::WebInputEventFactory;
-using WebKit::WebMouseWheelEvent;
-
-// This class is a simple convenience wrapper for Gtk functions. It has only
-// static methods.
-class RenderWidgetHostViewGtkWidget {
- public:
- static GtkWidget* CreateNewWidget(RenderWidgetHostViewGtk* host_view) {
- GtkWidget* widget = gtk_preserve_window_new();
- gtk_widget_set_name(widget, "chrome-render-widget-host-view");
- // We manually double-buffer in Paint() because Paint() may or may not be
- // called in repsonse to an "expose-event" signal.
- gtk_widget_set_double_buffered(widget, FALSE);
- gtk_widget_set_redraw_on_allocate(widget, FALSE);
- gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &kBGColor);
- // Allow the browser window to be resized freely.
- gtk_widget_set_size_request(widget, 0, 0);
-
- gtk_widget_add_events(widget, GDK_EXPOSURE_MASK |
- GDK_POINTER_MOTION_MASK |
- GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_KEY_PRESS_MASK |
- GDK_KEY_RELEASE_MASK |
- GDK_FOCUS_CHANGE_MASK |
- GDK_ENTER_NOTIFY_MASK |
- GDK_LEAVE_NOTIFY_MASK);
- gtk_widget_set_can_focus(widget, TRUE);
-
- g_signal_connect(widget, "expose-event",
- G_CALLBACK(OnExposeEvent), host_view);
- g_signal_connect(widget, "key-press-event",
- G_CALLBACK(OnKeyPressReleaseEvent), host_view);
- g_signal_connect(widget, "key-release-event",
- G_CALLBACK(OnKeyPressReleaseEvent), host_view);
- g_signal_connect(widget, "focus-in-event",
- G_CALLBACK(OnFocusIn), host_view);
- g_signal_connect(widget, "focus-out-event",
- G_CALLBACK(OnFocusOut), host_view);
- g_signal_connect(widget, "grab-notify",
- G_CALLBACK(OnGrabNotify), host_view);
- g_signal_connect(widget, "button-press-event",
- G_CALLBACK(OnButtonPressReleaseEvent), host_view);
- g_signal_connect(widget, "button-release-event",
- G_CALLBACK(OnButtonPressReleaseEvent), host_view);
- g_signal_connect(widget, "motion-notify-event",
- G_CALLBACK(OnMouseMoveEvent), host_view);
- g_signal_connect(widget, "enter-notify-event",
- G_CALLBACK(OnCrossingEvent), host_view);
- g_signal_connect(widget, "leave-notify-event",
- G_CALLBACK(OnCrossingEvent), host_view);
- g_signal_connect(widget, "client-event",
- G_CALLBACK(OnClientEvent), host_view);
-
-
- // Connect after so that we are called after the handler installed by the
- // TabContentsView which handles zoom events.
- g_signal_connect_after(widget, "scroll-event",
- G_CALLBACK(OnMouseScrollEvent), host_view);
-
- g_object_set_data(G_OBJECT(widget), kRenderWidgetHostViewKey,
- static_cast<RenderWidgetHostView*>(host_view));
-
- return widget;
- }
-
- private:
- static gboolean OnExposeEvent(GtkWidget* widget,
- GdkEventExpose* expose,
- RenderWidgetHostViewGtk* host_view) {
- if (host_view->is_hidden_)
- return FALSE;
- const gfx::Rect damage_rect(expose->area);
- host_view->Paint(damage_rect);
- return FALSE;
- }
-
- static gboolean OnKeyPressReleaseEvent(GtkWidget* widget,
- GdkEventKey* event,
- RenderWidgetHostViewGtk* host_view) {
- // Force popups or fullscreen windows to close on Escape so they won't keep
- // the keyboard grabbed or be stuck onscreen if the renderer is hanging.
- bool should_close_on_escape =
- (host_view->IsPopup() && host_view->NeedsInputGrab()) ||
- host_view->is_fullscreen_;
- if (should_close_on_escape && GDK_Escape == event->keyval) {
- host_view->host_->Shutdown();
- } else {
- // Send key event to input method.
- host_view->im_context_->ProcessKeyEvent(event);
- }
-
- // We return TRUE because we did handle the event. If it turns out webkit
- // can't handle the event, we'll deal with it in
- // RenderView::UnhandledKeyboardEvent().
- return TRUE;
- }
-
- static gboolean OnFocusIn(GtkWidget* widget,
- GdkEventFocus* focus,
- RenderWidgetHostViewGtk* host_view) {
- host_view->ShowCurrentCursor();
- host_view->GetRenderWidgetHost()->GotFocus();
-
- // The only way to enable a GtkIMContext object is to call its focus in
- // handler.
- host_view->im_context_->OnFocusIn();
-
- return TRUE;
- }
-
- static gboolean OnFocusOut(GtkWidget* widget,
- GdkEventFocus* focus,
- RenderWidgetHostViewGtk* host_view) {
- // Whenever we lose focus, set the cursor back to that of our parent window,
- // which should be the default arrow.
- gdk_window_set_cursor(widget->window, NULL);
- // If we are showing a context menu, maintain the illusion that webkit has
- // focus.
- if (!host_view->is_showing_context_menu_)
- host_view->GetRenderWidgetHost()->Blur();
-
- // Prevents us from stealing input context focus in OnGrabNotify() handler.
- host_view->was_imcontext_focused_before_grab_ = false;
-
- // Disable the GtkIMContext object.
- host_view->im_context_->OnFocusOut();
-
- return TRUE;
- }
-
- // Called when we are shadowed or unshadowed by a keyboard grab (which will
- // occur for activatable popups, such as dropdown menus). Popup windows do not
- // take focus, so we never get a focus out or focus in event when they are
- // shown, and must rely on this signal instead.
- static void OnGrabNotify(GtkWidget* widget, gboolean was_grabbed,
- RenderWidgetHostViewGtk* host_view) {
- if (was_grabbed) {
- if (host_view->was_imcontext_focused_before_grab_)
- host_view->im_context_->OnFocusIn();
- } else {
- host_view->was_imcontext_focused_before_grab_ =
- host_view->im_context_->is_focused();
- if (host_view->was_imcontext_focused_before_grab_) {
- gdk_window_set_cursor(widget->window, NULL);
- host_view->im_context_->OnFocusOut();
- }
- }
- }
-
- static gboolean OnButtonPressReleaseEvent(
- GtkWidget* widget,
- GdkEventButton* event,
- RenderWidgetHostViewGtk* host_view) {
-#if defined (OS_CHROMEOS)
- // We support buttons 8 & 9 for scrolling with an attached USB mouse
- // in ChromeOS. We do this separately from the builtin scrolling support
- // because we want to support the user's expectations about the amount
- // scrolled on each event. xorg.conf on chromeos specifies buttons
- // 8 & 9 for the scroll wheel for the attached USB mouse.
- if (event->type == GDK_BUTTON_RELEASE &&
- (event->button == 8 || event->button == 9)) {
- GdkEventScroll scroll_event;
- scroll_event.type = GDK_SCROLL;
- scroll_event.window = event->window;
- scroll_event.send_event = event->send_event;
- scroll_event.time = event->time;
- scroll_event.x = event->x;
- scroll_event.y = event->y;
- scroll_event.state = event->state;
- if (event->state & GDK_SHIFT_MASK) {
- scroll_event.direction =
- event->button == 8 ? GDK_SCROLL_LEFT : GDK_SCROLL_RIGHT;
- } else {
- scroll_event.direction =
- event->button == 8 ? GDK_SCROLL_UP : GDK_SCROLL_DOWN;
- }
- scroll_event.device = event->device;
- scroll_event.x_root = event->x_root;
- scroll_event.y_root = event->y_root;
- WebMouseWheelEvent web_event =
- WebInputEventFactory::mouseWheelEvent(&scroll_event);
- host_view->GetRenderWidgetHost()->ForwardWheelEvent(web_event);
- }
-#endif
-
- if (event->type != GDK_BUTTON_RELEASE)
- host_view->set_last_mouse_down(event);
-
- if (!(event->button == 1 || event->button == 2 || event->button == 3))
- return FALSE; // We do not forward any other buttons to the renderer.
- if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)
- return FALSE;
-
- // If we don't have focus already, this mouse click will focus us.
- if (!gtk_widget_is_focus(widget))
- host_view->host_->OnMouseActivate();
-
- // Confirm existing composition text on mouse click events, to make sure
- // the input caret won't be moved with an ongoing composition session.
- if (event->type != GDK_BUTTON_RELEASE)
- host_view->im_context_->ConfirmComposition();
-
- // We want to translate the coordinates of events that do not originate
- // from this widget to be relative to the top left of the widget.
- GtkWidget* event_widget = gtk_get_event_widget(
- reinterpret_cast<GdkEvent*>(event));
- if (event_widget != widget) {
- int x = 0;
- int y = 0;
- gtk_widget_get_pointer(widget, &x, &y);
- // If the mouse event happens outside our popup, force the popup to
- // close. We do this so a hung renderer doesn't prevent us from
- // releasing the x pointer grab.
- bool click_in_popup = x >= 0 && y >= 0 && x < widget->allocation.width &&
- y < widget->allocation.height;
- // Only Shutdown on mouse downs. Mouse ups can occur outside the render
- // view if the user drags for DnD or while using the scrollbar on a select
- // dropdown. Don't shutdown if we are not a popup.
- if (event->type != GDK_BUTTON_RELEASE && host_view->IsPopup() &&
- !host_view->is_popup_first_mouse_release_ && !click_in_popup) {
- host_view->host_->Shutdown();
- return FALSE;
- }
- event->x = x;
- event->y = y;
- }
-
- // TODO(evanm): why is this necessary here but not in test shell?
- // This logic is the same as GtkButton.
- if (event->type == GDK_BUTTON_PRESS && !gtk_widget_has_focus(widget))
- gtk_widget_grab_focus(widget);
-
- host_view->is_popup_first_mouse_release_ = false;
- host_view->GetRenderWidgetHost()->ForwardMouseEvent(
- WebInputEventFactory::mouseEvent(event));
-
- // Although we did handle the mouse event, we need to let other handlers
- // run (in particular the one installed by TabContentsViewGtk).
- return FALSE;
- }
-
- static gboolean OnMouseMoveEvent(GtkWidget* widget,
- GdkEventMotion* event,
- RenderWidgetHostViewGtk* host_view) {
- // We want to translate the coordinates of events that do not originate
- // from this widget to be relative to the top left of the widget.
- GtkWidget* event_widget = gtk_get_event_widget(
- reinterpret_cast<GdkEvent*>(event));
- if (event_widget != widget) {
- int x = 0;
- int y = 0;
- gtk_widget_get_pointer(widget, &x, &y);
- event->x = x;
- event->y = y;
- }
-
- host_view->ModifyEventForEdgeDragging(widget, event);
- host_view->GetRenderWidgetHost()->ForwardMouseEvent(
- WebInputEventFactory::mouseEvent(event));
- return FALSE;
- }
-
- static gboolean OnCrossingEvent(GtkWidget* widget,
- GdkEventCrossing* event,
- RenderWidgetHostViewGtk* host_view) {
- const int any_button_mask =
- GDK_BUTTON1_MASK |
- GDK_BUTTON2_MASK |
- GDK_BUTTON3_MASK |
- GDK_BUTTON4_MASK |
- GDK_BUTTON5_MASK;
-
- // Only forward crossing events if the mouse button is not down.
- // (When the mouse button is down, the proper events are already being
- // sent by ButtonPressReleaseEvent and MouseMoveEvent, above, and if we
- // additionally send this crossing event with the state indicating the
- // button is down, it causes problems with drag and drop in WebKit.)
- if (!(event->state & any_button_mask)) {
- host_view->GetRenderWidgetHost()->ForwardMouseEvent(
- WebInputEventFactory::mouseEvent(event));
- }
-
- return FALSE;
- }
-
- static gboolean OnClientEvent(GtkWidget* widget,
- GdkEventClient* event,
- RenderWidgetHostViewGtk* host_view) {
- VLOG(1) << "client event type: " << event->message_type
- << " data_format: " << event->data_format
- << " data: " << event->data.l;
- return TRUE;
- }
-
- // Allow the vertical scroll delta to be overridden from the command line.
- // This will allow us to test more easily to discover the amount
- // (either hard coded or computed) that's best.
- static float GetScrollPixelsPerTick() {
- static float scroll_pixels = -1;
- if (scroll_pixels < 0) {
- // TODO(brettw): Remove the command line switch (crbug.com/63525)
- scroll_pixels = kDefaultScrollPixelsPerTick;
- CommandLine* command_line = CommandLine::ForCurrentProcess();
- std::string scroll_pixels_option =
- command_line->GetSwitchValueASCII(switches::kScrollPixels);
- if (!scroll_pixels_option.empty()) {
- double v;
- if (base::StringToDouble(scroll_pixels_option, &v))
- scroll_pixels = static_cast<float>(v);
- }
- DCHECK_GT(scroll_pixels, 0);
- }
- return scroll_pixels;
- }
-
- // Return the net up / down (or left / right) distance represented by events
- // in the events will be removed from the queue. We only look at the top of
- // queue...any other type of event will cause us not to look farther.
- // If there is a change to the set of modifier keys or scroll axis
- // in the events we will stop looking as well.
- static int GetPendingScrollDelta(bool vert, guint current_event_state) {
- int num_clicks = 0;
- GdkEvent* event;
- bool event_coalesced = true;
- while ((event = gdk_event_get()) && event_coalesced) {
- event_coalesced = false;
- if (event->type == GDK_SCROLL) {
- GdkEventScroll scroll = event->scroll;
- if (scroll.state & GDK_SHIFT_MASK) {
- if (scroll.direction == GDK_SCROLL_UP)
- scroll.direction = GDK_SCROLL_LEFT;
- else if (scroll.direction == GDK_SCROLL_DOWN)
- scroll.direction = GDK_SCROLL_RIGHT;
- }
- if (vert) {
- if (scroll.direction == GDK_SCROLL_UP ||
- scroll.direction == GDK_SCROLL_DOWN) {
- if (scroll.state == current_event_state) {
- num_clicks += (scroll.direction == GDK_SCROLL_UP ? 1 : -1);
- gdk_event_free(event);
- event_coalesced = true;
- }
- }
- } else {
- if (scroll.direction == GDK_SCROLL_LEFT ||
- scroll.direction == GDK_SCROLL_RIGHT) {
- if (scroll.state == current_event_state) {
- num_clicks += (scroll.direction == GDK_SCROLL_LEFT ? 1 : -1);
- gdk_event_free(event);
- event_coalesced = true;
- }
- }
- }
- }
- }
- // If we have an event left we put it back on the queue.
- if (event) {
- gdk_event_put(event);
- gdk_event_free(event);
- }
- return num_clicks * GetScrollPixelsPerTick();
- }
-
- static gboolean OnMouseScrollEvent(GtkWidget* widget,
- GdkEventScroll* event,
- RenderWidgetHostViewGtk* host_view) {
- // If the user is holding shift, translate it into a horizontal scroll. We
- // don't care what other modifiers the user may be holding (zooming is
- // handled at the TabContentsView level).
- if (event->state & GDK_SHIFT_MASK) {
- if (event->direction == GDK_SCROLL_UP)
- event->direction = GDK_SCROLL_LEFT;
- else if (event->direction == GDK_SCROLL_DOWN)
- event->direction = GDK_SCROLL_RIGHT;
- }
-
- WebMouseWheelEvent web_event = WebInputEventFactory::mouseWheelEvent(event);
- // We peek ahead at the top of the queue to look for additional pending
- // scroll events.
- if (event->direction == GDK_SCROLL_UP ||
- event->direction == GDK_SCROLL_DOWN) {
- if (event->direction == GDK_SCROLL_UP)
- web_event.deltaY = GetScrollPixelsPerTick();
- else
- web_event.deltaY = -GetScrollPixelsPerTick();
- web_event.deltaY += GetPendingScrollDelta(true, event->state);
- } else {
- if (event->direction == GDK_SCROLL_LEFT)
- web_event.deltaX = GetScrollPixelsPerTick();
- else
- web_event.deltaX = -GetScrollPixelsPerTick();
- web_event.deltaX += GetPendingScrollDelta(false, event->state);
- }
- host_view->GetRenderWidgetHost()->ForwardWheelEvent(web_event);
- return FALSE;
- }
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(RenderWidgetHostViewGtkWidget);
-};
-
-// static
-RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
- RenderWidgetHost* widget) {
- return new RenderWidgetHostViewGtk(widget);
-}
-
-RenderWidgetHostViewGtk::RenderWidgetHostViewGtk(RenderWidgetHost* widget_host)
- : host_(widget_host),
- about_to_validate_and_paint_(false),
- is_hidden_(false),
- is_loading_(false),
- is_showing_context_menu_(false),
- overlay_color_(0),
- overlay_animation_(this),
- parent_(NULL),
- is_popup_first_mouse_release_(true),
- was_imcontext_focused_before_grab_(false),
- do_x_grab_(false),
- is_fullscreen_(false),
- destroy_handler_id_(0),
- dragged_at_horizontal_edge_(0),
- dragged_at_vertical_edge_(0),
- compositing_surface_(gfx::kNullPluginWindow),
- last_mouse_down_(NULL) {
- host_->SetView(this);
-}
-
-RenderWidgetHostViewGtk::~RenderWidgetHostViewGtk() {
- set_last_mouse_down(NULL);
- view_.Destroy();
-}
-
-void RenderWidgetHostViewGtk::InitAsChild() {
- DoSharedInit();
- overlay_animation_.SetDuration(kFadeEffectDuration);
- overlay_animation_.SetSlideDuration(kFadeEffectDuration);
- gtk_widget_show(view_.get());
-}
-
-void RenderWidgetHostViewGtk::InitAsPopup(
- RenderWidgetHostView* parent_host_view, const gfx::Rect& pos) {
- // If we aren't a popup, then |window| will be leaked.
- DCHECK(IsPopup());
-
- DoSharedInit();
- parent_ = parent_host_view->GetNativeView();
- GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));
- gtk_container_add(GTK_CONTAINER(window), view_.get());
- DoPopupOrFullscreenInit(window, pos);
-
- // The underlying X window needs to be created and mapped by the above code
- // before we can grab the input devices.
- if (NeedsInputGrab()) {
- // Grab all input for the app. If a click lands outside the bounds of the
- // popup, WebKit will notice and destroy us. Before doing this we need
- // to ensure that the the popup is added to the browser's window group,
- // to allow for the grabs to work correctly.
- gtk_window_group_add_window(gtk_window_get_group(
- GTK_WINDOW(gtk_widget_get_toplevel(parent_))), window);
- gtk_grab_add(view_.get());
-
- // We need for the application to do an X grab as well. However if the app
- // already has an X grab (as in the case of extension popup), an app grab
- // will suffice.
- do_x_grab_ = !gdk_pointer_is_grabbed();
-
- // Now grab all of X's input.
- if (do_x_grab_) {
- gdk_pointer_grab(
- parent_->window,
- TRUE, // Only events outside of the window are reported with respect
- // to |parent_->window|.
- static_cast<GdkEventMask>(GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK),
- NULL,
- NULL,
- GDK_CURRENT_TIME);
- // We grab keyboard events too so things like alt+tab are eaten.
- gdk_keyboard_grab(parent_->window, TRUE, GDK_CURRENT_TIME);
- }
- }
-}
-
-void RenderWidgetHostViewGtk::InitAsFullscreen(
- RenderWidgetHostView* /*reference_host_view*/) {
- DoSharedInit();
-
- is_fullscreen_ = true;
- GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
- gtk_window_set_decorated(window, FALSE);
- gtk_window_fullscreen(window);
- g_signal_connect(GTK_WIDGET(window),
- "window-state-event",
- G_CALLBACK(&OnWindowStateEventThunk),
- this);
- destroy_handler_id_ = g_signal_connect(GTK_WIDGET(window),
- "destroy",
- G_CALLBACK(OnDestroyThunk),
- this);
- gtk_container_add(GTK_CONTAINER(window), view_.get());
-
- // Try to move and resize the window to cover the screen in case the window
- // manager doesn't support _NET_WM_STATE_FULLSCREEN.
- GdkScreen* screen = gtk_window_get_screen(window);
- gfx::Rect bounds(
- 0, 0, gdk_screen_get_width(screen), gdk_screen_get_height(screen));
- DoPopupOrFullscreenInit(window, bounds);
-}
-
-RenderWidgetHost* RenderWidgetHostViewGtk::GetRenderWidgetHost() const {
- return host_;
-}
-
-void RenderWidgetHostViewGtk::DidBecomeSelected() {
- if (!is_hidden_)
- return;
-
- if (tab_switch_paint_time_.is_null())
- tab_switch_paint_time_ = base::TimeTicks::Now();
- is_hidden_ = false;
- host_->WasRestored();
-}
-
-void RenderWidgetHostViewGtk::WasHidden() {
- if (is_hidden_)
- return;
-
- // If we receive any more paint messages while we are hidden, we want to
- // ignore them so we don't re-allocate the backing store. We will paint
- // everything again when we become selected again.
- is_hidden_ = true;
-
- // If we have a renderer, then inform it that we are being hidden so it can
- // reduce its resource utilization.
- GetRenderWidgetHost()->WasHidden();
-}
-
-void RenderWidgetHostViewGtk::SetSize(const gfx::Size& size) {
- int width = std::min(size.width(), kMaxWindowWidth);
- int height = std::min(size.height(), kMaxWindowHeight);
- if (IsPopup()) {
- // We're a popup, honor the size request.
- gtk_widget_set_size_request(view_.get(), width, height);
- } else {
-#if defined(TOOLKIT_VIEWS)
- // TOOLKIT_VIEWS' resize logic flow matches windows. so we go ahead and
- // size the widget. In GTK+, the size of the widget is determined by its
- // children.
- gtk_widget_set_size_request(view_.get(), width, height);
-#endif
- }
-
- // Update the size of the RWH.
- if (requested_size_.width() != width ||
- requested_size_.height() != height) {
- requested_size_ = gfx::Size(width, height);
- host_->WasResized();
- }
-}
-
-void RenderWidgetHostViewGtk::SetBounds(const gfx::Rect& rect) {
- // This is called when webkit has sent us a Move message.
- if (IsPopup()) {
- gtk_window_move(GTK_WINDOW(gtk_widget_get_toplevel(view_.get())),
- rect.x(), rect.y());
- }
-
- SetSize(rect.size());
-}
-
-gfx::NativeView RenderWidgetHostViewGtk::GetNativeView() {
- return view_.get();
-}
-
-void RenderWidgetHostViewGtk::MovePluginWindows(
- const std::vector<webkit::npapi::WebPluginGeometry>& moves) {
- for (size_t i = 0; i < moves.size(); ++i) {
- plugin_container_manager_.MovePluginContainer(moves[i]);
- }
-}
-
-void RenderWidgetHostViewGtk::Focus() {
- gtk_widget_grab_focus(view_.get());
-}
-
-void RenderWidgetHostViewGtk::Blur() {
- // TODO(estade): We should be clearing native focus as well, but I know of no
- // way to do that without focusing another widget.
- host_->Blur();
-}
-
-bool RenderWidgetHostViewGtk::HasFocus() {
- return gtk_widget_is_focus(view_.get());
-}
-
-void RenderWidgetHostViewGtk::Show() {
- gtk_widget_show(view_.get());
-}
-
-void RenderWidgetHostViewGtk::Hide() {
- gtk_widget_hide(view_.get());
-}
-
-bool RenderWidgetHostViewGtk::IsShowing() {
- return gtk_widget_get_visible(view_.get());
-}
-
-gfx::Rect RenderWidgetHostViewGtk::GetViewBounds() const {
- GtkAllocation* alloc = &view_.get()->allocation;
- return gfx::Rect(alloc->x, alloc->y,
- requested_size_.width(),
- requested_size_.height());
-}
-
-void RenderWidgetHostViewGtk::UpdateCursor(const WebCursor& cursor) {
- // Optimize the common case, where the cursor hasn't changed.
- // However, we can switch between different pixmaps, so only on the
- // non-pixmap branch.
- if (current_cursor_.GetCursorType() != GDK_CURSOR_IS_PIXMAP &&
- current_cursor_.GetCursorType() == cursor.GetCursorType()) {
- return;
- }
-
- current_cursor_ = cursor;
- ShowCurrentCursor();
-}
-
-void RenderWidgetHostViewGtk::SetIsLoading(bool is_loading) {
- is_loading_ = is_loading;
- // Only call ShowCurrentCursor() when it will actually change the cursor.
- if (current_cursor_.GetCursorType() == GDK_LAST_CURSOR)
- ShowCurrentCursor();
-}
-
-void RenderWidgetHostViewGtk::ImeUpdateTextInputState(
- ui::TextInputType type,
- bool can_compose_inline,
- const gfx::Rect& caret_rect) {
- im_context_->UpdateInputMethodState(type, can_compose_inline, caret_rect);
-}
-
-void RenderWidgetHostViewGtk::ImeCancelComposition() {
- im_context_->CancelComposition();
-}
-
-void RenderWidgetHostViewGtk::DidUpdateBackingStore(
- const gfx::Rect& scroll_rect, int scroll_dx, int scroll_dy,
- const std::vector<gfx::Rect>& copy_rects) {
- if (is_hidden_)
- return;
-
- // TODO(darin): Implement the equivalent of Win32's ScrollWindowEX. Can that
- // be done using XCopyArea? Perhaps similar to
- // BackingStore::ScrollBackingStore?
- if (about_to_validate_and_paint_)
- invalid_rect_ = invalid_rect_.Union(scroll_rect);
- else
- Paint(scroll_rect);
-
- for (size_t i = 0; i < copy_rects.size(); ++i) {
- // Avoid double painting. NOTE: This is only relevant given the call to
- // Paint(scroll_rect) above.
- gfx::Rect rect = copy_rects[i].Subtract(scroll_rect);
- if (rect.IsEmpty())
- continue;
-
- if (about_to_validate_and_paint_)
- invalid_rect_ = invalid_rect_.Union(rect);
- else
- Paint(rect);
- }
-}
-
-void RenderWidgetHostViewGtk::RenderViewGone(base::TerminationStatus status,
- int error_code) {
- Destroy();
- plugin_container_manager_.set_host_widget(NULL);
-}
-
-void RenderWidgetHostViewGtk::Destroy() {
- if (compositing_surface_ != gfx::kNullPluginWindow) {
- GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
- manager->ReleasePermanentXID(compositing_surface_);
- }
-
- if (do_x_grab_) {
- // Undo the X grab.
- GdkDisplay* display = gtk_widget_get_display(parent_);
- gdk_display_pointer_ungrab(display, GDK_CURRENT_TIME);
- gdk_display_keyboard_ungrab(display, GDK_CURRENT_TIME);
- }
-
- // If this is a popup or fullscreen widget, then we need to destroy the window
- // that we created to hold it.
- if (IsPopup() || is_fullscreen_) {
- GtkWidget* window = gtk_widget_get_parent(view_.get());
-
- // Disconnect the destroy handler so that we don't try to shutdown twice.
- if (is_fullscreen_)
- g_signal_handler_disconnect(window, destroy_handler_id_);
-
- gtk_widget_destroy(window);
- }
-
- // Remove |view_| from all containers now, so nothing else can hold a
- // reference to |view_|'s widget except possibly a gtk signal handler if
- // this code is currently executing within the context of a gtk signal
- // handler. Note that |view_| is still alive after this call. It will be
- // deallocated in the destructor.
- // See http://www.crbug.com/11847 for details.
- gtk_widget_destroy(view_.get());
-
- // The RenderWidgetHost's destruction led here, so don't call it.
- host_ = NULL;
-
- MessageLoop::current()->DeleteSoon(FROM_HERE, this);
-}
-
-void RenderWidgetHostViewGtk::SetTooltipText(const std::wstring& tooltip_text) {
- // Maximum number of characters we allow in a tooltip.
- const int kMaxTooltipLength = 8 << 10;
- // Clamp the tooltip length to kMaxTooltipLength so that we don't
- // accidentally DOS the user with a mega tooltip (since GTK doesn't do
- // this itself).
- // I filed https://bugzilla.gnome.org/show_bug.cgi?id=604641 upstream.
- const string16 clamped_tooltip =
- ui::TruncateString(WideToUTF16Hack(tooltip_text),
- kMaxTooltipLength);
-
- if (clamped_tooltip.empty()) {
- gtk_widget_set_has_tooltip(view_.get(), FALSE);
- } else {
- gtk_widget_set_tooltip_text(view_.get(),
- UTF16ToUTF8(clamped_tooltip).c_str());
-#if defined(OS_CHROMEOS)
- tooltip_window_->SetTooltipText(UTF16ToWideHack(clamped_tooltip));
-#endif // defined(OS_CHROMEOS)
- }
-}
-
-void RenderWidgetHostViewGtk::SelectionChanged(const std::string& text,
- const ui::Range& range,
- const gfx::Point& start,
- const gfx::Point& end) {
- if (!text.empty()) {
- GtkClipboard* x_clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
- gtk_clipboard_set_text(x_clipboard, text.c_str(), text.length());
- }
-}
-
-void RenderWidgetHostViewGtk::ShowingContextMenu(bool showing) {
- is_showing_context_menu_ = showing;
-}
-
-#if !defined(TOOLKIT_VIEWS)
-GtkWidget* RenderWidgetHostViewGtk::BuildInputMethodsGtkMenu() {
- return im_context_->BuildInputMethodsGtkMenu();
-}
-#endif
-
-gboolean RenderWidgetHostViewGtk::OnWindowStateEvent(
- GtkWidget* widget,
- GdkEventWindowState* event) {
- if (is_fullscreen_) {
- // If a fullscreen widget got unfullscreened (e.g. by the window manager),
- // close it.
- bool unfullscreened =
- (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) &&
- !(event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN);
- if (unfullscreened) {
- host_->Shutdown();
- return TRUE;
- }
- }
-
- return FALSE;
-}
-
-void RenderWidgetHostViewGtk::OnDestroy(GtkWidget* widget) {
- DCHECK(is_fullscreen_);
- host_->Shutdown();
-}
-
-bool RenderWidgetHostViewGtk::NeedsInputGrab() {
- return popup_type_ == WebKit::WebPopupTypeSelect;
-}
-
-bool RenderWidgetHostViewGtk::IsPopup() const {
- return popup_type_ != WebKit::WebPopupTypeNone;
-}
-
-void RenderWidgetHostViewGtk::DoSharedInit() {
- view_.Own(RenderWidgetHostViewGtkWidget::CreateNewWidget(this));
- im_context_.reset(new GtkIMContextWrapper(this));
- plugin_container_manager_.set_host_widget(view_.get());
-#if defined(OS_CHROMEOS)
- tooltip_window_.reset(new views::TooltipWindowGtk(view_.get()));
-#else
- key_bindings_handler_.reset(new GtkKeyBindingsHandler(view_.get()));
-#endif
-}
-
-void RenderWidgetHostViewGtk::DoPopupOrFullscreenInit(GtkWindow* window,
- const gfx::Rect& bounds) {
- requested_size_.SetSize(std::min(bounds.width(), kMaxWindowWidth),
- std::min(bounds.height(), kMaxWindowHeight));
- host_->WasResized();
-
- gtk_widget_set_size_request(
- view_.get(), requested_size_.width(), requested_size_.height());
-
- // Don't allow the window to be resized. This also forces the window to
- // shrink down to the size of its child contents.
- gtk_window_set_resizable(window, FALSE);
- gtk_window_set_default_size(window, -1, -1);
- gtk_window_move(window, bounds.x(), bounds.y());
-
- gtk_widget_show_all(GTK_WIDGET(window));
-}
-
-BackingStore* RenderWidgetHostViewGtk::AllocBackingStore(
- const gfx::Size& size) {
- return new BackingStoreX(host_, size,
- ui::GetVisualFromGtkWidget(view_.get()),
- gtk_widget_get_visual(view_.get())->depth);
-}
-
-void RenderWidgetHostViewGtk::SetBackground(const SkBitmap& background) {
- RenderWidgetHostView::SetBackground(background);
- host_->Send(new ViewMsg_SetBackground(host_->routing_id(), background));
-}
-
-void RenderWidgetHostViewGtk::ModifyEventForEdgeDragging(
- GtkWidget* widget, GdkEventMotion* event) {
- // If the widget is aligned with an edge of the monitor its on and the user
- // attempts to drag past that edge we track the number of times it has
- // occurred, so that we can force the widget to scroll when it otherwise
- // would be unable to, by modifying the (x,y) position in the drag
- // event that we forward on to webkit. If we get a move that's no longer a
- // drag or a drag indicating the user is no longer at that edge we stop
- // altering the drag events.
- int new_dragged_at_horizontal_edge = 0;
- int new_dragged_at_vertical_edge = 0;
- // Used for checking the edges of the monitor. We cache the values to save
- // roundtrips to the X server.
- static gfx::Size drag_monitor_size;
- if (event->state & GDK_BUTTON1_MASK) {
- if (drag_monitor_size.IsEmpty()) {
- // We can safely cache the monitor size for the duration of a drag.
- GdkScreen* screen = gtk_widget_get_screen(widget);
- int monitor =
- gdk_screen_get_monitor_at_point(screen, event->x_root, event->y_root);
- GdkRectangle geometry;
- gdk_screen_get_monitor_geometry(screen, monitor, &geometry);
- drag_monitor_size.SetSize(geometry.width, geometry.height);
- }
-
- // Check X and Y independently, as the user could be dragging into a corner.
- if (event->x == 0 && event->x_root == 0) {
- new_dragged_at_horizontal_edge = dragged_at_horizontal_edge_ - 1;
- } else if (widget->allocation.width - 1 == static_cast<gint>(event->x) &&
- drag_monitor_size.width() - 1 == static_cast<gint>(event->x_root)) {
- new_dragged_at_horizontal_edge = dragged_at_horizontal_edge_ + 1;
- }
-
- if (event->y == 0 && event->y_root == 0) {
- new_dragged_at_vertical_edge = dragged_at_vertical_edge_ - 1;
- } else if (widget->allocation.height - 1 == static_cast<gint>(event->y) &&
- drag_monitor_size.height() - 1 == static_cast<gint>(event->y_root)) {
- new_dragged_at_vertical_edge = dragged_at_vertical_edge_ + 1;
- }
-
- event->x_root += new_dragged_at_horizontal_edge;
- event->x += new_dragged_at_horizontal_edge;
- event->y_root += new_dragged_at_vertical_edge;
- event->y += new_dragged_at_vertical_edge;
- } else {
- // Clear whenever we get a non-drag mouse move.
- drag_monitor_size.SetSize(0, 0);
- }
- dragged_at_horizontal_edge_ = new_dragged_at_horizontal_edge;
- dragged_at_vertical_edge_ = new_dragged_at_vertical_edge;
-}
-
-void RenderWidgetHostViewGtk::Paint(const gfx::Rect& damage_rect) {
- // If the GPU process is rendering directly into the View,
- // call the compositor directly.
- RenderWidgetHost* render_widget_host = GetRenderWidgetHost();
- if (render_widget_host->is_accelerated_compositing_active()) {
- host_->ScheduleComposite();
- return;
- }
-
- GdkWindow* window = view_.get()->window;
- DCHECK(!about_to_validate_and_paint_);
-
- invalid_rect_ = damage_rect;
- about_to_validate_and_paint_ = true;
- BackingStoreX* backing_store = static_cast<BackingStoreX*>(
- host_->GetBackingStore(true));
- // Calling GetBackingStore maybe have changed |invalid_rect_|...
- about_to_validate_and_paint_ = false;
-
- gfx::Rect paint_rect = gfx::Rect(0, 0, kMaxWindowWidth, kMaxWindowHeight);
- paint_rect = paint_rect.Intersect(invalid_rect_);
-
- if (backing_store) {
- // Only render the widget if it is attached to a window; there's a short
- // period where this object isn't attached to a window but hasn't been
- // Destroy()ed yet and it receives paint messages...
- if (window) {
- if (SkColorGetA(overlay_color_) == 0) {
- // In the common case, use XCopyArea. We don't draw more than once, so
- // we don't need to double buffer.
- backing_store->XShowRect(gfx::Point(0, 0),
- paint_rect, ui::GetX11WindowFromGtkWidget(view_.get()));
- } else {
- // If the grey blend is showing, we make two drawing calls. Use double
- // buffering to prevent flicker. Use CairoShowRect because XShowRect
- // shortcuts GDK's double buffering. We won't be able to draw outside
- // of |damage_rect|, so invalidate the difference between |paint_rect|
- // and |damage_rect|.
- if (paint_rect != damage_rect) {
- GdkRectangle extra_gdk_rect =
- paint_rect.Subtract(damage_rect).ToGdkRectangle();
- gdk_window_invalidate_rect(window, &extra_gdk_rect, false);
- }
-
- GdkRectangle rect = { damage_rect.x(), damage_rect.y(),
- damage_rect.width(), damage_rect.height() };
- gdk_window_begin_paint_rect(window, &rect);
-
- backing_store->CairoShowRect(damage_rect, GDK_DRAWABLE(window));
-
- cairo_t* cr = gdk_cairo_create(window);
- gdk_cairo_rectangle(cr, &rect);
- SkColor overlay = SkColorSetA(
- overlay_color_,
- SkColorGetA(overlay_color_) *
- overlay_animation_.GetCurrentValue());
- float r = SkColorGetR(overlay) / 255.;
- float g = SkColorGetG(overlay) / 255.;
- float b = SkColorGetB(overlay) / 255.;
- float a = SkColorGetA(overlay) / 255.;
- cairo_set_source_rgba(cr, r, g, b, a);
- cairo_fill(cr);
- cairo_destroy(cr);
-
- gdk_window_end_paint(window);
- }
- }
- if (!whiteout_start_time_.is_null()) {
- base::TimeDelta whiteout_duration = base::TimeTicks::Now() -
- whiteout_start_time_;
- UMA_HISTOGRAM_TIMES("MPArch.RWHH_WhiteoutDuration", whiteout_duration);
-
- // Reset the start time to 0 so that we start recording again the next
- // time the backing store is NULL...
- whiteout_start_time_ = base::TimeTicks();
- }
- if (!tab_switch_paint_time_.is_null()) {
- base::TimeDelta tab_switch_paint_duration = base::TimeTicks::Now() -
- tab_switch_paint_time_;
- UMA_HISTOGRAM_TIMES("MPArch.RWH_TabSwitchPaintDuration",
- tab_switch_paint_duration);
- // Reset tab_switch_paint_time_ to 0 so future tab selections are
- // recorded.
- tab_switch_paint_time_ = base::TimeTicks();
- }
- } else {
- if (window)
- gdk_window_clear(window);
- if (whiteout_start_time_.is_null())
- whiteout_start_time_ = base::TimeTicks::Now();
- }
-}
-
-void RenderWidgetHostViewGtk::ShowCurrentCursor() {
- // The widget may not have a window. If that's the case, abort mission. This
- // is the same issue as that explained above in Paint().
- if (!view_.get()->window)
- return;
-
- // TODO(port): WebKit bug https://bugs.webkit.org/show_bug.cgi?id=16388 is
- // that calling gdk_window_set_cursor repeatedly is expensive. We should
- // avoid it here where possible.
- GdkCursor* gdk_cursor;
- if (current_cursor_.GetCursorType() == GDK_LAST_CURSOR) {
- // Use MOZ_CURSOR_SPINNING if we are showing the default cursor and
- // the page is loading.
- gdk_cursor = is_loading_ ? GetMozSpinningCursor() : NULL;
- } else {
- gdk_cursor = current_cursor_.GetNativeCursor();
- }
- gdk_window_set_cursor(view_.get()->window, gdk_cursor);
-}
-
-void RenderWidgetHostViewGtk::CreatePluginContainer(
- gfx::PluginWindowHandle id) {
- plugin_container_manager_.CreatePluginContainer(id);
-}
-
-void RenderWidgetHostViewGtk::DestroyPluginContainer(
- gfx::PluginWindowHandle id) {
- plugin_container_manager_.DestroyPluginContainer(id);
-}
-
-void RenderWidgetHostViewGtk::SetVisuallyDeemphasized(
- const SkColor* color, bool animate) {
- // Do nothing unless |color| has changed, meaning |animate| is only
- // respected for the first call.
- if (color && (*color == overlay_color_))
- return;
-
- overlay_color_ = color ? *color : 0;
-
- if (animate) {
- overlay_animation_.Reset();
- overlay_animation_.Show();
- } else {
- overlay_animation_.Reset(1.0);
- gtk_widget_queue_draw(view_.get());
- }
-}
-
-void RenderWidgetHostViewGtk::UnhandledWheelEvent(
- const WebKit::WebMouseWheelEvent& event) {
-}
-
-void RenderWidgetHostViewGtk::SetHasHorizontalScrollbar(
- bool has_horizontal_scrollbar) {
-}
-
-void RenderWidgetHostViewGtk::SetScrollOffsetPinning(
- bool is_pinned_to_left, bool is_pinned_to_right) {
-}
-
-
-void RenderWidgetHostViewGtk::AcceleratedCompositingActivated(bool activated) {
- GtkPreserveWindow* widget =
- reinterpret_cast<GtkPreserveWindow*>(view_.get());
-
- gtk_preserve_window_delegate_resize(widget, activated);
-}
-
-gfx::PluginWindowHandle RenderWidgetHostViewGtk::GetCompositingSurface() {
- if (compositing_surface_ == gfx::kNullPluginWindow) {
- GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
- gfx::NativeViewId view_id = gfx::IdFromNativeView(GetNativeView());
-
- if (!manager->GetPermanentXIDForId(&compositing_surface_, view_id)) {
- DLOG(ERROR) << "Can't find XID for view id " << view_id;
- }
- }
- return compositing_surface_;
-}
-
-void RenderWidgetHostViewGtk::ForwardKeyboardEvent(
- const NativeWebKeyboardEvent& event) {
- if (!host_)
- return;
-
-#if !defined(OS_CHROMEOS)
- EditCommands edit_commands;
- if (!event.skip_in_browser &&
- key_bindings_handler_->Match(event, &edit_commands)) {
- host_->Send(new ViewMsg_SetEditCommandsForNextKeyEvent(
- host_->routing_id(), edit_commands));
- NativeWebKeyboardEvent copy_event(event);
- copy_event.match_edit_command = true;
- host_->ForwardKeyboardEvent(copy_event);
- return;
- }
-#endif
-
- host_->ForwardKeyboardEvent(event);
-}
-
-void RenderWidgetHostViewGtk::AnimationEnded(const ui::Animation* animation) {
- gtk_widget_queue_draw(view_.get());
-}
-
-void RenderWidgetHostViewGtk::AnimationProgressed(
- const ui::Animation* animation) {
- gtk_widget_queue_draw(view_.get());
-}
-
-void RenderWidgetHostViewGtk::AnimationCanceled(
- const ui::Animation* animation) {
- gtk_widget_queue_draw(view_.get());
-}
-
-void RenderWidgetHostViewGtk::set_last_mouse_down(GdkEventButton* event) {
- GdkEventButton* temp = NULL;
- if (event) {
- temp = reinterpret_cast<GdkEventButton*>(
- gdk_event_copy(reinterpret_cast<GdkEvent*>(event)));
- }
-
- if (last_mouse_down_)
- gdk_event_free(reinterpret_cast<GdkEvent*>(last_mouse_down_));
-
- last_mouse_down_ = temp;
-}
-
-// static
-RenderWidgetHostView*
- RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
- gfx::NativeView widget) {
- gpointer user_data = g_object_get_data(G_OBJECT(widget),
- kRenderWidgetHostViewKey);
- return reinterpret_cast<RenderWidgetHostView*>(user_data);
-}
diff --git a/content/browser/renderer_host/render_widget_host_view_gtk.h b/content/browser/renderer_host/render_widget_host_view_gtk.h
deleted file mode 100644
index c857651..0000000
--- a/content/browser/renderer_host/render_widget_host_view_gtk.h
+++ /dev/null
@@ -1,273 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_GTK_H_
-#define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_GTK_H_
-#pragma once
-
-#include <gdk/gdk.h>
-
-#include <string>
-#include <vector>
-
-#include "base/memory/scoped_ptr.h"
-#include "base/time.h"
-#include "content/browser/renderer_host/render_widget_host_view.h"
-#include "ui/base/animation/animation_delegate.h"
-#include "ui/base/animation/slide_animation.h"
-#include "ui/base/gtk/gtk_signal.h"
-#include "ui/base/gtk/owned_widget_gtk.h"
-#include "ui/gfx/native_widget_types.h"
-#include "ui/gfx/rect.h"
-#include "webkit/glue/webcursor.h"
-#include "webkit/plugins/npapi/gtk_plugin_container_manager.h"
-
-class RenderWidgetHost;
-class GtkIMContextWrapper;
-struct NativeWebKeyboardEvent;
-
-#if defined(OS_CHROMEOS)
-namespace views {
-class TooltipWindowGtk;
-}
-#else
-class GtkKeyBindingsHandler;
-#endif // defined(OS_CHROMEOS)
-
-typedef struct _GtkClipboard GtkClipboard;
-typedef struct _GtkSelectionData GtkSelectionData;
-
-// -----------------------------------------------------------------------------
-// See comments in render_widget_host_view.h about this class and its members.
-// -----------------------------------------------------------------------------
-class RenderWidgetHostViewGtk : public RenderWidgetHostView,
- public ui::AnimationDelegate {
- public:
- explicit RenderWidgetHostViewGtk(RenderWidgetHost* widget);
- virtual ~RenderWidgetHostViewGtk();
-
- // Initialize this object for use as a drawing area.
- void InitAsChild();
-
- // RenderWidgetHostView implementation.
- virtual void InitAsPopup(RenderWidgetHostView* parent_host_view,
- const gfx::Rect& pos) OVERRIDE;
- virtual void InitAsFullscreen(
- RenderWidgetHostView* reference_host_view) OVERRIDE;
- virtual RenderWidgetHost* GetRenderWidgetHost() const OVERRIDE;
- virtual void DidBecomeSelected() OVERRIDE;
- virtual void WasHidden() OVERRIDE;
- virtual void SetSize(const gfx::Size& size) OVERRIDE;
- virtual void SetBounds(const gfx::Rect& rect) OVERRIDE;
- virtual gfx::NativeView GetNativeView() OVERRIDE;
- virtual void MovePluginWindows(
- const std::vector<webkit::npapi::WebPluginGeometry>& moves) OVERRIDE;
- virtual void Focus() OVERRIDE;
- virtual void Blur() OVERRIDE;
- virtual bool HasFocus() OVERRIDE;
- virtual void Show() OVERRIDE;
- virtual void Hide() OVERRIDE;
- virtual bool IsShowing() OVERRIDE;
- virtual gfx::Rect GetViewBounds() const OVERRIDE;
- virtual void UpdateCursor(const WebCursor& cursor) OVERRIDE;
- virtual void SetIsLoading(bool is_loading) OVERRIDE;
- virtual void ImeUpdateTextInputState(ui::TextInputType type,
- bool can_compose_inline,
- const gfx::Rect& caret_rect) OVERRIDE;
- virtual void ImeCancelComposition() OVERRIDE;
- virtual void DidUpdateBackingStore(
- const gfx::Rect& scroll_rect, int scroll_dx, int scroll_dy,
- const std::vector<gfx::Rect>& copy_rects) OVERRIDE;
- virtual void RenderViewGone(base::TerminationStatus status,
- int error_code) OVERRIDE;
- virtual void Destroy() OVERRIDE;
- virtual void WillDestroyRenderWidget(RenderWidgetHost* rwh) {}
- virtual void SetTooltipText(const std::wstring& tooltip_text) OVERRIDE;
- virtual void SelectionChanged(const std::string& text,
- const ui::Range& range,
- const gfx::Point& start,
- const gfx::Point& end) OVERRIDE;
- virtual void ShowingContextMenu(bool showing) OVERRIDE;
- virtual BackingStore* AllocBackingStore(const gfx::Size& size) OVERRIDE;
- virtual void SetBackground(const SkBitmap& background) OVERRIDE;
- virtual void CreatePluginContainer(gfx::PluginWindowHandle id) OVERRIDE;
- virtual void DestroyPluginContainer(gfx::PluginWindowHandle id) OVERRIDE;
- virtual void SetVisuallyDeemphasized(const SkColor* color,
- bool animate) OVERRIDE;
- virtual void UnhandledWheelEvent(
- const WebKit::WebMouseWheelEvent& event) OVERRIDE;
- virtual void SetHasHorizontalScrollbar(
- bool has_horizontal_scrollbar) OVERRIDE;
- virtual void SetScrollOffsetPinning(
- bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE;
- virtual void AcceleratedCompositingActivated(bool activated) OVERRIDE;
- virtual gfx::PluginWindowHandle GetCompositingSurface() OVERRIDE;
-
- // ui::AnimationDelegate implementation.
- virtual void AnimationEnded(const ui::Animation* animation) OVERRIDE;
- virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE;
- virtual void AnimationCanceled(const ui::Animation* animation) OVERRIDE;
-
- gfx::NativeView native_view() const { return view_.get(); }
-
- // If the widget is aligned with an edge of the monitor its on and the user
- // attempts to drag past that edge we track the number of times it has
- // occurred, so that we can force the widget to scroll when it otherwise
- // would be unable to.
- void ModifyEventForEdgeDragging(GtkWidget* widget, GdkEventMotion* event);
- void Paint(const gfx::Rect&);
-
- // Called by GtkIMContextWrapper to forward a keyboard event to renderer.
- // On Linux (not ChromeOS):
- // Before calling RenderWidgetHost::ForwardKeyboardEvent(), this method
- // calls GtkKeyBindingsHandler::Match() against the event and send matched
- // edit commands to renderer by calling
- // RenderWidgetHost::ForwardEditCommandsForNextKeyEvent().
- void ForwardKeyboardEvent(const NativeWebKeyboardEvent& event);
-
- GdkEventButton* last_mouse_down() const {
- return last_mouse_down_;
- }
-
-#if !defined(TOOLKIT_VIEWS)
- // Builds a submenu containing all the gtk input method commands.
- GtkWidget* BuildInputMethodsGtkMenu();
-#endif
-
- private:
- friend class RenderWidgetHostViewGtkWidget;
-
- CHROMEGTK_CALLBACK_1(RenderWidgetHostViewGtk,
- gboolean,
- OnWindowStateEvent,
- GdkEventWindowState*);
-
- CHROMEGTK_CALLBACK_0(RenderWidgetHostViewGtk,
- void,
- OnDestroy);
-
- // Returns whether the widget needs an input grab (GTK+ and X) to work
- // properly.
- bool NeedsInputGrab();
-
- // Returns whether this render view is a popup (<select> dropdown or
- // autocomplete window).
- bool IsPopup() const;
-
- // Do initialization needed by all InitAs*() methods.
- void DoSharedInit();
-
- // Do initialization needed just by InitAsPopup() and InitAsFullscreen().
- // We move and resize |window| to |bounds| and show it and its contents.
- void DoPopupOrFullscreenInit(GtkWindow* window, const gfx::Rect& bounds);
-
- // Update the display cursor for the render view.
- void ShowCurrentCursor();
-
- void set_last_mouse_down(GdkEventButton* event);
-
- // The model object.
- RenderWidgetHost* host_;
-
- // The native UI widget.
- OwnedWidgetGtk view_;
-
- // This is true when we are currently painting and thus should handle extra
- // paint requests by expanding the invalid rect rather than actually
- // painting.
- bool about_to_validate_and_paint_;
-
- // This is the rectangle which we'll paint.
- gfx::Rect invalid_rect_;
-
- // Whether or not this widget is hidden.
- bool is_hidden_;
-
- // Whether we are currently loading.
- bool is_loading_;
-
- // The cursor for the page. This is passed up from the renderer.
- WebCursor current_cursor_;
-
- // Whether we are showing a context menu.
- bool is_showing_context_menu_;
-
- // The time at which this view started displaying white pixels as a result of
- // not having anything to paint (empty backing store from renderer). This
- // value returns true for is_null() if we are not recording whiteout times.
- base::TimeTicks whiteout_start_time_;
-
- // The time it took after this view was selected for it to be fully painted.
- base::TimeTicks tab_switch_paint_time_;
-
- // A color we use to shade the entire render view. If 100% transparent, we do
- // not shade the render view.
- SkColor overlay_color_;
-
- // The animation used for the abovementioned shade effect. The animation's
- // value affects the alpha we use for |overlay_color_|.
- ui::SlideAnimation overlay_animation_;
-
- // The native view of our parent widget. Used only for popups.
- GtkWidget* parent_;
-
- // We ignore the first mouse release on popups so the popup will remain open.
- bool is_popup_first_mouse_release_;
-
- // Whether or not this widget's input context was focused before being
- // shadowed by another widget. Used in OnGrabNotify() handler to track the
- // focused state correctly.
- bool was_imcontext_focused_before_grab_;
-
- // True if we are responsible for creating an X grab. This will only be used
- // for <select> dropdowns. It should be true for most such cases, but false
- // for extension popups.
- bool do_x_grab_;
-
- // Is the widget fullscreen?
- bool is_fullscreen_;
-
- // For full-screen windows we have a OnDestroy handler that we need to remove,
- // so we keep it ID here.
- unsigned long destroy_handler_id_;
-
- // A convenience wrapper object for GtkIMContext;
- scoped_ptr<GtkIMContextWrapper> im_context_;
-
-#if !defined(OS_CHROMEOS)
- // A convenience object for handling editor key bindings defined in gtk
- // keyboard theme.
- scoped_ptr<GtkKeyBindingsHandler> key_bindings_handler_;
-#endif
-
- // Helper class that lets us allocate plugin containers and move them.
- webkit::npapi::GtkPluginContainerManager plugin_container_manager_;
-
- // The size that we want the renderer to be. We keep this in a separate
- // variable because resizing in GTK+ is async.
- gfx::Size requested_size_;
-
- // The number of times the user has dragged against horizontal edge of the
- // monitor (if the widget is aligned with that edge). Negative values
- // indicate the left edge, positive the right.
- int dragged_at_horizontal_edge_;
-
- // The number of times the user has dragged against vertical edge of the
- // monitor (if the widget is aligned with that edge). Negative values
- // indicate the top edge, positive the bottom.
- int dragged_at_vertical_edge_;
-
- gfx::PluginWindowHandle compositing_surface_;
-
- // The event for the last mouse down we handled. We need this for context
- // menus and drags.
- GdkEventButton* last_mouse_down_;
-
-#if defined(OS_CHROMEOS)
- // Custimized tooltip window.
- scoped_ptr<views::TooltipWindowGtk> tooltip_window_;
-#endif // defined(OS_CHROMEOS)
-};
-
-#endif // CHROME_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_GTK_H_
--
cgit v1.1