Merge lp:~chrisccoulson/oxide/refactor-webview-rwhv-interation into lp:~oxide-developers/oxide/oxide.trunk

[Chris Coulson]

[lp:~chrisccoulson/oxide/refactor-webview-rwhv-interation]

1222. By Chris Coulson on 2015-10-17

Merge from trunk

1223. By Chris Coulson on 2015-10-17

When a RWHV is hidden, make sure we hide its cc::Layer

1224. By Chris Coulson on 2015-10-19

Don't proxy EvictCurrentFrame up to the WebView. This already doesn't make sense, and we should have a separate algorithm for LayerTreeHost eviction when a WebView is hidden. The current implementation won't make sense when we have Interstitial views anyway

1225. By Chris Coulson on 2015-10-19

Create RWHVs with a container

1226. By Chris Coulson on 2015-10-19

Change the behaviour of RWHV::IsShowing, and make sure that when we create a new cc::Layer it has the correct visibility

1227. By Chris Coulson on 2015-10-19

Fix RWHV::HasFocus

1228. By Chris Coulson on 2015-10-20

Merge from trunk

1229. By Chris Coulson on 2015-10-20

Merge from trunk

1230. By Chris Coulson on 2015-10-21

Split IME related calls from WebViewClient in to new classes

1231. By Chris Coulson on 2015-10-21

Attach the IM context when creating a new webview

1232. By Chris Coulson on 2015-10-21

Remove an unused method from WebViewClient

1233. By Chris Coulson on 2015-10-21

Fix cursor updates to work with interstitial views

1234. By Chris Coulson on 2015-10-21

Fix a shutdown crash

1235. By Chris Coulson on 2015-10-21

Turn a couple of CHECKs in to DCHECKs

1236. By Chris Coulson on 2015-10-21

Actually observe the input method context

1237. By Chris Coulson on 2015-10-21

Add CompositorObserver and make RWHV use this, rather than relying on WebView to proxy DidCommit to it

1238. By Chris Coulson on 2015-10-21

Fix a -Wreorder warning

1239. By Chris Coulson on 2015-10-21

Don't call Show() or Hide() when setting the container

1240. By Chris Coulson on 2015-10-21

We only need to set the RWHV visibility / focus for the first view

=== added directory 'qt/core/browser/input'
=== added file 'qt/core/browser/input/oxide_qt_input_method_context.cc'
--- qt/core/browser/input/oxide_qt_input_method_context.cc	1970-01-01 00:00:00 +0000
+++ qt/core/browser/input/oxide_qt_input_method_context.cc	2015-10-21 17:31:00 +0000
@@ -0,0 +1,424 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_qt_input_method_context.h"
+
+#include <string>
+#include <vector>
+
+#include <QFocusEvent>
+#include <QGuiApplication>
+#include <QInputMethod>
+#include <QInputMethodEvent>
+#include <QRect>
+#include <QString>
+#include <QTextCharFormat>
+#include <QWindow>
+
+#include "base/strings/utf_string_conversions.h"
+#include "third_party/skia/include/core/SkColor.h"
+#include "third_party/WebKit/public/platform/WebColor.h"
+#include "third_party/WebKit/public/web/WebCompositionUnderline.h"
+#include "ui/base/ime/text_input_type.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/range/range.h"
+
+#include "shared/browser/input/oxide_ime_bridge.h"
+
+#include "oxide_qt_input_method_context_client.h"
+
+namespace oxide {
+namespace qt {
+
+namespace {
+
+Qt::InputMethodHints QImHintsFromInputType(ui::TextInputType type) {
+  switch (type) {
+    case ui::TEXT_INPUT_TYPE_TEXT:
+    case ui::TEXT_INPUT_TYPE_TEXT_AREA:
+    case ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE:
+      return Qt::ImhPreferLowercase;
+    case ui::TEXT_INPUT_TYPE_PASSWORD:
+      return Qt::ImhHiddenText | Qt::ImhSensitiveData |
+          Qt::ImhNoAutoUppercase | Qt::ImhPreferLowercase |
+          Qt::ImhNoPredictiveText;
+    case ui::TEXT_INPUT_TYPE_SEARCH:
+      return Qt::ImhNoAutoUppercase | Qt::ImhPreferLowercase;
+    case ui::TEXT_INPUT_TYPE_EMAIL:
+      return Qt::ImhEmailCharactersOnly;
+    case ui::TEXT_INPUT_TYPE_NUMBER:
+      return Qt::ImhFormattedNumbersOnly;
+    case ui::TEXT_INPUT_TYPE_TELEPHONE:
+      return Qt::ImhDialableCharactersOnly;
+    case ui::TEXT_INPUT_TYPE_URL:
+      return Qt::ImhUrlCharactersOnly;
+    case ui::TEXT_INPUT_TYPE_DATE:
+    case ui::TEXT_INPUT_TYPE_MONTH:
+    case ui::TEXT_INPUT_TYPE_WEEK:
+      return Qt::ImhDate;
+    case ui::TEXT_INPUT_TYPE_DATE_TIME:
+    case ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL:
+    case ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD:
+      return Qt::ImhDate | Qt::ImhTime;
+    case ui::TEXT_INPUT_TYPE_TIME:
+      return Qt::ImhTime;
+    default:
+      return Qt::ImhNone;
+  }
+}
+
+}
+
+void InputMethodContext::OnInputPanelVisibilityChanged() {
+}
+
+bool InputMethodContext::ShouldShowInputPanel() const {
+  if (!ime_bridge()) {
+    return false;
+  }
+
+  if (ime_bridge()->text_input_type() != ui::TEXT_INPUT_TYPE_NONE &&
+      ime_bridge()->show_ime_if_needed() &&
+      ime_bridge()->focused_node_is_editable()) {
+    return true;
+  }
+
+  return false;
+}
+
+bool InputMethodContext::ShouldHideInputPanel() const {
+  if (!ime_bridge()) {
+    return true;
+  }
+
+  if (ime_bridge()->text_input_type() == ui::TEXT_INPUT_TYPE_NONE &&
+      !ime_bridge()->focused_node_is_editable()) {
+    return true;
+  }
+
+  return false;
+}
+
+void InputMethodContext::SetInputPanelVisibility(bool visible) {
+  client_->SetInputMethodEnabled(visible);
+
+  if (!visible) {
+    has_input_method_state_ = false;
+  }
+
+  // Do not check whether the input method is currently visible here, to avoid
+  // a possible race condition: if hide() and show() are called very quickly 
+  // in a row, when show() is called the hide() request might not have
+  // completed yet, and isVisible() could return true.
+  // See https://launchpad.net/bugs/1377755
+  QInputMethod* im = QGuiApplication::inputMethod();
+  if (im) {
+    im->setVisible(visible);
+  }
+}
+
+bool InputMethodContext::IsInputPanelVisible() const {
+  QInputMethod* im = QGuiApplication::inputMethod();
+  if (!im) {
+    return false;
+  }
+
+  return im->isVisible();
+}
+
+void InputMethodContext::TextInputStateChanged() {
+  if (!client_) {
+    return;
+  }
+
+  if (!client_->HasFocus()) {
+    return;
+  }
+
+  // Don't notify if type is none. See https://launchpad.net/bugs/1381083
+  if (ime_bridge() &&
+      ime_bridge()->text_input_type() != ui::TEXT_INPUT_TYPE_NONE) {
+    QGuiApplication::inputMethod()->update(
+        static_cast<Qt::InputMethodQueries>(Qt::ImQueryInput | Qt::ImHints));
+  }
+
+  if (ShouldShowInputPanel()) {
+    SetInputPanelVisibility(true);
+  } else if (ShouldHideInputPanel()) {
+    SetInputPanelVisibility(false);
+  }
+}
+
+void InputMethodContext::SelectionBoundsChanged() {
+  if (!client_) {
+    return;
+  }
+
+  if (!client_->HasFocus()) {
+    return;
+  }
+
+  QInputMethod* im = QGuiApplication::inputMethod();
+  if (!im) {
+    return;
+  }
+
+  im->update(static_cast<Qt::InputMethodQueries>(
+      Qt::ImCursorRectangle
+      | Qt::ImCursorPosition
+      | Qt::ImAnchorPosition
+#if QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
+      | Qt::ImTextBeforeCursor
+      | Qt::ImTextAfterCursor
+#endif
+  ));
+}
+
+void InputMethodContext::SelectionChanged() {
+  if (!client_) {
+    return;
+  }
+
+  if (!client_->HasFocus()) {
+    return;
+  }
+
+  QInputMethod* im = QGuiApplication::inputMethod();
+  if (!im) {
+    return;
+  }
+
+  im->update(static_cast<Qt::InputMethodQueries>(
+      Qt::ImSurroundingText
+      | Qt::ImCurrentSelection
+#if QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
+      | Qt::ImTextBeforeCursor
+      | Qt::ImTextAfterCursor
+#endif
+  ));
+}
+
+void InputMethodContext::CancelComposition() {
+  if (!has_input_method_state_) {
+    return;
+  }
+
+  QInputMethod* im = QGuiApplication::inputMethod();
+  if (!im) {
+    return;
+  }
+
+  im->reset();
+}
+
+void InputMethodContext::FocusedNodeChanged() {
+  if (!client_) {
+    return;
+  }
+
+  // Work around for https://launchpad.net/bugs/1323743
+  if (QGuiApplication::focusWindow() &&
+      QGuiApplication::focusWindow()->focusObject()) {
+    QGuiApplication::focusWindow()->focusObjectChanged(
+        QGuiApplication::focusWindow()->focusObject());
+  }
+
+  if (ShouldHideInputPanel() && client_->HasFocus()) {
+    SetInputPanelVisibility(false);
+  } else if (!has_input_method_state_ && ShouldShowInputPanel()) {
+    // See https://launchpad.net/bugs/1400372
+    SetInputPanelVisibility(true);
+  } else if (has_input_method_state_ &&
+             ime_bridge() &&
+             ime_bridge()->focused_node_is_editable() &&
+             QGuiApplication::inputMethod()) {
+    QGuiApplication::inputMethod()->reset();
+  }
+}
+
+InputMethodContext::InputMethodContext(InputMethodContextClient* client)
+    : client_(client),
+      has_input_method_state_(false) {
+  QInputMethod* im = QGuiApplication::inputMethod();
+  if (im) {
+    connect(im, SIGNAL(visibleChanged()),
+            SLOT(OnInputPanelVisibilityChanged()));
+  }
+}
+
+InputMethodContext::~InputMethodContext() {
+  QInputMethod* im = QGuiApplication::inputMethod();
+  if (im) {
+    im->disconnect(this);
+  }
+}
+
+void InputMethodContext::DetachClient() {
+  client_ = nullptr;
+}
+
+QVariant InputMethodContext::Query(Qt::InputMethodQuery query) const {
+  switch (query) {
+    case Qt::ImHints:
+      if (!ime_bridge()) {
+        return QVariant(QImHintsFromInputType(ui::TEXT_INPUT_TYPE_NONE));
+      }
+      return QVariant(QImHintsFromInputType(ime_bridge()->text_input_type()));
+    case Qt::ImCursorRectangle: {
+      if (!ime_bridge()) {
+        return QRect();
+      }
+      // XXX: Is this in the right coordinate space?
+      return QRect(ime_bridge()->caret_rect().x(),
+                   ime_bridge()->caret_rect().y(),
+                   ime_bridge()->caret_rect().width(),
+                   ime_bridge()->caret_rect().height());
+    }
+    case Qt::ImCursorPosition:
+      if (!ime_bridge()) {
+        return 0;
+      }
+      return static_cast<int>(ime_bridge()->selection_cursor_position() &
+                              INT_MAX);
+    case Qt::ImSurroundingText:
+      if (!ime_bridge()) {
+        return QString();
+      }
+      return QString::fromStdString(
+          base::UTF16ToUTF8(ime_bridge()->GetSelectionText()));
+    case Qt::ImCurrentSelection:
+      if (!ime_bridge()) {
+        return QString();
+      }
+      return QString::fromStdString(
+          base::UTF16ToUTF8(ime_bridge()->GetSelectedText()));
+    case Qt::ImAnchorPosition:
+      if (!ime_bridge()) {
+        return 0;
+      }
+      return static_cast<int>(ime_bridge()->selection_anchor_position() &
+                              INT_MAX);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
+    case Qt::ImTextBeforeCursor: {
+      if (!ime_bridge()) {
+        return QString();
+      }
+      std::string text = base::UTF16ToUTF8(ime_bridge()->GetSelectionText());
+      return QString::fromStdString(
+          text.substr(0, ime_bridge()->selection_cursor_position()));
+    }
+    case Qt::ImTextAfterCursor: {
+      if (!ime_bridge()) {
+        return QString();
+      }
+      std::string text = base::UTF16ToUTF8(ime_bridge()->GetSelectionText());
+      if (ime_bridge()->selection_cursor_position() > text.length()) {
+        return QString();
+      }
+      return QString::fromStdString(
+          text.substr(ime_bridge()->selection_cursor_position(),
+                      std::string::npos));
+    }
+#endif
+    default:
+      break;
+  }
+
+  return QVariant();
+}
+
+void InputMethodContext::FocusChanged(QFocusEvent* event) {
+  if (!event->gotFocus()) {
+    return;
+  }
+
+  if (!ShouldShowInputPanel()) {
+    return;
+  }
+
+  SetInputPanelVisibility(true);
+}
+
+void InputMethodContext::HandleEvent(QInputMethodEvent* event) {
+  QString commit_string = event->commitString();
+
+  if (!commit_string.isEmpty()) {
+    gfx::Range replacement_range = gfx::Range::InvalidRange();
+    if (event->replacementLength() > 0) {
+      replacement_range.set_start(event->replacementStart());
+      replacement_range.set_end(event->replacementStart() +
+                                event->replacementLength());
+    }
+    if (ime_bridge()) {
+      ime_bridge()->CommitText(base::UTF8ToUTF16(commit_string.toStdString()),
+                               replacement_range);
+    }
+  }
+
+  QString preedit_string = event->preeditString();
+
+  std::vector<blink::WebCompositionUnderline> underlines;
+  int cursor_position = -1;
+  gfx::Range selection_range = gfx::Range::InvalidRange();
+
+  for (const auto& attribute : event->attributes()) {
+    switch (attribute.type) {
+    case QInputMethodEvent::Cursor:
+      if (attribute.length > 0) {
+        cursor_position = attribute.start;
+      }
+      break;
+    case QInputMethodEvent::Selection:
+      selection_range.set_start(
+          qMin(attribute.start, (attribute.start + attribute.length)));
+      selection_range.set_end(
+          qMax(attribute.start, (attribute.start + attribute.length)));
+      break;
+    case QInputMethodEvent::TextFormat: {
+      QTextCharFormat format =
+          attribute.value.value<QTextFormat>().toCharFormat();
+      blink::WebColor color = format.underlineColor().rgba();
+      int start = qMin(attribute.start, (attribute.start + attribute.length));
+      int end = qMax(attribute.start, (attribute.start + attribute.length));
+      blink::WebCompositionUnderline underline(
+          start, end, color, false, SK_ColorTRANSPARENT);
+      underlines.push_back(underline);
+      break;
+    }
+    default:
+      break;
+    }
+  }
+
+  if (!selection_range.IsValid()) {
+    selection_range =
+        gfx::Range(cursor_position > 0 ?
+                     cursor_position :
+                     preedit_string.length());
+  }
+
+  if (ime_bridge()) {
+    ime_bridge()->SetComposingText(
+        base::UTF8ToUTF16(preedit_string.toStdString()),
+        underlines, selection_range);
+  }
+
+  has_input_method_state_ = !preedit_string.isEmpty();
+}
+
+} // namespace qt
+} // namespace oxide

=== added file 'qt/core/browser/input/oxide_qt_input_method_context.h'
--- qt/core/browser/input/oxide_qt_input_method_context.h	1970-01-01 00:00:00 +0000
+++ qt/core/browser/input/oxide_qt_input_method_context.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,82 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_QT_CORE_BROWSER_INPUT_INPUT_METHOD_CONTEXT_H_
+#define _OXIDE_QT_CORE_BROWSER_INPUT_INPUT_METHOD_CONTEXT_H_
+
+#include <QObject>
+#include <QtGlobal>
+#include <QVariant>
+
+#include "base/macros.h"
+
+#include "shared/browser/input/oxide_input_method_context.h"
+
+QT_BEGIN_NAMESPACE
+class QFocusEvent;
+class QInputMethodEvent;
+QT_END_NAMESPACE
+
+namespace oxide {
+namespace qt {
+
+class InputMethodContextClient;
+
+class InputMethodContext : public QObject,
+                           public oxide::InputMethodContext {
+  Q_OBJECT
+
+ public:
+  InputMethodContext(InputMethodContextClient* client);
+  ~InputMethodContext() override;
+
+  QVariant Query(Qt::InputMethodQuery query) const;
+
+  // Null out |client_| to prevent calls back in to it during its destructor
+  void DetachClient();
+
+  void FocusChanged(QFocusEvent* event);
+  void HandleEvent(QInputMethodEvent* event);
+
+ private Q_SLOTS:
+  void OnInputPanelVisibilityChanged();
+
+ private:
+  bool ShouldShowInputPanel() const;
+  bool ShouldHideInputPanel() const;
+
+  void SetInputPanelVisibility(bool visible);
+
+  // oxide::InputMethodContext implementation
+  bool IsInputPanelVisible() const override;
+  void TextInputStateChanged() override;
+  void SelectionBoundsChanged() override;
+  void SelectionChanged() override;
+  void CancelComposition() override;
+  void FocusedNodeChanged() override;
+
+  InputMethodContextClient* client_; // Owns us
+
+  bool has_input_method_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(InputMethodContext);
+};
+
+} // namespace qt
+} // namespace oxide
+
+#endif // _OXIDE_QT_CORE_BROWSER_INPUT_INPUT_METHOD_CONTEXT_H_

=== added file 'qt/core/browser/input/oxide_qt_input_method_context_client.h'
--- qt/core/browser/input/oxide_qt_input_method_context_client.h	1970-01-01 00:00:00 +0000
+++ qt/core/browser/input/oxide_qt_input_method_context_client.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,36 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_QT_CORE_BROWSER_INPUT_INPUT_METHOD_CONTEXT_CLIENT_H_
+#define _OXIDE_QT_CORE_BROWSER_INPUT_INPUT_METHOD_CONTEXT_CLIENT_H_
+
+namespace oxide {
+namespace qt {
+
+class InputMethodContextClient {
+ public:
+  virtual ~InputMethodContextClient() {}
+
+  virtual bool HasFocus() const = 0;
+
+  virtual void SetInputMethodEnabled(bool enabled) = 0;
+};
+
+} // namespace qt
+} // namespace oxide
+
+#endif // _OXIDE_QT_CORE_BROWSER_INPUT_INPUT_METHOD_CONTEXT_CLIENT_H_

=== modified file 'qt/core/browser/oxide_qt_web_view.cc'
--- qt/core/browser/oxide_qt_web_view.cc	2015-10-16 21:36:30 +0000
+++ qt/core/browser/oxide_qt_web_view.cc	2015-10-21 17:31:00 +0000
@@ -25,14 +25,12 @@
 #include <QCursor>
 #include <QGuiApplication>
 #include <QInputEvent>
-#include <QInputMethod>
 #include <QKeyEvent>
+#include <QPixmap>
 #include <QScreen>
 #include <QString>
 #include <QtDebug>
-#include <QTextCharFormat>
 #include <QUrl>
-#include <QWindow>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ -46,16 +44,12 @@
 #include "content/public/browser/navigation_controller.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "net/base/net_errors.h"
-#include "third_party/skia/include/core/SkColor.h"
-#include "third_party/WebKit/public/platform/WebColor.h"
 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
 #include "third_party/WebKit/public/platform/WebTopControlsState.h"
-#include "ui/base/ime/text_input_type.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/gfx/range/range.h"
 #include "url/gurl.h"
 
 #include "qt/core/api/oxideqdownloadrequest.h"
@@ -74,6 +68,7 @@
 #include "qt/core/api/oxideqfindcontroller_p.h"
 #include "qt/core/api/oxideqwebpreferences.h"
 #include "qt/core/api/oxideqwebpreferences_p.h"
+#include "qt/core/browser/input/oxide_qt_input_method_context.h"
 #include "qt/core/glue/oxide_qt_web_frame_proxy_client.h"
 #include "qt/core/glue/oxide_qt_web_view_proxy_client.h"
 #include "shared/browser/compositor/oxide_compositor_frame_data.h"
@@ -236,41 +231,6 @@
   return QCursor(cs);
 }
 
-Qt::InputMethodHints QImHintsFromInputType(ui::TextInputType type) {
-  switch (type) {
-    case ui::TEXT_INPUT_TYPE_TEXT:
-    case ui::TEXT_INPUT_TYPE_TEXT_AREA:
-    case ui::TEXT_INPUT_TYPE_CONTENT_EDITABLE:
-      return Qt::ImhPreferLowercase;
-    case ui::TEXT_INPUT_TYPE_PASSWORD:
-      return Qt::ImhHiddenText | Qt::ImhSensitiveData |
-          Qt::ImhNoAutoUppercase | Qt::ImhPreferLowercase |
-          Qt::ImhNoPredictiveText;
-    case ui::TEXT_INPUT_TYPE_SEARCH:
-      return Qt::ImhNoAutoUppercase | Qt::ImhPreferLowercase;
-    case ui::TEXT_INPUT_TYPE_EMAIL:
-      return Qt::ImhEmailCharactersOnly;
-    case ui::TEXT_INPUT_TYPE_NUMBER:
-      return Qt::ImhFormattedNumbersOnly;
-    case ui::TEXT_INPUT_TYPE_TELEPHONE:
-      return Qt::ImhDialableCharactersOnly;
-    case ui::TEXT_INPUT_TYPE_URL:
-      return Qt::ImhUrlCharactersOnly;
-    case ui::TEXT_INPUT_TYPE_DATE:
-    case ui::TEXT_INPUT_TYPE_MONTH:
-    case ui::TEXT_INPUT_TYPE_WEEK:
-      return Qt::ImhDate;
-    case ui::TEXT_INPUT_TYPE_DATE_TIME:
-    case ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL:
-    case ui::TEXT_INPUT_TYPE_DATE_TIME_FIELD:
-      return Qt::ImhDate | Qt::ImhTime;
-    case ui::TEXT_INPUT_TYPE_TIME:
-      return Qt::ImhTime;
-    default:
-      return Qt::ImhNone;
-  }
-}
-
 static const char* STATE_SERIALIZER_MAGIC_NUMBER = "oxide";
 static uint16_t STATE_SERIALIZER_VERSION = 1;
 
@@ -429,22 +389,12 @@
   QRect rect_;
 };
 
-void WebView::OnInputPanelVisibilityChanged() {
-  view_->InputPanelVisibilityChanged();
-}
-
 WebView::WebView(WebViewProxyClient* client,
                  OxideQSecurityStatus* security_status)
-    : client_(client),
-      has_input_method_state_(false),
+    : input_method_context_(new InputMethodContext(this)),
+      client_(client),
       security_status_(security_status),
-      frame_tree_torn_down_(false) {
-  QInputMethod* im = QGuiApplication::inputMethod();
-  if (im) {
-    connect(im, SIGNAL(visibleChanged()),
-            SLOT(OnInputPanelVisibilityChanged()));
-  }
-}
+      frame_tree_torn_down_(false) {}
 
 float WebView::GetDeviceScaleFactor() const {
   QScreen* screen = client_->GetScreen();
@@ -455,48 +405,6 @@
   return GetDeviceScaleFactorFromQScreen(screen);
 }
 
-bool WebView::ShouldShowInputPanel() const {
-  if (!view_) {
-    // Can be called during WebView construction when |view_| is still null.
-    return false;
-  }
-
-  if (view_->text_input_type() != ui::TEXT_INPUT_TYPE_NONE &&
-      view_->show_ime_if_needed() && view_->focused_node_is_editable()) {
-    return true;
-  }
-
-  return false;
-}
-
-bool WebView::ShouldHideInputPanel() const {
-  if (!view_) {
-    // Can be called during WebView construction when |view_| is still null.
-    return true;
-  }
-
-  if (view_->text_input_type() == ui::TEXT_INPUT_TYPE_NONE &&
-      !view_->focused_node_is_editable()) {
-    return true;
-  }
-
-  return false;
-}
-
-void WebView::SetInputPanelVisibility(bool visible) {
-  client_->SetInputMethodEnabled(visible);
-
-  if (!visible) {
-    has_input_method_state_ = false;
-  }
-
-  // Do not check whether the input method is currently visible here, to avoid
-  // a possible race condition: if hide() and show() are called very quickly
-  // in a row, when show() is called the hide() request might not have
-  // completed yet, and isVisible() could return true.
-  QGuiApplication::inputMethod()->setVisible(visible);
-}
-
 void WebView::CommonInit(OxideQFindController* find_controller) {
   content::WebContents* contents = view_->GetWebContents();
 
@@ -524,6 +432,10 @@
       OxideQWebPreferencesPrivate::get(p)->preferences());
 }
 
+void WebView::SetInputMethodEnabled(bool enabled) {
+  client_->SetInputMethodEnabled(enabled);
+}
+
 blink::WebScreenInfo WebView::GetScreenInfo() const {
   QScreen* screen = client_->GetScreen();
   if (!screen) {
@@ -549,15 +461,6 @@
   return client_->HasFocus();
 }
 
-bool WebView::IsInputPanelVisible() const {
-  QInputMethod* im = QGuiApplication::inputMethod();
-  if (!im) {
-    return false;
-  }
-
-  return im->isVisible();
-}
-
 oxide::JavaScriptDialog* WebView::CreateJavaScriptDialog(
     content::JavaScriptMessageType javascript_message_type) {
   JavaScriptDialogProxyClient::Type type;
@@ -918,77 +821,8 @@
   client_->EvictCurrentFrame();
 }
 
-void WebView::TextInputStateChanged() {
-  if (!HasFocus()) {
-    return;
-  }
-
-  if (view_->text_input_type() != ui::TEXT_INPUT_TYPE_NONE) {
-    QGuiApplication::inputMethod()->update(
-        static_cast<Qt::InputMethodQueries>(Qt::ImQueryInput | Qt::ImHints));
-  }
-
-  if (ShouldShowInputPanel()) {
-    SetInputPanelVisibility(true);
-  } else if (ShouldHideInputPanel()) {
-    SetInputPanelVisibility(false);
-  }
-}
-
-void WebView::FocusedNodeChanged() {
-  // Work around for https://launchpad.net/bugs/1323743
-  if (QGuiApplication::focusWindow() &&
-      QGuiApplication::focusWindow()->focusObject()) {
-    QGuiApplication::focusWindow()->focusObjectChanged(
-        QGuiApplication::focusWindow()->focusObject());
-  }
-
-  if (ShouldHideInputPanel() && HasFocus()) {
-    SetInputPanelVisibility(false);
-  } else if (!has_input_method_state_ && ShouldShowInputPanel()) {
-    SetInputPanelVisibility(true);
-  } else if (has_input_method_state_ && view_->focused_node_is_editable()) {
-    QGuiApplication::inputMethod()->reset();
-  }
-}
-
-void WebView::SelectionBoundsChanged() {
-  if (!HasFocus()) {
-    return;
-  }
-
-  QGuiApplication::inputMethod()->update(
-      static_cast<Qt::InputMethodQueries>(
-        Qt::ImCursorRectangle
-        | Qt::ImCursorPosition
-        | Qt::ImAnchorPosition
-#if QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
-        | Qt::ImTextBeforeCursor
-        | Qt::ImTextAfterCursor
-#endif
-      ));
-}
-
-void WebView::ImeCancelComposition() {
-  if (has_input_method_state_) {
-    QGuiApplication::inputMethod()->reset();
-  }
-}
-
-void WebView::SelectionChanged() {
-  if (!HasFocus()) {
-    return;
-  }
-
-  QGuiApplication::inputMethod()->update(
-      static_cast<Qt::InputMethodQueries>(
-        Qt::ImSurroundingText
-        | Qt::ImCurrentSelection
-#if QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
-        | Qt::ImTextBeforeCursor
-        | Qt::ImTextAfterCursor
-#endif
-      ));
+oxide::InputMethodContext* WebView::GetInputMethodContext() const {
+  return input_method_context_.get();
 }
 
 void WebView::UpdateCursor(const content::WebCursor& cursor) {
@@ -1189,10 +1023,7 @@
 }
 
 void WebView::handleFocusEvent(QFocusEvent* event) {
-  if (event->gotFocus() && ShouldShowInputPanel()) {
-    SetInputPanelVisibility(true);
-  }
-
+  input_method_context_->FocusChanged(event);
   view_->FocusChanged();
 }
 
@@ -1208,62 +1039,7 @@
 }
 
 void WebView::handleInputMethodEvent(QInputMethodEvent* event) {
-  QString commit_string = event->commitString();
-
-  if (!commit_string.isEmpty()) {
-    gfx::Range replacement_range = gfx::Range::InvalidRange();
-    if (event->replacementLength() > 0) {
-      replacement_range.set_start(event->replacementStart());
-      replacement_range.set_end(event->replacementStart() +
-                                event->replacementLength());
-    }
-    view_->ImeCommitText(base::UTF8ToUTF16(commit_string.toStdString()),
-                         replacement_range);
-  }
-
-  QString preedit_string = event->preeditString();
-
-  std::vector<blink::WebCompositionUnderline> underlines;
-  int cursor_position = -1;
-  gfx::Range selection_range = gfx::Range::InvalidRange();
-
-  Q_FOREACH (const QInputMethodEvent::Attribute& attribute, event->attributes()) {
-    switch (attribute.type) {
-    case QInputMethodEvent::Cursor:
-      if (attribute.length > 0) {
-        cursor_position = attribute.start;
-      }
-      break;
-    case QInputMethodEvent::Selection:
-      selection_range.set_start(
-          qMin(attribute.start, (attribute.start + attribute.length)));
-      selection_range.set_end(
-          qMax(attribute.start, (attribute.start + attribute.length)));
-      break;
-    case QInputMethodEvent::TextFormat: {
-      QTextCharFormat format =
-          attribute.value.value<QTextFormat>().toCharFormat();
-      blink::WebColor color = format.underlineColor().rgba();
-      int start = qMin(attribute.start, (attribute.start + attribute.length));
-      int end = qMax(attribute.start, (attribute.start + attribute.length));
-      blink::WebCompositionUnderline underline(
-          start, end, color, false, SK_ColorTRANSPARENT);
-      underlines.push_back(underline);
-      break;
-    }
-    default:
-      break;
-    }
-  }
-
-  if (!selection_range.IsValid()) {
-    selection_range = gfx::Range(
-        cursor_position > 0 ? cursor_position : preedit_string.length());
-  }
-  view_->ImeSetComposingText(base::UTF8ToUTF16(preedit_string.toStdString()),
-                             underlines, selection_range);
-
-  has_input_method_state_ = !preedit_string.isEmpty();
+  input_method_context_->HandleEvent(event);
 }
 
 void WebView::handleKeyEvent(QKeyEvent* event) {
@@ -1313,42 +1089,7 @@
 }
 
 QVariant WebView::inputMethodQuery(Qt::InputMethodQuery query) const {
-  switch (query) {
-    case Qt::ImHints:
-      return QVariant(QImHintsFromInputType(view_->text_input_type()));
-    case Qt::ImCursorRectangle: {
-      // XXX: Is this in the right coordinate space?
-      return QRect(view_->caret_rect().x(), view_->caret_rect().y(),
-                   view_->caret_rect().width(), view_->caret_rect().height());
-    }
-    case Qt::ImCursorPosition:
-      return static_cast<int>(view_->selection_cursor_position() & INT_MAX);
-    case Qt::ImSurroundingText:
-      return QString::fromStdString(base::UTF16ToUTF8(view_->GetSelectionText()));
-    case Qt::ImCurrentSelection:
-      return QString::fromStdString(base::UTF16ToUTF8(view_->GetSelectedText()));
-    case Qt::ImAnchorPosition:
-      return static_cast<int>(view_->selection_anchor_position() & INT_MAX);
-#if QT_VERSION >= QT_VERSION_CHECK(5, 3, 0)
-    case Qt::ImTextBeforeCursor: {
-      std::string text = base::UTF16ToUTF8(view_->GetSelectionText());
-      return QString::fromStdString(
-          text.substr(0, view_->selection_cursor_position()));
-    }
-    case Qt::ImTextAfterCursor: {
-      std::string text = base::UTF16ToUTF8(view_->GetSelectionText());
-      if (view_->selection_cursor_position() > text.length()) {
-        return QString();
-      }
-      return QString::fromStdString(
-          text.substr(view_->selection_cursor_position(), std::string::npos));
-    }
-#endif
-    default:
-      break;
-  }
-
-  return QVariant();
+  return input_method_context_->Query(query);
 }
 
 void WebView::goBack() {
@@ -1689,13 +1430,10 @@
 WebView::~WebView() {
   DCHECK(frame_tree_torn_down_);
 
+  input_method_context_->DetachClient();
+
   oxide::PermissionRequestDispatcher::FromWebContents(
       view_->GetWebContents())->set_client(nullptr);
-
-  QInputMethod* im = QGuiApplication::inputMethod();
-  if (im) {
-    im->disconnect(this);
-  }
 }
 
 // static

=== modified file 'qt/core/browser/oxide_qt_web_view.h'
--- qt/core/browser/oxide_qt_web_view.h	2015-10-16 21:36:30 +0000
+++ qt/core/browser/oxide_qt_web_view.h	2015-10-21 17:31:00 +0000
@@ -20,7 +20,6 @@
 
 #include <QKeyEvent>
 #include <QList>
-#include <QObject>
 #include <QPointer>
 #include <QSharedPointer>
 #include <QtGlobal>
@@ -28,6 +27,7 @@
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 
+#include "qt/core/browser/input/oxide_qt_input_method_context_client.h"
 #include "qt/core/browser/oxide_qt_event_utils.h"
 #include "qt/core/glue/oxide_qt_web_view_proxy.h"
 #include "shared/browser/oxide_javascript_dialog_manager.h"
@@ -53,16 +53,15 @@
 namespace qt {
 
 class CompositorFrameHandle;
+class InputMethodContext;
 class WebContext;
 class WebViewProxyClient;
 
-class WebView : public QObject,
+class WebView : public InputMethodContextClient,
                 public oxide::WebViewClient,
                 public oxide::PermissionRequestDispatcherClient,
                 public oxide::WebFrameTreeObserver,
                 public WebViewProxy {
-  Q_OBJECT
-
  public:
   WebView(WebViewProxyClient* client,
           OxideQFindController* find_controller,
@@ -85,29 +84,24 @@
 
   const oxide::SecurityStatus& GetSecurityStatus() const;
 
- private Q_SLOTS:
-  void OnInputPanelVisibilityChanged();
-
  private:
   WebView(WebViewProxyClient* client,
           OxideQSecurityStatus* security_status);
 
   float GetDeviceScaleFactor() const;
 
-  bool ShouldShowInputPanel() const;
-  bool ShouldHideInputPanel() const;
-  void SetInputPanelVisibility(bool visible);
-
   void CommonInit(OxideQFindController* find_controller);
 
   void EnsurePreferences();
 
+  // InputMethodContextClient implementation
+  void SetInputMethodEnabled(bool enabled);
+
   // oxide::WebViewClient implementation
   blink::WebScreenInfo GetScreenInfo() const override;
   gfx::Rect GetViewBoundsPix() const override;
   bool IsVisible() const override;
   bool HasFocus() const override;
-  bool IsInputPanelVisible() const override;
   oxide::JavaScriptDialog* CreateJavaScriptDialog(
       content::JavaScriptMessageType javascript_message_type) override;
   oxide::JavaScriptDialog* CreateBeforeUnloadDialog() override;
@@ -169,11 +163,7 @@
   oxide::FilePicker* CreateFilePicker(content::RenderViewHost* rvh) override;
   void SwapCompositorFrame() override;
   void EvictCurrentFrame() override;
-  void TextInputStateChanged() override;
-  void FocusedNodeChanged() override;
-  void SelectionBoundsChanged() override;
-  void ImeCancelComposition() override;
-  void SelectionChanged() override;
+  oxide::InputMethodContext* GetInputMethodContext() const override;
   void UpdateCursor(const content::WebCursor& cursor) override;
   void SecurityStatusChanged(const oxide::SecurityStatus& old) override;
   void OnCertificateError(scoped_ptr<oxide::CertificateError> error) override;
@@ -293,12 +283,13 @@
 
   void teardownFrameTree() override;
 
+  // This must outlive |view_|
+  scoped_ptr<InputMethodContext> input_method_context_;
+
   scoped_ptr<oxide::WebView> view_;
 
   WebViewProxyClient* client_;
 
-  bool has_input_method_state_;
-
   QPointer<OxideQSecurityStatus> security_status_;
   QList<ScriptMessageHandlerProxyHandle*> message_handlers_;
 

=== modified file 'qt/core/core.gyp'
--- qt/core/core.gyp	2015-09-20 08:39:19 +0000
+++ qt/core/core.gyp	2015-10-21 17:31:00 +0000
@@ -61,13 +61,16 @@
       ],
       'sources': [
         '<(INTERMEDIATE_DIR)/moc_oxide_qt_browser_platform_integration.cc',
-        '<(INTERMEDIATE_DIR)/moc_oxide_qt_web_view.cc',
+        '<(INTERMEDIATE_DIR)/moc_oxide_qt_input_method_context.cc',
         'api/internal/oxideqmediacapturedevices_p.cc',
         'api/internal/oxideqwebpreferences_p.cc',
         'app/oxide_qt_main.cc',
         'app/oxide_qt_main.h',
         'app/oxide_qt_platform_delegate.cc',
         'app/oxide_qt_platform_delegate.h',
+        'browser/input/oxide_qt_input_method_context.cc',
+        'browser/input/oxide_qt_input_method_context.h',
+        'browser/input/oxide_qt_input_method_context_client.h',
         'browser/oxide_qt_browser_platform_integration.cc',
         'browser/oxide_qt_browser_platform_integration.h',
         'browser/oxide_qt_browser_startup.cc',
@@ -179,8 +182,8 @@
           'includes': [ 'moc.gypi' ]
         },
         {
-          'action_name': 'moc_oxide_qt_web_view.cc',
-          'moc_input': 'browser/oxide_qt_web_view.h',
+          'action_name': 'moc_oxide_qt_input_method_context.cc',
+          'moc_input': 'browser/input/oxide_qt_input_method_context.h',
           'includes': [ 'moc.gypi' ]
         },
       ],

=== modified file 'shared/browser/compositor/oxide_compositor.cc'
--- shared/browser/compositor/oxide_compositor.cc	2015-10-09 09:27:28 +0000
+++ shared/browser/compositor/oxide_compositor.cc	2015-10-21 17:31:00 +0000
@@ -40,6 +40,7 @@
 #include "oxide_compositor_client.h"
 #include "oxide_compositor_frame_data.h"
 #include "oxide_compositor_frame_handle.h"
+#include "oxide_compositor_observer.h"
 #include "oxide_compositor_output_surface_gl.h"
 #include "oxide_compositor_output_surface_software.h"
 #include "oxide_compositor_software_output_device.h"
@@ -87,7 +88,6 @@
       root_layer_(cc::Layer::Create(cc::LayerSettings())),
       proxy_(new CompositorThreadProxy(this)),
       next_output_surface_id_(1),
-      lock_count_(0),
       weak_factory_(this) {
   DCHECK(CalledOnValidThread());
 }
@@ -103,29 +103,6 @@
   client_->CompositorSwapFrame(handle.get());
 }
 
-void Compositor::LockCompositor() {
-  DCHECK(CalledOnValidThread());
-  if (lock_count_++ > 0) {
-    return;
-  }
-
-  if (layer_tree_host_) {
-    layer_tree_host_->SetDeferCommits(true);
-  }
-}
-
-void Compositor::UnlockCompositor() {
-  DCHECK(CalledOnValidThread());
-  DCHECK(lock_count_ > 0);
-  if (--lock_count_ > 0) {
-    return;
-  }
-
-  if (layer_tree_host_) {
-    layer_tree_host_->SetDeferCommits(false);
-  }
-}
-
 scoped_ptr<cc::OutputSurface> Compositor::CreateOutputSurface() {
   DCHECK(CalledOnValidThread());
 
@@ -155,6 +132,14 @@
   return output.Pass();
 }
 
+void Compositor::AddObserver(CompositorObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void Compositor::RemoveObserver(CompositorObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 void Compositor::WillBeginMainFrame() {}
 void Compositor::BeginMainFrame(const cc::BeginFrameArgs& args) {}
 void Compositor::BeginMainFrameNotExpectedSoon() {}
@@ -194,7 +179,7 @@
 void Compositor::WillCommit() {}
 
 void Compositor::DidCommit() {
-  client_->CompositorDidCommit();
+  FOR_EACH_OBSERVER(CompositorObserver, observers_, CompositorDidCommit());
 }
 
 void Compositor::DidCommitAndDrawFrame() {}
@@ -214,7 +199,7 @@
 }
 
 Compositor::~Compositor() {
-  CHECK_EQ(lock_count_, 0U);
+  FOR_EACH_OBSERVER(CompositorObserver, observers_, OnCompositorDestruction());
   proxy_->CompositorDestroyed();
 }
 
@@ -249,15 +234,15 @@
     layer_tree_host_->SetVisible(true);
     layer_tree_host_->SetViewportSize(size_);
     layer_tree_host_->SetDeviceScaleFactor(device_scale_factor_);
-
-    if (lock_count_ > 0) {
-      layer_tree_host_->SetDeferCommits(true);
-    }
   }
 }
 
 void Compositor::SetDeviceScaleFactor(float scale) {
   DCHECK(CalledOnValidThread());
+  if (scale == device_scale_factor_) {
+    return;
+  }
+
   device_scale_factor_ = scale;
 
   if (layer_tree_host_) {
@@ -281,6 +266,7 @@
 
 void Compositor::SetRootLayer(scoped_refptr<cc::Layer> layer) {
   DCHECK(CalledOnValidThread());
+
   root_layer_->RemoveAllChildren();
   if (layer.get()) {
     root_layer_->AddChild(layer);

=== modified file 'shared/browser/compositor/oxide_compositor.h'
--- shared/browser/compositor/oxide_compositor.h	2015-08-14 16:32:46 +0000
+++ shared/browser/compositor/oxide_compositor.h	2015-10-21 17:31:00 +0000
@@ -23,6 +23,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
 #include "base/threading/non_thread_safe.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "ui/gfx/geometry/size.h"
@@ -41,7 +42,7 @@
 class CompositorClient;
 class CompositorFrameData;
 class CompositorFrameHandle;
-class CompositorLock;
+class CompositorObserver;
 class CompositorThreadProxy;
 
 class Compositor final : public cc::LayerTreeHostClient,
@@ -63,18 +64,18 @@
                               FrameHandleVector returned_frames);
 
  private:
-  friend class CompositorLock;
+  friend class CompositorObserver;
   friend class CompositorThreadProxy;
 
   Compositor(CompositorClient* client);
 
   void SendSwapCompositorFrameToClient(scoped_ptr<CompositorFrameData> frame);
 
-  void LockCompositor();
-  void UnlockCompositor();
-
   scoped_ptr<cc::OutputSurface> CreateOutputSurface();
 
+  void AddObserver(CompositorObserver* observer);
+  void RemoveObserver(CompositorObserver* observer);
+
   // cc::LayerTreeHostClient implementation
   void WillBeginMainFrame() final;
   void BeginMainFrame(const cc::BeginFrameArgs& args) final;
@@ -112,34 +113,13 @@
 
   uint32 next_output_surface_id_;
 
-  uint32 lock_count_;
+  base::ObserverList<CompositorObserver> observers_;
 
   base::WeakPtrFactory<Compositor> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
-class CompositorLock final {
- public:
-  CompositorLock(Compositor* compositor)
-      : compositor_(compositor) {
-    if (compositor_) {
-      compositor_->LockCompositor();
-    }
-  }
-
-  ~CompositorLock() {
-    if (compositor_) {
-      compositor_->UnlockCompositor();
-    }
-  }
-
- private:
-  Compositor* compositor_;
-
-  DISALLOW_COPY_AND_ASSIGN(CompositorLock);
-};
-
 } // namespace oxide
 
 #endif // _OXIDE_SHARED_BROWSER_COMPOSITOR_COMPOSITOR_H_

=== modified file 'shared/browser/compositor/oxide_compositor_client.h'
--- shared/browser/compositor/oxide_compositor_client.h	2015-08-14 16:32:46 +0000
+++ shared/browser/compositor/oxide_compositor_client.h	2015-10-21 17:31:00 +0000
@@ -28,8 +28,6 @@
  public:
   virtual ~CompositorClient() {}
 
-  virtual void CompositorDidCommit() = 0;
-
   virtual void CompositorSwapFrame(CompositorFrameHandle* handle) = 0;
 };
 

=== added file 'shared/browser/compositor/oxide_compositor_observer.cc'
--- shared/browser/compositor/oxide_compositor_observer.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/compositor/oxide_compositor_observer.cc	2015-10-21 17:31:00 +0000
@@ -0,0 +1,60 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_compositor_observer.h"
+
+#include "oxide_compositor.h"
+
+namespace oxide {
+
+CompositorObserver::CompositorObserver()
+    : compositor_(nullptr) {}
+
+CompositorObserver::CompositorObserver(Compositor* compositor)
+    : compositor_(compositor) {
+  if (compositor_) {
+    compositor_->AddObserver(this);
+  }
+}
+
+void CompositorObserver::Observe(Compositor* compositor) {
+  if (compositor == compositor_) {
+    return;
+  }
+
+  if (compositor_) {
+    compositor_->RemoveObserver(this);
+  }
+  compositor_ = compositor;
+  if (compositor_) {
+    compositor_->AddObserver(this);
+  }
+}
+
+void CompositorObserver::OnCompositorDestruction() {
+  compositor_ = nullptr;
+}
+
+CompositorObserver::~CompositorObserver() {
+  if (compositor_) {
+    compositor_->RemoveObserver(this);
+  }
+}
+
+void CompositorObserver::CompositorDidCommit() {}
+
+} // namespace oxide

=== added file 'shared/browser/compositor/oxide_compositor_observer.h'
--- shared/browser/compositor/oxide_compositor_observer.h	1970-01-01 00:00:00 +0000
+++ shared/browser/compositor/oxide_compositor_observer.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,49 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_BROWSER_COMPOSITOR_COMPOSITOR_OBSERVER_H_
+#define _OXIDE_SHARED_BROWSER_COMPOSITOR_COMPOSITOR_OBSERVER_H_
+
+namespace oxide {
+
+class Compositor;
+
+class CompositorObserver {
+ public:
+  virtual ~CompositorObserver();
+
+  virtual void CompositorDidCommit();
+
+ protected:
+  CompositorObserver();
+  CompositorObserver(Compositor* compositor);
+
+  void Observe(Compositor* compositor);
+
+  Compositor* compositor() const { return compositor_; }
+
+ private:
+  friend class Compositor;
+
+  void OnCompositorDestruction();
+
+  Compositor* compositor_;
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_BROWSER_COMPOSITOR_COMPOSITOR_OBSERVER_H_

=== added directory 'shared/browser/input'
=== added file 'shared/browser/input/oxide_ime_bridge.cc'
--- shared/browser/input/oxide_ime_bridge.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_ime_bridge.cc	2015-10-21 17:31:00 +0000
@@ -0,0 +1,31 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_ime_bridge.h"
+
+namespace oxide {
+
+ImeBridge::ImeBridge()
+    : text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
+      show_ime_if_needed_(false),
+      selection_cursor_position_(0),
+      selection_anchor_position_(0),
+      focused_node_is_editable_(false) {}
+
+ImeBridge::~ImeBridge() {}
+
+} // namespace oxide

=== added file 'shared/browser/input/oxide_ime_bridge.h'
--- shared/browser/input/oxide_ime_bridge.h	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_ime_bridge.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,84 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_BROWSER_INPUT_IME_BRIDGE_H_
+#define _OXIDE_SHARED_BROWSER_INPUT_IME_BRIDGE_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/strings/string16.h"
+#include "third_party/WebKit/public/web/WebCompositionUnderline.h"
+#include "ui/base/ime/text_input_type.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace gfx {
+class Range;
+}
+
+namespace oxide {
+
+// This class contains state for a particular RWHV. InputMethodContext is
+// connected to one ImeBridge
+class ImeBridge {
+ public:
+  ImeBridge();
+  virtual ~ImeBridge();
+
+  ui::TextInputType text_input_type() const { return text_input_type_; }
+
+  bool show_ime_if_needed() const { return show_ime_if_needed_; }
+
+  gfx::Rect caret_rect() const { return caret_rect_; }
+
+  size_t selection_cursor_position() const {
+    return selection_cursor_position_;
+  }
+
+  size_t selection_anchor_position() const {
+    return selection_anchor_position_;
+  }
+
+  bool focused_node_is_editable() const {
+    return focused_node_is_editable_;
+  }
+
+  virtual base::string16 GetSelectionText() const = 0;
+  virtual base::string16 GetSelectedText() const = 0;
+
+  virtual void CommitText(const base::string16& text,
+                          const gfx::Range& replacement_range) = 0;
+  virtual void SetComposingText(
+      const base::string16& text,
+      const std::vector<blink::WebCompositionUnderline>& underlines,
+      const gfx::Range& selection_range) = 0;
+
+ protected:
+  ui::TextInputType text_input_type_;
+  bool show_ime_if_needed_;
+  gfx::Rect caret_rect_;
+  size_t selection_cursor_position_;
+  size_t selection_anchor_position_;
+  bool focused_node_is_editable_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ImeBridge);
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_BROWSER_INPUT_IME_BRIDGE_H_

=== added file 'shared/browser/input/oxide_ime_bridge_impl.cc'
--- shared/browser/input/oxide_ime_bridge_impl.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_ime_bridge_impl.cc	2015-10-21 17:31:00 +0000
@@ -0,0 +1,157 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_ime_bridge_impl.h"
+
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/public/browser/native_web_keyboard_event.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/events/keycodes/keyboard_codes.h"
+
+#include "shared/browser/oxide_render_widget_host_view.h"
+
+#include "oxide_input_method_context.h"
+
+namespace oxide {
+
+namespace {
+
+// Qt input methods don’t generate key events, but a lot of web pages out there
+// rely on keydown and keyup events to e.g. perform search-as-you-type or
+// enable/disable a submit button based on the contents of a text input field,
+// so we send a fake pair of keydown/keyup events.
+// This mimicks what is done in GtkIMContextWrapper::HandlePreeditChanged(…)
+// and GtkIMContextWrapper::HandleCommit(…)
+// (see content/browser/renderer_host/gtk_im_context_wrapper.cc).
+void SendFakeCompositionKeyEvent(content::RenderWidgetHostImpl* host,
+                                 blink::WebInputEvent::Type type) {
+  content::NativeWebKeyboardEvent fake_event;
+  fake_event.windowsKeyCode = ui::VKEY_PROCESSKEY;
+  fake_event.skip_in_browser = true;
+  fake_event.type = type;
+  host->ForwardKeyboardEvent(fake_event);
+}
+
+}
+
+base::string16 ImeBridgeImpl::GetSelectionText() const {
+  return rwhv_->selection_text();
+}
+
+base::string16 ImeBridgeImpl::GetSelectedText() const {
+  return rwhv_->GetSelectedText();
+}
+
+void ImeBridgeImpl::CommitText(const base::string16& text,
+                               const gfx::Range& replacement_range) {
+  if (!rwhv_->host()) {
+    return;
+  }
+
+  SendFakeCompositionKeyEvent(rwhv_->host(), blink::WebInputEvent::RawKeyDown);
+  rwhv_->host()->ImeConfirmComposition(text, replacement_range, false);
+  SendFakeCompositionKeyEvent(rwhv_->host(), blink::WebInputEvent::KeyUp);
+}
+
+void ImeBridgeImpl::SetComposingText(
+    const base::string16& text,
+    const std::vector<blink::WebCompositionUnderline>& underlines,
+    const gfx::Range& selection_range) {
+  if (!rwhv_->host()) {
+    return;
+  }
+
+  SendFakeCompositionKeyEvent(rwhv_->host(), blink::WebInputEvent::RawKeyDown);
+  rwhv_->host()->ImeSetComposition(text,
+                                   underlines,
+                                   selection_range.start(),
+                                   selection_range.end());
+  SendFakeCompositionKeyEvent(rwhv_->host(), blink::WebInputEvent::KeyUp);
+}
+
+ImeBridgeImpl::ImeBridgeImpl(RenderWidgetHostView* rwhv)
+    : rwhv_(rwhv),
+      context_(nullptr) {}
+
+ImeBridgeImpl::~ImeBridgeImpl() {
+  SetContext(nullptr);
+}
+
+void ImeBridgeImpl::SetContext(InputMethodContext* context) {
+  if (context_) {
+    DCHECK_EQ(context_->ime_bridge(), this);
+    context_->SetImeBridge(nullptr);
+  }
+  context_ = context;
+  if (context_) {
+    DCHECK(!context_->ime_bridge());
+    context_->SetImeBridge(this);
+  }
+}
+
+void ImeBridgeImpl::TextInputStateChanged(ui::TextInputType type,
+                                          bool show_ime_if_needed) {
+  if (type == text_input_type_ &&
+      show_ime_if_needed == show_ime_if_needed_) {
+    return;
+  }
+
+  text_input_type_ = type;
+  show_ime_if_needed_ = show_ime_if_needed;
+
+  if (!context_) {
+    return;
+  }
+
+  context_->TextInputStateChanged();
+}
+
+void ImeBridgeImpl::SelectionBoundsChanged(const gfx::Rect& caret_rect,
+                                           size_t selection_cursor_position,
+                                           size_t selection_anchor_position) {
+  if (caret_rect == caret_rect_ &&
+      selection_cursor_position == selection_cursor_position_ &&
+      selection_anchor_position == selection_anchor_position_) {
+    return;
+  }
+
+  caret_rect_ = caret_rect;
+  selection_cursor_position_ = selection_cursor_position;
+  selection_anchor_position_ = selection_anchor_position;
+
+  if (!context_) {
+    return;
+  }
+
+  context_->SelectionBoundsChanged();
+}
+
+void ImeBridgeImpl::FocusedNodeChanged(bool is_editable_node) {
+  if (is_editable_node == focused_node_is_editable_) {
+    return;
+  }
+
+  focused_node_is_editable_ = is_editable_node;
+
+  if (!context_) {
+    return;
+  }
+
+  context_->FocusedNodeChanged();
+}
+
+} // namespace oxide

=== added file 'shared/browser/input/oxide_ime_bridge_impl.h'
--- shared/browser/input/oxide_ime_bridge_impl.h	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_ime_bridge_impl.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,69 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_BROWSER_INPUT_IME_BRIDGE_IMPL_H_
+#define _OXIDE_SHARED_BROWSER_INPUT_IME_BRIDGE_IMPL_H_
+
+#include "base/macros.h"
+#include "ui/base/ime/text_input_type.h"
+
+#include "shared/browser/input/oxide_ime_bridge.h"
+
+namespace gfx {
+class Rect;
+}
+
+namespace oxide {
+
+class InputMethodContext;
+class RenderWidgetHostView;
+
+class ImeBridgeImpl : public ImeBridge {
+ public:
+  ImeBridgeImpl(RenderWidgetHostView* rwhv);
+  ~ImeBridgeImpl() override;
+
+  InputMethodContext* context() const { return context_; }
+  void SetContext(InputMethodContext* context);
+
+  void TextInputStateChanged(ui::TextInputType type,
+                             bool show_ime_if_needed);
+  void SelectionBoundsChanged(const gfx::Rect& caret_rect,
+                              size_t selection_cursor_position,
+                              size_t selection_anchor_position);
+  void FocusedNodeChanged(bool is_editable_node);
+
+ private:
+  base::string16 GetSelectionText() const override;
+  base::string16 GetSelectedText() const override;
+  void CommitText(const base::string16& text,
+                  const gfx::Range& replacement_range) override;
+  void SetComposingText(
+      const base::string16& text,
+      const std::vector<blink::WebCompositionUnderline>& underlines,
+      const gfx::Range& selection_range) override;
+
+  RenderWidgetHostView* rwhv_; // Owns us
+
+  InputMethodContext* context_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImeBridgeImpl);
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_BROWSER_INPUT_IME_BRIDGE_IMPL_H_

=== added file 'shared/browser/input/oxide_input_method_context.cc'
--- shared/browser/input/oxide_input_method_context.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_input_method_context.cc	2015-10-21 17:31:00 +0000
@@ -0,0 +1,69 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_input_method_context.h"
+
+#include "oxide_input_method_context_observer.h"
+
+namespace oxide {
+
+void InputMethodContext::NotifyInputPanelVisibilityChanged() {
+  FOR_EACH_OBSERVER(InputMethodContextObserver,
+                    observers_,
+                    InputPanelVisibilityChanged());
+}
+
+void InputMethodContext::SetImeBridge(ImeBridge* bridge) {
+  ime_bridge_ = bridge;
+
+  CancelComposition();
+
+  // XXX: This is a bit of a hammer
+  TextInputStateChanged();
+  SelectionBoundsChanged();
+  SelectionChanged();
+  FocusedNodeChanged();
+}
+
+void InputMethodContext::AddObserver(InputMethodContextObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void InputMethodContext::RemoveObserver(InputMethodContextObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+InputMethodContext::InputMethodContext()
+    : ime_bridge_(nullptr) {}
+
+InputMethodContext::~InputMethodContext() {
+  FOR_EACH_OBSERVER(InputMethodContextObserver,
+                    observers_,
+                    OnInputMethodContextDestruction());
+}
+
+bool InputMethodContext::IsInputPanelVisible() const {
+  return false;
+}
+
+void InputMethodContext::TextInputStateChanged() {}
+void InputMethodContext::SelectionBoundsChanged() {}
+void InputMethodContext::SelectionChanged() {}
+void InputMethodContext::CancelComposition() {}
+void InputMethodContext::FocusedNodeChanged() {}
+
+} // namespace oxide

=== added file 'shared/browser/input/oxide_input_method_context.h'
--- shared/browser/input/oxide_input_method_context.h	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_input_method_context.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,69 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_BROWSER_INPUT_INPUT_METHOD_CONTEXT_H_
+#define _OXIDE_SHARED_BROWSER_INPUT_INPUT_METHOD_CONTEXT_H_
+
+#include "base/macros.h"
+#include "base/observer_list.h"
+
+namespace oxide {
+
+class ImeBridge;
+class ImeBridgeImpl;
+class InputMethodContextObserver;
+
+// This class is the interface from ImeBridgeImpl to the toolkit provided
+// input method context, and provides a way for the toolkit layer to access
+// the currently connected ImeBridge
+class InputMethodContext {
+ public:
+  InputMethodContext();
+  virtual ~InputMethodContext();
+
+  virtual bool IsInputPanelVisible() const;
+
+  virtual void TextInputStateChanged();
+  virtual void SelectionBoundsChanged();
+  virtual void SelectionChanged();
+  virtual void CancelComposition();
+  virtual void FocusedNodeChanged();
+
+ protected:
+  ImeBridge* ime_bridge() const { return ime_bridge_; }
+
+  void NotifyInputPanelVisibilityChanged();
+
+ private:
+  friend class ImeBridgeImpl;
+  friend class InputMethodContextObserver;
+
+  void SetImeBridge(ImeBridge* bridge);
+
+  void AddObserver(InputMethodContextObserver* observer);
+  void RemoveObserver(InputMethodContextObserver* observer);
+
+  ImeBridge* ime_bridge_;
+
+  base::ObserverList<InputMethodContextObserver> observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(InputMethodContext);
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_BROWSER_INPUT_INPUT_METHOD_CONTEXT_H_

=== added file 'shared/browser/input/oxide_input_method_context_observer.cc'
--- shared/browser/input/oxide_input_method_context_observer.cc	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_input_method_context_observer.cc	2015-10-21 17:31:00 +0000
@@ -0,0 +1,61 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include "oxide_input_method_context_observer.h"
+
+#include "oxide_input_method_context.h"
+
+namespace oxide {
+
+InputMethodContextObserver::InputMethodContextObserver()
+    : im_context_(nullptr) {}
+
+InputMethodContextObserver::InputMethodContextObserver(
+    InputMethodContext* context)
+    : im_context_(context) {
+  if (context) {
+    context->AddObserver(this);
+  }
+}
+
+void InputMethodContextObserver::Observe(InputMethodContext* context) {
+  if (context == im_context_) {
+    return;
+  }
+
+  if (im_context_) {
+    im_context_->RemoveObserver(this);
+  }
+  im_context_ = context;
+  if (im_context_) {
+    im_context_->AddObserver(this);
+  }
+}
+
+void InputMethodContextObserver::OnInputMethodContextDestruction() {
+  im_context_ = nullptr;
+}
+
+InputMethodContextObserver::~InputMethodContextObserver() {
+  if (im_context_) {
+    im_context_->RemoveObserver(this);
+  }
+}
+
+void InputMethodContextObserver::InputPanelVisibilityChanged() {}
+
+} // namespace oxide

=== added file 'shared/browser/input/oxide_input_method_context_observer.h'
--- shared/browser/input/oxide_input_method_context_observer.h	1970-01-01 00:00:00 +0000
+++ shared/browser/input/oxide_input_method_context_observer.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,49 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_BROWSER_INPUT_INPUT_METHOD_CONTEXT_OBSERVER_H_
+#define _OXIDE_SHARED_BROWSER_INPUT_INPUT_METHOD_CONTEXT_OBSERVER_H_
+
+namespace oxide {
+
+class InputMethodContext;
+
+class InputMethodContextObserver {
+ public:
+  virtual ~InputMethodContextObserver();
+
+  virtual void InputPanelVisibilityChanged();
+
+ protected:
+  InputMethodContextObserver();
+  InputMethodContextObserver(InputMethodContext* context);
+
+  void Observe(InputMethodContext* context);
+
+  InputMethodContext* im_context() const { return im_context_; }
+
+ private:
+  friend class InputMethodContext;
+
+  void OnInputMethodContextDestruction();
+
+  InputMethodContext* im_context_;
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_BROWSER_INPUT_INPUT_METHOD_CONTEXT_OBSERVER_H_

=== modified file 'shared/browser/oxide_render_widget_host_view.cc'
--- shared/browser/oxide_render_widget_host_view.cc	2015-09-29 08:25:11 +0000
+++ shared/browser/oxide_render_widget_host_view.cc	2015-10-21 17:31:00 +0000
@@ -40,13 +40,13 @@
 #include "ui/gfx/geometry/size_conversions.h"
 
 #include "shared/browser/compositor/oxide_compositor.h"
-#include "shared/browser/compositor/oxide_compositor_utils.h"
+#include "shared/browser/input/oxide_input_method_context.h"
 
 #include "oxide_browser_platform_integration.h"
 #include "oxide_browser_process_main.h"
 #include "oxide_event_utils.h"
 #include "oxide_renderer_frame_evictor.h"
-#include "oxide_render_widget_host_view_delegate.h"
+#include "oxide_render_widget_host_view_container.h"
 
 namespace oxide {
 
@@ -81,43 +81,35 @@
 void RenderWidgetHostView::OnTextInputStateChanged(
     ui::TextInputType type,
     bool show_ime_if_needed) {
-  if (type != current_text_input_type_ ||
-      show_ime_if_needed != show_ime_if_needed_) {
-    current_text_input_type_ = type;
-    show_ime_if_needed_ = show_ime_if_needed;
-
-    if (delegate_) {
-      delegate_->TextInputStateChanged(current_text_input_type_,
-                                       show_ime_if_needed_);
-    }
-  }
+  ime_bridge_.TextInputStateChanged(type, show_ime_if_needed);
 }
 
 void RenderWidgetHostView::OnSelectionBoundsChanged(
     const gfx::Rect& anchor_rect,
     const gfx::Rect& focus_rect,
     bool is_anchor_first) {
-  caret_rect_ = gfx::UnionRects(anchor_rect, focus_rect);
+  gfx::Rect caret_rect = gfx::UnionRects(anchor_rect, focus_rect);
+
+  size_t selection_cursor_position = 0;
+  size_t selection_anchor_position = 0;
 
   if (selection_range_.IsValid()) {
     if (is_anchor_first) {
-      selection_cursor_position_ =
+      selection_cursor_position =
           selection_range_.GetMax() - selection_text_offset_;
-      selection_anchor_position_ =
+      selection_anchor_position =
           selection_range_.GetMin() - selection_text_offset_;
     } else {
-      selection_cursor_position_ =
+      selection_cursor_position =
           selection_range_.GetMin() - selection_text_offset_;
-      selection_anchor_position_ =
+      selection_anchor_position =
           selection_range_.GetMax() - selection_text_offset_;
     }
   }
 
-  if (delegate_) {
-    delegate_->SelectionBoundsChanged(caret_rect_,
-                                      selection_cursor_position_,
-                                      selection_anchor_position_);
-  }
+  ime_bridge_.SelectionBoundsChanged(caret_rect,
+                                     selection_cursor_position,
+                                     selection_anchor_position);
 }
 
 void RenderWidgetHostView::SelectionChanged(const base::string16& text,
@@ -136,17 +128,17 @@
 
   content::RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 
-  if (delegate_) {
-    delegate_->SelectionChanged();
+  if (ime_bridge_.context()) {
+    ime_bridge_.context()->SelectionChanged();
   }
 }
 
 gfx::Size RenderWidgetHostView::GetPhysicalBackingSize() const {
-  if (!delegate_) {
+  if (!container_) {
     return gfx::Size();
   }
 
-  return delegate_->GetViewSizePix();
+  return container_->GetViewSizePix();
 }
 
 bool RenderWidgetHostView::DoTopControlsShrinkBlinkSize() const {
@@ -154,18 +146,15 @@
 }
 
 float RenderWidgetHostView::GetTopControlsHeight() const {
-  if (!delegate_) {
+  if (!container_) {
     return 0.0f;
   }
 
-  return delegate_->GetLocationBarHeightDip();
+  return container_->GetLocationBarHeightDip();
 }
 
 void RenderWidgetHostView::FocusedNodeChanged(bool is_editable_node) {
-  focused_node_is_editable_ = is_editable_node;
-  if (delegate_) {
-    delegate_->FocusedNodeChanged(is_editable_node);
-  }
+  ime_bridge_.FocusedNodeChanged(is_editable_node);
 }
 
 void RenderWidgetHostView::OnSwapCompositorFrame(
@@ -186,9 +175,6 @@
     return;
   }
 
-  Compositor* compositor = delegate_ ? delegate_->GetCompositor() : nullptr;
-  CompositorLock lock(compositor);
-
   if (output_surface_id != last_output_surface_id_) {
     resource_collection_->SetClient(nullptr);
     if (resource_collection_->LoseAllResources()) {
@@ -228,10 +214,16 @@
         frame_size != frame_provider_->frame_size() ||
         frame_size_dip != last_frame_size_dip_) {
       DetachLayer();
+
       frame_provider_ = new cc::DelegatedFrameProvider(resource_collection_,
                                                        frame_data.Pass());
       layer_ = cc::DelegatedRendererLayer::Create(cc::LayerSettings(),
                                                   frame_provider_);
+      layer_->SetIsDrawable(true);
+      layer_->SetContentsOpaque(true);
+      layer_->SetBounds(frame_size_dip);
+      layer_->SetHideLayerAndSubtree(!is_showing_);
+
       AttachLayer();
     } else {
       frame_provider_->SetFrameData(frame_data.Pass());
@@ -241,15 +233,12 @@
   last_frame_size_dip_ = frame_size_dip;
 
   if (layer_.get()) {
-    layer_->SetIsDrawable(true);
-    layer_->SetContentsOpaque(true);
-    layer_->SetBounds(frame_size_dip);
     layer_->SetNeedsDisplayRect(damage_rect_dip);
   }
 
   if (frame_is_evicted_) {
     frame_is_evicted_ = false;
-    RendererFrameEvictor::GetInstance()->AddFrame(this, IsShowing());
+    RendererFrameEvictor::GetInstance()->AddFrame(this, is_showing_);
   }
 
   compositor_frame_metadata_ = frame->metadata;
@@ -267,6 +256,7 @@
   gesture_provider_->SetDoubleTapSupportForPageEnabled(
       !has_fixed_page_scale && !has_mobile_viewport);
 
+  Compositor* compositor = container_->GetCompositor();
   if (!compositor || !compositor->IsActive()) {
     RunAckCallbacks();
   }
@@ -291,12 +281,17 @@
     const std::vector<content::WebPluginGeometry>& moves) {}
 
 void RenderWidgetHostView::UpdateCursor(const content::WebCursor& cursor) {
-  if (cursor.IsEqual(current_cursor_)) {
-    return;
-  }
-
-  current_cursor_ = cursor;
-  UpdateCursorOnWebView();
+  if (cursor.IsEqual(web_cursor_)) {
+    return;
+  }
+
+  web_cursor_ = cursor;
+
+  if (is_loading_) {
+    return;
+  }
+
+  UpdateCurrentCursor();
 }
 
 void RenderWidgetHostView::SetIsLoading(bool is_loading) {
@@ -305,15 +300,15 @@
   }
 
   is_loading_ = is_loading;
-  UpdateCursorOnWebView();
+  UpdateCurrentCursor();
 }
 
 void RenderWidgetHostView::ImeCancelComposition() {
-  if (!delegate_) {
+  if (!ime_bridge_.context()) {
     return;
   }
 
-  delegate_->ImeCancelComposition();
+  ime_bridge_.context()->CancelComposition();
 }
 
 void RenderWidgetHostView::RenderProcessGone(base::TerminationStatus status,
@@ -354,13 +349,13 @@
 }
 
 void RenderWidgetHostView::GetScreenInfo(blink::WebScreenInfo* result) {
-  if (!delegate_) {
+  if (!container_) {
     *result =
         BrowserPlatformIntegration::GetInstance()->GetDefaultScreenInfo();
     return;
   }
 
-  *result = delegate_->GetScreenInfo();
+  *result = container_->GetScreenInfo();
 }
 
 bool RenderWidgetHostView::GetScreenColorProfile(
@@ -412,11 +407,11 @@
 }
 
 bool RenderWidgetHostView::HasFocus() const {
-  if (!delegate_) {
+  if (!container_) {
     return false;
   }
 
-  return delegate_->HasFocus();
+  return container_->HasFocus(this);
 }
 
 bool RenderWidgetHostView::IsSurfaceAvailableForCopy() const {
@@ -425,20 +420,22 @@
 
 void RenderWidgetHostView::Show() {
   if (is_showing_) {
-    DCHECK(delegate_);
-    return;
-  }
-
-  if (!delegate_) {
-    return;
-  }
-
+    return;
+  }
   is_showing_ = true;
 
+  if (layer_.get()) {
+    layer_->SetHideLayerAndSubtree(false);
+  }
+
   if (!frame_is_evicted_) {
     RendererFrameEvictor::GetInstance()->LockFrame(this);
   }
 
+  if (!host_ || !host_->is_hidden()) {
+    return;
+  }
+
   host_->WasShown(ui::LatencyInfo());
 }
 
@@ -446,30 +443,36 @@
   if (!is_showing_) {
     return;
   }
-
   is_showing_ = false;
 
+  if (layer_.get()) {
+    layer_->SetHideLayerAndSubtree(true);
+  }
+
   if (!frame_is_evicted_) {
     RendererFrameEvictor::GetInstance()->UnlockFrame(this);
   }
 
+  RunAckCallbacks();
+
+  if (!host_ || host_->is_hidden()) {
+    return;
+  }
+
   host_->WasHidden();
-
-  RunAckCallbacks();
 }
 
 bool RenderWidgetHostView::IsShowing() {
-  DCHECK(!is_showing_ || delegate_);
-  return is_showing_;
+  return is_showing_ && container_ && container_->IsVisible();
 }
 
 gfx::Rect RenderWidgetHostView::GetViewBounds() const {
   gfx::Rect bounds;
 
-  if (!delegate_) {
+  if (!container_) {
     bounds = gfx::Rect(last_size_);
   } else {
-    bounds = delegate_->GetViewBoundsDip();
+    bounds = container_->GetViewBoundsDip();
   }
 
   if (DoTopControlsShrinkBlinkSize()) {
@@ -485,6 +488,10 @@
 
 void RenderWidgetHostView::UnlockMouse() {}
 
+void RenderWidgetHostView::CompositorDidCommit() {
+  RunAckCallbacks();
+}
+
 void RenderWidgetHostView::OnGestureEvent(
     const blink::WebGestureEvent& event) {
   if (!host_) {
@@ -517,10 +524,6 @@
 void RenderWidgetHostView::EvictCurrentFrame() {
   frame_is_evicted_ = true;
   DestroyDelegatedContent();
-
-  if (delegate_) {
-    delegate_->EvictCurrentFrame();
-  }
 }
 
 void RenderWidgetHostView::UnusedResourcesAreAvailable() {
@@ -529,19 +532,20 @@
   }
 }
 
-void RenderWidgetHostView::UpdateCursorOnWebView() {
-  if (!delegate_) {
-    return;
-  }
-
+void RenderWidgetHostView::UpdateCurrentCursor() {
   if (is_loading_) {
     content::WebCursor::CursorInfo busy_cursor_info(
         blink::WebCursorInfo::TypeWait);
-    content::WebCursor busy_cursor(busy_cursor_info);
-    delegate_->UpdateCursor(busy_cursor);
+    current_cursor_ = content::WebCursor(busy_cursor_info);
   } else {
-    delegate_->UpdateCursor(current_cursor_);
-  }
+    current_cursor_ = web_cursor_;
+  }
+
+  if (!container_) {
+    return;
+  }
+
+  container_->CursorChanged();
 }
 
 void RenderWidgetHostView::DestroyDelegatedContent() {
@@ -582,92 +586,76 @@
 }
 
 void RenderWidgetHostView::AttachLayer() {
-  if (!delegate_) {
+  if (!container_) {
     return;
   }
   if (!layer_.get()) {
     return;
   }
 
-  delegate_->GetCompositor()->SetRootLayer(layer_.get());
+  container_->AttachLayer(layer_);
 }
 
 void RenderWidgetHostView::DetachLayer() {
-  if (!delegate_) {
+  if (!container_) {
     return;
   }
   if (!layer_.get()) {
     return;
   }
 
-  delegate_->GetCompositor()->SetRootLayer(scoped_refptr<cc::Layer>());
+  container_->DetachLayer(layer_);
 }
 
-RenderWidgetHostView::RenderWidgetHostView(content::RenderWidgetHost* host) :
-    host_(content::RenderWidgetHostImpl::From(host)),
-    delegate_(nullptr),
-    resource_collection_(new cc::DelegatedFrameResourceCollection()),
-    last_output_surface_id_(0),
-    frame_is_evicted_(true),
-    selection_cursor_position_(0),
-    selection_anchor_position_(0),
-    current_text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
-    show_ime_if_needed_(false),
-    focused_node_is_editable_(false),
-    is_loading_(false),
-    is_showing_(false),
-    top_controls_shrink_blink_size_(false),
-    gesture_provider_(GestureProvider::Create(this)) {
+RenderWidgetHostView::RenderWidgetHostView(
+    content::RenderWidgetHost* host,
+    RenderWidgetHostViewContainer* container)
+    : host_(content::RenderWidgetHostImpl::From(host)),
+      container_(container),
+      resource_collection_(new cc::DelegatedFrameResourceCollection()),
+      last_output_surface_id_(0),
+      frame_is_evicted_(true),
+      ime_bridge_(this),
+      is_loading_(false),
+      is_showing_(false),
+      top_controls_shrink_blink_size_(false),
+      gesture_provider_(GestureProvider::Create(this)) {
   CHECK(host_) << "Implementation didn't supply a RenderWidgetHost";
 
   resource_collection_->SetClient(this);
   host_->SetView(this);
 
   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
+
+  if (container) {
+    CompositorObserver::Observe(container->GetCompositor());
+  }
 }
 
 RenderWidgetHostView::~RenderWidgetHostView() {
   resource_collection_->SetClient(nullptr);
-  SetDelegate(nullptr);
-}
-
-void RenderWidgetHostView::CompositorDidCommit() {
-  RunAckCallbacks();
-}
-
-void RenderWidgetHostView::SetDelegate(
-    RenderWidgetHostViewDelegate* delegate) {
-  if (delegate == delegate_) {
+  SetContainer(nullptr);
+}
+
+void RenderWidgetHostView::SetContainer(
+    RenderWidgetHostViewContainer* container) {
+  if (container == container_) {
     return;
   }
 
   DetachLayer();
-  delegate_ = delegate;
+  container_ = container;
   AttachLayer();
 
-  if (delegate_) {
-    DCHECK(host_) <<
-        "Shouldn't be attaching to a delegate when we're already destroyed";
-    host_->SendScreenRects();
-    host_->WasResized();
-
-    if (delegate_->IsVisible()) {
-      Show();
-    } else {
-      Hide();
-    }
-
-    UpdateCursorOnWebView();
-    delegate_->TextInputStateChanged(current_text_input_type_,
-                                     show_ime_if_needed_);
-    delegate_->FocusedNodeChanged(focused_node_is_editable_);
-    delegate_->SelectionBoundsChanged(caret_rect_,
-                                      selection_cursor_position_,
-                                      selection_anchor_position_);
-    delegate_->SelectionChanged();
-  } else if (host_) {
-    Hide();
+  CompositorObserver::Observe(
+      container_ ? container_->GetCompositor() : nullptr);
+
+  if (!host_) {
+    return;
   }
+
+  host_->SendScreenRects();
+  host_->WasResized();
 }
 
 void RenderWidgetHostView::Blur() {

=== modified file 'shared/browser/oxide_render_widget_host_view.h'
--- shared/browser/oxide_render_widget_host_view.h	2015-09-29 08:25:11 +0000
+++ shared/browser/oxide_render_widget_host_view.h	2015-10-21 17:31:00 +0000
@@ -30,10 +30,10 @@
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "content/common/cursors/webcursor.h"
-#include "ui/base/ime/text_input_type.h"
-#include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
+#include "shared/browser/compositor/oxide_compositor_observer.h"
+#include "shared/browser/input/oxide_ime_bridge_impl.h"
 #include "shared/browser/oxide_gesture_provider.h"
 #include "shared/browser/oxide_renderer_frame_evictor_client.h"
 #include "shared/port/content/browser/render_widget_host_view_oxide.h"
@@ -53,23 +53,25 @@
 
 namespace oxide {
 
-class RenderWidgetHostViewDelegate;
-class WebView;
+class RenderWidgetHostViewContainer;
 
 class RenderWidgetHostView final :
     public content::RenderWidgetHostViewOxide,
+    public CompositorObserver,
     public GestureProviderClient,
     public RendererFrameEvictorClient,
     public cc::DelegatedFrameResourceCollectionClient,
     public base::SupportsWeakPtr<RenderWidgetHostView> {
  public:
-  RenderWidgetHostView(content::RenderWidgetHost* render_widget_host);
+  RenderWidgetHostView(content::RenderWidgetHost* render_widget_host,
+                       RenderWidgetHostViewContainer* container);
   ~RenderWidgetHostView();
 
   content::RenderWidgetHostImpl* host() const { return host_; }
 
-  void CompositorDidCommit();
-  void SetDelegate(RenderWidgetHostViewDelegate* delegate);
+  void SetContainer(RenderWidgetHostViewContainer* container);
+
+  ImeBridgeImpl* ime_bridge() { return &ime_bridge_; }
 
   const base::string16& selection_text() const {
     return selection_text_;
@@ -79,6 +81,8 @@
     return compositor_frame_metadata_;
   }
 
+  const content::WebCursor& current_cursor() const { return current_cursor_; }
+
   void HandleTouchEvent(const ui::MotionEvent& event);
   void ResetGestureDetection();
 
@@ -158,6 +162,9 @@
   bool LockMouse() final;
   void UnlockMouse() final;
 
+  // CompositorObserver implementation
+  void CompositorDidCommit() final;
+
   // GestureProviderClient implementation
   void OnGestureEvent(const blink::WebGestureEvent& event) final;
 
@@ -169,7 +176,7 @@
 
   // ===================
 
-  void UpdateCursorOnWebView();
+  void UpdateCurrentCursor();
 
   void DestroyDelegatedContent();
   void SendDelegatedFrameAck(uint32 surface_id);
@@ -180,7 +187,7 @@
 
   content::RenderWidgetHostImpl* host_;
 
-  RenderWidgetHostViewDelegate* delegate_;
+  RenderWidgetHostViewContainer* container_;
 
   gfx::GLSurfaceHandle shared_surface_handle_;
 
@@ -197,15 +204,10 @@
 
   bool frame_is_evicted_;
 
-  gfx::Rect caret_rect_;
-  size_t selection_cursor_position_;
-  size_t selection_anchor_position_;
-
-  ui::TextInputType current_text_input_type_;
-  bool show_ime_if_needed_;
-  bool focused_node_is_editable_;
+  ImeBridgeImpl ime_bridge_;
 
   bool is_loading_;
+  content::WebCursor web_cursor_;
   content::WebCursor current_cursor_;
 
   bool is_showing_;

=== renamed file 'shared/browser/oxide_render_widget_host_view_delegate.h' => 'shared/browser/oxide_render_widget_host_view_container.h'
--- shared/browser/oxide_render_widget_host_view_delegate.h	2015-05-14 15:37:57 +0000
+++ shared/browser/oxide_render_widget_host_view_container.h	2015-10-21 17:31:00 +0000
@@ -1,5 +1,5 @@
 // vim:expandtab:shiftwidth=2:tabstop=2:
-// Copyright (C) 2014 Canonical Ltd.
+// Copyright (C) 2014-2015 Canonical Ltd.
 
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -15,16 +15,24 @@
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-#ifndef _OXIDE_SHARED_BROWSER_RENDER_WIDGET_HOST_VIEW_DELEGATE_H_
-#define _OXIDE_SHARED_BROWSER_RENDER_WIDGET_HOST_VIEW_DELEGATE_H_
-
+#ifndef _OXIDE_SHARED_BROWSER_RENDER_WIDGET_HOST_VIEW_CONTAINER_H_
+#define _OXIDE_SHARED_BROWSER_RENDER_WIDGET_HOST_VIEW_CONTAINER_H_
+
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "content/public/common/menu_item.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
-#include "ui/base/ime/text_input_type.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
+namespace cc {
+class Layer;
+}
+
 namespace content {
-class WebCursor;
+struct ContextMenuParams;
+class RenderFrameHost;
 }
 
 namespace gfx {
@@ -34,44 +42,43 @@
 namespace oxide {
 
 class Compositor;
-class WebView;
+class RenderWidgetHostView;
 
-class RenderWidgetHostViewDelegate {
+class RenderWidgetHostViewContainer {
  public:
-  virtual ~RenderWidgetHostViewDelegate() {}
-
-  virtual void EvictCurrentFrame() = 0;
-
-  virtual void UpdateCursor(const content::WebCursor& cursor) = 0;
-
-  virtual void TextInputStateChanged(ui::TextInputType type,
-                                     bool show_ime_if_needed) = 0;
-
-  virtual void FocusedNodeChanged(bool is_editable_node) = 0;
-
-  virtual void ImeCancelComposition() = 0;
-
-  virtual void SelectionBoundsChanged(const gfx::Rect& caret_rect,
-                                      size_t selection_cursor_position,
-                                      size_t selection_anchor_position) = 0;
-
-  virtual void SelectionChanged() = 0;
+  virtual ~RenderWidgetHostViewContainer() {}
 
   virtual Compositor* GetCompositor() const = 0;
 
+  virtual void AttachLayer(scoped_refptr<cc::Layer> layer) = 0;
+
+  virtual void DetachLayer(scoped_refptr<cc::Layer> layer) = 0;
+
+  virtual void CursorChanged() = 0;
+
   virtual gfx::Size GetViewSizePix() const = 0;
 
   virtual gfx::Rect GetViewBoundsDip() const = 0;
 
   virtual blink::WebScreenInfo GetScreenInfo() const = 0;
 
-  virtual bool HasFocus() const = 0;
+  virtual bool HasFocus(const RenderWidgetHostView* view) const = 0;
 
   virtual bool IsVisible() const = 0;
 
   virtual float GetLocationBarHeightDip() const = 0;
+
+  virtual void ShowContextMenu(content::RenderFrameHost* render_frame_host,
+                               const content::ContextMenuParams& params) = 0;
+
+  virtual void ShowPopupMenu(content::RenderFrameHost* render_frame_host,
+                             const gfx::Rect& bounds,
+                             int selected_item,
+                             const std::vector<content::MenuItem>& items,
+                             bool allow_multiple_selection) = 0;
+  virtual void HidePopupMenu() = 0;
 };
 
 } // namespace oxide
 
-#endif // _OXIDE_SHARED_BROWSER_RENDER_WIDGET_HOST_VIEW_DELEGATE_H_
+#endif // _OXIDE_SHARED_BROWSER_RENDER_WIDGET_HOST_VIEW_CONTAINER_H_

=== modified file 'shared/browser/oxide_web_contents_view.cc'
--- shared/browser/oxide_web_contents_view.cc	2015-05-28 23:51:39 +0000
+++ shared/browser/oxide_web_contents_view.cc	2015-10-21 17:31:00 +0000
@@ -21,15 +21,27 @@
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/web_contents.h"
 
+#include "shared/common/oxide_unowned_user_data.h"
+
 #include "oxide_render_widget_host_view.h"
-#include "oxide_web_view.h"
+#include "oxide_render_widget_host_view_container.h"
 
 namespace oxide {
 
-WebContentsView::WebContentsView(content::WebContents* web_contents) :
-    web_contents_(web_contents) {}
-
-WebContentsView::~WebContentsView() {}
+namespace {
+int kUserDataKey;
+}
+
+WebContentsView::WebContentsView(content::WebContents* web_contents)
+    : web_contents_(web_contents),
+      container_(nullptr) {
+  web_contents_->SetUserData(&kUserDataKey,
+                             new UnownedUserData<WebContentsView>(this));
+}
+
+WebContentsView::~WebContentsView() {
+  web_contents_->RemoveUserData(&kUserDataKey);
+}
 
 // static
 content::WebContentsViewOxide* WebContentsView::Create(
@@ -37,8 +49,27 @@
   return new WebContentsView(web_contents);
 }
 
-WebView* WebContentsView::GetWebView() const {
-  return WebView::FromWebContents(web_contents_);
+// static
+WebContentsView* WebContentsView::FromWebContents(
+    content::WebContents* contents) {
+  UnownedUserData<WebContentsView>* data =
+      static_cast<UnownedUserData<WebContentsView>*>(
+        contents->GetUserData(&kUserDataKey));
+  if (!data) {
+    return nullptr;
+  }
+
+  return data->get();
+}
+
+void WebContentsView::SetContainer(RenderWidgetHostViewContainer* container) {
+  container_ = container;
+  RenderWidgetHostView* rwhv =
+      static_cast<RenderWidgetHostView*>(
+        web_contents_->GetRenderWidgetHostView());
+  if (rwhv) {
+    rwhv->SetContainer(container);
+  }
 }
 
 gfx::NativeView WebContentsView::GetNativeView() const {
@@ -54,7 +85,7 @@
 }
 
 void WebContentsView::GetContainerBounds(gfx::Rect* out) const {
-  *out = GetWebView()->GetViewBoundsDip();
+  *out = container_->GetViewBoundsDip();
 }
 
 void WebContentsView::SizeContents(const gfx::Size& size) {
@@ -107,21 +138,7 @@
 content::RenderWidgetHostViewBase* WebContentsView::CreateViewForWidget(
     content::RenderWidgetHost* render_widget_host,
     bool is_guest_view_hack) {
-  RenderWidgetHostView* rwhv = new RenderWidgetHostView(render_widget_host);
-
-  WebView* view = GetWebView();
-  if (view) {
-    // As RWHV contains the plumbing from WebView::VisibilityChanged to
-    // RenderWidgetHostImpl::Was{Shown,Hidden}, RWHI::is_hidden could be
-    // out of date. This ensures that we sync RWHI::is_hidden with the
-    // real visibility of the webview - see https://launchpad.net/bugs/1322622
-    view->VisibilityChanged();
-
-    // Also sync focus state
-    view->FocusChanged();
-  }
-
-  return rwhv;
+  return new RenderWidgetHostView(render_widget_host, container_);
 }
 
 content::RenderWidgetHostViewBase* WebContentsView::CreateViewForPopupWidget(
@@ -140,7 +157,7 @@
 void WebContentsView::ShowContextMenu(
     content::RenderFrameHost* render_frame_host,
     const content::ContextMenuParams& params) {
-  GetWebView()->ShowContextMenu(render_frame_host, params);
+  container_->ShowContextMenu(render_frame_host, params);
 }
 
 void WebContentsView::StartDragging(
@@ -163,13 +180,13 @@
     const std::vector<content::MenuItem>& items,
     bool right_aligned,
     bool allow_multiple_selection) {
-  GetWebView()->ShowPopupMenu(render_frame_host,
-                              bounds, selected_item, items,
-                              allow_multiple_selection);
+  container_->ShowPopupMenu(render_frame_host,
+                            bounds, selected_item, items,
+                            allow_multiple_selection);
 }
 
 void WebContentsView::HidePopupMenu() {
-  GetWebView()->HidePopupMenu();
+  container_->HidePopupMenu();
 }
 
 } // namespace oxide

=== modified file 'shared/browser/oxide_web_contents_view.h'
--- shared/browser/oxide_web_contents_view.h	2015-05-28 23:51:39 +0000
+++ shared/browser/oxide_web_contents_view.h	2015-10-21 17:31:00 +0000
@@ -27,7 +27,7 @@
 
 namespace oxide {
 
-class WebView;
+class RenderWidgetHostViewContainer;
 
 class WebContentsView final : public content::WebContentsViewOxide {
  public:
@@ -35,7 +35,9 @@
   static content::WebContentsViewOxide* Create(
       content::WebContents* web_contents);
 
-  WebView* GetWebView() const;
+  static WebContentsView* FromWebContents(content::WebContents* contents);
+
+  void SetContainer(RenderWidgetHostViewContainer* container);
 
   // content::WebContentsView
   gfx::NativeView GetNativeView() const final;
@@ -93,6 +95,8 @@
 
   content::WebContents* web_contents_;
 
+  RenderWidgetHostViewContainer* container_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebContentsView);
 };
 

=== modified file 'shared/browser/oxide_web_view.cc'
--- shared/browser/oxide_web_view.cc	2015-10-08 15:56:22 +0000
+++ shared/browser/oxide_web_view.cc	2015-10-21 17:31:00 +0000
@@ -25,17 +25,18 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/supports_user_data.h"
+#include "cc/layers/layer.h"
+#include "cc/layers/solid_color_layer.h"
+#include "cc/trees/layer_tree_settings.h"
 #include "components/sessions/content/content_serialized_navigation_builder.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/event_with_latency_info.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
-#include "content/browser/renderer_host/ui_events_helper.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/browser_context.h"
-#include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
@@ -60,7 +61,6 @@
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/base/window_open_disposition.h"
 #include "ui/events/event.h"
-#include "ui/gfx/range/range.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/shell_dialogs/selected_file_info.h"
 #include "url/gurl.h"
@@ -69,12 +69,15 @@
 #include "shared/browser/compositor/oxide_compositor.h"
 #include "shared/browser/compositor/oxide_compositor_frame_data.h"
 #include "shared/browser/compositor/oxide_compositor_frame_handle.h"
+#include "shared/browser/input/oxide_ime_bridge.h"
+#include "shared/browser/input/oxide_input_method_context.h"
 #include "shared/browser/media/oxide_media_capture_devices_dispatcher.h"
 #include "shared/browser/permissions/oxide_permission_request_dispatcher.h"
 #include "shared/browser/permissions/oxide_temporary_saved_permission_context.h"
 #include "shared/common/oxide_content_client.h"
 #include "shared/common/oxide_enum_flags.h"
 #include "shared/common/oxide_messages.h"
+#include "shared/common/oxide_unowned_user_data.h"
 
 #include "oxide_browser_context.h"
 #include "oxide_browser_process_main.h"
@@ -106,20 +109,7 @@
 
 namespace {
 
-const char kWebViewKey[] = "oxide_web_view_data";
-
-// SupportsUserData implementations own their data. This class exists
-// because we don't want WebContents to own WebView (it's the other way
-// around)
-class WebViewUserData : public base::SupportsUserData::Data {
- public:
-  WebViewUserData(WebView* view) : view_(view) {}
-
-  WebView* get() const { return view_; }
-
- private:
-  WebView* view_;
-};
+int kUserDataKey;
 
 void FillLoadURLParamsFromOpenURLParams(
     content::NavigationController::LoadURLParams* load_params,
@@ -143,22 +133,6 @@
   }
 }
 
-// Qt input methods don’t generate key events, but a lot of web pages out there
-// rely on keydown and keyup events to e.g. perform search-as-you-type or
-// enable/disable a submit button based on the contents of a text input field,
-// so we send a fake pair of keydown/keyup events.
-// This mimicks what is done in GtkIMContextWrapper::HandlePreeditChanged(…)
-// and GtkIMContextWrapper::HandleCommit(…)
-// (see content/browser/renderer_host/gtk_im_context_wrapper.cc).
-void SendFakeCompositionKeyEvent(content::RenderWidgetHostImpl* host,
-                                 blink::WebInputEvent::Type type) {
-  content::NativeWebKeyboardEvent fake_event;
-  fake_event.windowsKeyCode = ui::VKEY_PROCESSKEY;
-  fake_event.skip_in_browser = true;
-  fake_event.type = type;
-  host->ForwardKeyboardEvent(fake_event);
-}
-
 void CreateHelpers(content::WebContents* contents,
                    content::WebContents* opener = nullptr) {
   new WebViewContentsHelper(contents, opener);
@@ -225,13 +199,9 @@
 
 WebView::WebView(WebViewClient* client)
     : client_(client),
-      text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
-      show_ime_if_needed_(false),
-      focused_node_is_editable_(false),
-      selection_cursor_position_(0),
-      selection_anchor_position_(0),
       web_contents_helper_(nullptr),
       compositor_(Compositor::Create(this)),
+      root_layer_(cc::SolidColorLayer::Create(cc::LayerSettings())),
       is_fullscreen_(false),
       blocked_content_(CONTENT_TYPE_NONE),
       location_bar_height_pix_(0),
@@ -239,6 +209,14 @@
       location_bar_animated_(true),
       weak_factory_(this) {
   CHECK(client) << "Didn't specify a client";
+
+  root_layer_->SetIsDrawable(true);
+  root_layer_->SetBackgroundColor(SK_ColorWHITE);
+
+  compositor_->SetRootLayer(root_layer_);
+
+  CompositorObserver::Observe(compositor_.get());
+  InputMethodContextObserver::Observe(client_->GetInputMethodContext());
 }
 
 void WebView::CommonInit(scoped_ptr<content::WebContents> contents) {
@@ -246,7 +224,8 @@
 
   // Attach ourself to the WebContents
   web_contents_->SetDelegate(this);
-  web_contents_->SetUserData(kWebViewKey, new WebViewUserData(this));
+  web_contents_->SetUserData(&kUserDataKey,
+                             new UnownedUserData<WebView>(this));
 
   content::WebContentsObserver::Observe(web_contents_.get());
 
@@ -262,6 +241,8 @@
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
+  WebContentsView::FromWebContents(web_contents_.get())->SetContainer(this);
+
   DCHECK(std::find(g_all_web_views.Get().begin(),
                    g_all_web_views.Get().end(),
                    this) ==
@@ -329,11 +310,13 @@
     return false;
   }
 
-  if (!IsInputPanelVisible()) {
+  if (!client_->GetInputMethodContext() ||
+      !client_->GetInputMethodContext()->IsInputPanelVisible()) {
     return false;
   }
 
-  if (!focused_node_is_editable_) {
+  if (!GetRenderWidgetHostView() ||
+      !GetRenderWidgetHostView()->ime_bridge()->focused_node_is_editable()) {
     return false;
   }
 
@@ -388,6 +371,10 @@
   return client_->GetScriptMessageHandlerAt(index);
 }
 
+void WebView::InputPanelVisibilityChanged() {
+  MaybeScrollFocusedEditableNodeIntoView();
+}
+
 void WebView::CompositorDidCommit() {
   RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
   if (!rwhv) {
@@ -395,8 +382,6 @@
   }
 
   pending_compositor_frame_metadata_ = rwhv->compositor_frame_metadata();
-
-  rwhv->CompositorDidCommit();
 }
 
 void WebView::CompositorSwapFrame(CompositorFrameHandle* handle) {
@@ -438,63 +423,79 @@
   }
 }
 
-void WebView::EvictCurrentFrame() {
-  current_compositor_frame_ = nullptr;
-  client_->EvictCurrentFrame();
-}
-
-void WebView::UpdateCursor(const content::WebCursor& cursor) {
-  client_->UpdateCursor(cursor);
-}
-
-void WebView::TextInputStateChanged(ui::TextInputType type,
-                                    bool show_ime_if_needed) {
-  if (type == text_input_type_ &&
-      show_ime_if_needed == show_ime_if_needed_) {
-    return;
-  }
-
-  text_input_type_ = type;
-  show_ime_if_needed_ = show_ime_if_needed;
-
-  client_->TextInputStateChanged();
-}
-
-void WebView::FocusedNodeChanged(bool is_editable_node) {
-  focused_node_is_editable_ = is_editable_node;
-  client_->FocusedNodeChanged();
-
-  MaybeScrollFocusedEditableNodeIntoView();
-}
-
-void WebView::ImeCancelComposition() {
-  client_->ImeCancelComposition();
-}
-
-void WebView::SelectionBoundsChanged(const gfx::Rect& caret_rect,
-                                     size_t selection_cursor_position,
-                                     size_t selection_anchor_position) {
-  if (caret_rect == caret_rect_ &&
-      selection_cursor_position == selection_cursor_position_ &&
-      selection_anchor_position == selection_anchor_position_) {
-    return;
-  }
-
-  caret_rect_ = caret_rect;
-  selection_cursor_position_ = selection_cursor_position;
-  selection_anchor_position_ = selection_anchor_position;
-
-  client_->SelectionBoundsChanged();
-}
-
-void WebView::SelectionChanged() {
-  client_->SelectionChanged();
-}
-
 Compositor* WebView::GetCompositor() const {
   return compositor_.get();
 }
 
+void WebView::AttachLayer(scoped_refptr<cc::Layer> layer) {
+  DCHECK(layer.get());
+  root_layer_->InsertChild(layer, 0);
+  root_layer_->SetIsDrawable(false);
+}
+
+void WebView::DetachLayer(scoped_refptr<cc::Layer> layer) {
+  DCHECK(layer.get());
+  DCHECK_EQ(layer->parent(), root_layer_.get());
+  layer->RemoveFromParent();
+  if (root_layer_->children().size() == 0) {
+    root_layer_->SetIsDrawable(true);
+  }
+}
+
+void WebView::CursorChanged() {
+  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
+  if (!rwhv) {
+    return;
+  }
+
+  client_->UpdateCursor(rwhv->current_cursor());
+}
+
+bool WebView::HasFocus(const RenderWidgetHostView* view) const {
+  if (!HasFocus()) {
+    return false;
+  }
+
+  return view == GetRenderWidgetHostView();
+}
+
+void WebView::ShowContextMenu(content::RenderFrameHost* render_frame_host,
+                              const content::ContextMenuParams& params) {
+  WebContextMenu* menu = client_->CreateContextMenu(render_frame_host, params);
+  if (!menu) {
+    return;
+  }
+
+  menu->Show();
+}
+
+void WebView::ShowPopupMenu(content::RenderFrameHost* render_frame_host,
+                            const gfx::Rect& bounds,
+                            int selected_item,
+                            const std::vector<content::MenuItem>& items,
+                            bool allow_multiple_selection) {
+  DCHECK(!active_popup_menu_);
+
+  WebPopupMenu* menu = client_->CreatePopupMenu(render_frame_host);
+  if (!menu) {
+    static_cast<content::RenderFrameHostImpl *>(
+        render_frame_host)->DidCancelPopupMenu();
+    return;
+  }
+
+  active_popup_menu_ = menu->GetWeakPtr();
+
+  menu->Show(bounds, items, selected_item, allow_multiple_selection);
+}
+
+void WebView::HidePopupMenu() {
+  if (!active_popup_menu_) {
+    return;
+  }
+
+  active_popup_menu_->Close();
+}
+
 content::WebContents* WebView::OpenURLFromTab(
     content::WebContents* source,
     const content::OpenURLParams& params) {
@@ -874,15 +875,31 @@
 void WebView::RenderViewHostChanged(content::RenderViewHost* old_host,
                                     content::RenderViewHost* new_host) {
   if (old_host && old_host->GetView()) {
-    static_cast<RenderWidgetHostView *>(old_host->GetView())->SetDelegate(nullptr);
+    RenderWidgetHostView* rwhv =
+        static_cast<RenderWidgetHostView*>(old_host->GetView());
+    rwhv->SetContainer(nullptr);
+    rwhv->ime_bridge()->SetContext(nullptr);
   }
+
   if (new_host) {
     if (new_host->GetView()) {
-      static_cast<RenderWidgetHostView *>(new_host->GetView())->SetDelegate(this);
+      RenderWidgetHostView* rwhv =
+          static_cast<RenderWidgetHostView*>(new_host->GetView());
+      rwhv->SetContainer(this);
+      rwhv->ime_bridge()->SetContext(client_->GetInputMethodContext());
     }
 
     InitializeTopControlsForHost(new_host, !old_host);
   }
+
+  if (old_host) {
+    return;
+  }
+
+  // For the initial view, we need to sync its visibility and focus state
+  // with us. For subsequent views, RFHM does this for us
+  VisibilityChanged();
+  FocusChanged();
 }
 
 void WebView::DidStartProvisionalLoadForFrame(
@@ -1067,6 +1084,7 @@
   compositor_->SetViewportSize(GetViewSizePix());
   compositor_->SetVisibility(IsVisible());
   compositor_->SetDeviceScaleFactor(GetScreenInfo().deviceScaleFactor);
+  root_layer_->SetBounds(GetViewSizeDip());
 
   if (params.restore_entries.size() > 0) {
     ScopedVector<content::NavigationEntry> entries =
@@ -1093,22 +1111,21 @@
 
   CommonInit(contents.Pass());
 
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  if (rwhv) {
-    rwhv->SetDelegate(this);
-  }
-
   content::RenderViewHost* rvh = GetRenderViewHost();
   if (rvh) {
     InitializeTopControlsForHost(rvh, true);
   }
 
+  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
+  if (rwhv) {
+    rwhv->ime_bridge()->SetContext(client_->GetInputMethodContext());
+  }
+
   // Sync WebContents with the state of the WebView
   WasResized();
   ScreenUpdated();
   VisibilityChanged();
   FocusChanged();
-  InputPanelVisibilityChanged();
 
   // Update SSL Status
   content::NavigationEntry* entry =
@@ -1125,21 +1142,24 @@
                   this),
       g_all_web_views.Get().end());
 
+  WebContentsView::FromWebContents(web_contents_.get())->SetContainer(nullptr);
+
   RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
   if (rwhv) {
-    rwhv->SetDelegate(nullptr);
+    rwhv->ime_bridge()->SetContext(nullptr);
   }
 
   // Stop WebContents from calling back in to us
   content::WebContentsObserver::Observe(nullptr);
 
-  web_contents_->RemoveUserData(kWebViewKey);
+  web_contents_->RemoveUserData(&kUserDataKey);
 }
 
 // static
 WebView* WebView::FromWebContents(const content::WebContents* web_contents) {
-  WebViewUserData* data = static_cast<WebViewUserData *>(
-      web_contents->GetUserData(kWebViewKey));
+  UnownedUserData<WebView>* data =
+      static_cast<UnownedUserData<WebView>*>(
+        web_contents->GetUserData(&kUserDataKey));
   if (!data) {
     return nullptr;
   }
@@ -1275,11 +1295,9 @@
 }
 
 void WebView::WasResized() {
-  {
-    CompositorLock lock(compositor_.get());
-    compositor_->SetDeviceScaleFactor(GetScreenInfo().deviceScaleFactor);
-    compositor_->SetViewportSize(GetViewSizePix());
-  }
+  compositor_->SetDeviceScaleFactor(GetScreenInfo().deviceScaleFactor);
+  compositor_->SetViewportSize(GetViewSizePix());
+  root_layer_->SetBounds(GetViewSizeDip());
 
   RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
   if (rwhv) {
@@ -1309,6 +1327,14 @@
     web_contents_->WasShown();
   } else {
     web_contents_->WasHidden();
+    // TODO: Have an eviction algorithm for LayerTreeHosts in Compositor, and
+    //  trigger eviction of the frontbuffer from a CompositorClient callback.
+    // XXX: Also this isn't really necessary for eviction - after all, the LTH
+    //  owned by Compositor owns the frontbuffer (via its cc::OutputSurface).
+    //  This callback is really to notify the toolkit layer that the
+    //  frontbuffer is being dropped
+    current_compositor_frame_ = nullptr;
+    client_->EvictCurrentFrame();
   }
 
   MaybeScrollFocusedEditableNodeIntoView();
@@ -1329,10 +1355,6 @@
   MaybeScrollFocusedEditableNodeIntoView();
 }
 
-void WebView::InputPanelVisibilityChanged() {
-  MaybeScrollFocusedEditableNodeIntoView();
-}
-
 void WebView::UpdateWebPreferences() {
   content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   if (!rvh) {
@@ -1605,43 +1627,6 @@
   web_contents_->DispatchBeforeUnload(false);
 }
 
-void WebView::ShowContextMenu(content::RenderFrameHost* render_frame_host,
-                              const content::ContextMenuParams& params) {
-  WebContextMenu* menu = client_->CreateContextMenu(render_frame_host, params);
-  if (!menu) {
-    return;
-  }
-
-  menu->Show();
-}
-
-void WebView::ShowPopupMenu(content::RenderFrameHost* render_frame_host,
-                            const gfx::Rect& bounds,
-                            int selected_item,
-                            const std::vector<content::MenuItem>& items,
-                            bool allow_multiple_selection) {
-  DCHECK(!active_popup_menu_);
-
-  WebPopupMenu* menu = client_->CreatePopupMenu(render_frame_host);
-  if (!menu) {
-    static_cast<content::RenderFrameHostImpl *>(
-        render_frame_host)->DidCancelPopupMenu();
-    return;
-  }
-
-  active_popup_menu_ = menu->GetWeakPtr();
-
-  menu->Show(bounds, items, selected_item, allow_multiple_selection);
-}
-
-void WebView::HidePopupMenu() {
-  if (!active_popup_menu_) {
-    return;
-  }
-
-  active_popup_menu_->Close();
-}
-
 void WebView::AllowCertificateError(
     content::RenderFrameHost* rfh,
     int cert_error,
@@ -1727,34 +1712,6 @@
   rvh->ForwardWheelEvent(event);
 }
 
-void WebView::ImeCommitText(const base::string16& text,
-                            const gfx::Range& replacement_range) {
-  content::RenderWidgetHostImpl* host = GetRenderWidgetHostImpl();
-  if (!host) {
-    return;
-  }
-
-  SendFakeCompositionKeyEvent(host, blink::WebInputEvent::RawKeyDown);
-  host->ImeConfirmComposition(text, replacement_range, false);
-  SendFakeCompositionKeyEvent(host, blink::WebInputEvent::KeyUp);
-}
-
-void WebView::ImeSetComposingText(
-    const base::string16& text,
-    const std::vector<blink::WebCompositionUnderline>& underlines,
-    const gfx::Range& selection_range) {
-  content::RenderWidgetHostImpl* host = GetRenderWidgetHostImpl();
-  if (!host) {
-    return;
-  }
-
-  SendFakeCompositionKeyEvent(host, blink::WebInputEvent::RawKeyDown);
-  host->ImeSetComposition(text, underlines,
-                          selection_range.start(),
-                          selection_range.end());
-  SendFakeCompositionKeyEvent(host, blink::WebInputEvent::KeyUp);
-}
-
 void WebView::DownloadRequested(
     const GURL& url,
     const std::string& mime_type,
@@ -1810,10 +1767,6 @@
   return client_->HasFocus();
 }
 
-bool WebView::IsInputPanelVisible() const {
-  return client_->IsInputPanelVisible();
-}
-
 JavaScriptDialog* WebView::CreateJavaScriptDialog(
     content::JavaScriptMessageType javascript_message_type) {
   return client_->CreateJavaScriptDialog(javascript_message_type);
@@ -1837,23 +1790,5 @@
   return client_->CanCreateWindows();
 }
 
-base::string16 WebView::GetSelectedText() const {
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  if (!rwhv) {
-    return base::string16();
-  }
-
-  return rwhv->GetSelectedText();
-}
-
-const base::string16& WebView::GetSelectionText() const {
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  if (!rwhv) {
-    return base::EmptyString16();
-  }
-
-  return rwhv->selection_text();
-}
-
 } // namespace oxide
 

=== modified file 'shared/browser/oxide_web_view.h'
--- shared/browser/oxide_web_view.h	2015-10-08 15:56:22 +0000
+++ shared/browser/oxide_web_view.h	2015-10-21 17:31:00 +0000
@@ -39,16 +39,16 @@
 #include "content/public/common/resource_type.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "third_party/WebKit/public/platform/WebTopControlsState.h"
-#include "third_party/WebKit/public/web/WebCompositionUnderline.h"
-#include "ui/base/ime/text_input_type.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 #include "shared/browser/compositor/oxide_compositor_client.h"
+#include "shared/browser/compositor/oxide_compositor_observer.h"
+#include "shared/browser/input/oxide_input_method_context_observer.h"
 #include "shared/browser/oxide_certificate_error.h"
 #include "shared/browser/oxide_content_types.h"
-#include "shared/browser/oxide_render_widget_host_view_delegate.h"
+#include "shared/browser/oxide_render_widget_host_view_container.h"
 #include "shared/browser/oxide_script_message_target.h"
 #include "shared/browser/oxide_security_status.h"
 #include "shared/browser/oxide_security_types.h"
@@ -63,10 +63,12 @@
 class WebMouseWheelEvent;
 } // namespace blink
 
+namespace cc {
+class SolidColorLayer;
+}
+
 namespace content {
 
-struct ContextMenuParams;
-struct MenuItem;
 class NativeWebKeyboardEvent;
 class NotificationRegistrar;
 struct OpenURLParams;
@@ -75,7 +77,6 @@
 class RenderWidgetHostImpl;
 class WebContents;
 class WebContentsImpl;
-class WebCursor;
 
 } // namespace content
 
@@ -129,10 +130,12 @@
 // This is the main webview class. Implementations should customize this by
 // providing an implementation of WebViewClient
 class WebView : public ScriptMessageTarget,
+                private InputMethodContextObserver,
+                private CompositorObserver,
                 private CompositorClient,
                 private WebPreferencesObserver,
                 private content::NotificationObserver,
-                private RenderWidgetHostViewDelegate,
+                private RenderWidgetHostViewContainer,
                 private content::WebContentsDelegate,
                 private content::WebContentsObserver {
  public:
@@ -199,7 +202,6 @@
   void ScreenUpdated();
   void VisibilityChanged();
   void FocusChanged();
-  void InputPanelVisibilityChanged();
   void UpdateWebPreferences();
 
   BrowserContext* GetBrowserContext() const;
@@ -259,15 +261,6 @@
 
   void PrepareToClose();
 
-  void ShowContextMenu(content::RenderFrameHost* render_frame_host,
-                       const content::ContextMenuParams& params);
-  void ShowPopupMenu(content::RenderFrameHost* render_frame_host,
-                     const gfx::Rect& bounds,
-                     int selected_item,
-                     const std::vector<content::MenuItem>& items,
-                     bool allow_multiple_selection);
-  void HidePopupMenu();
-
   void AllowCertificateError(content::RenderFrameHost* rfh,
                              int cert_error,
                              const net::SSLInfo& ssl_info,
@@ -283,13 +276,6 @@
   void HandleTouchEvent(const ui::TouchEvent& event);
   void HandleWheelEvent(const blink::WebMouseWheelEvent& event);
 
-  void ImeCommitText(const base::string16& text,
-                     const gfx::Range& replacement_range);
-  void ImeSetComposingText(
-      const base::string16& text,
-      const std::vector<blink::WebCompositionUnderline>& underlines,
-      const gfx::Range& selection_range);
-
   void DownloadRequested(
       const GURL& url,
       const std::string& mime_type,
@@ -309,7 +295,6 @@
   gfx::Rect GetViewBoundsPix() const;
   bool IsVisible() const;
   bool HasFocus() const;
-  bool IsInputPanelVisible() const;
 
   JavaScriptDialog* CreateJavaScriptDialog(
       content::JavaScriptMessageType javascript_message_type);
@@ -319,17 +304,6 @@
 
   bool CanCreateWindows() const;
 
-  ui::TextInputType text_input_type() const { return text_input_type_; }
-  bool show_ime_if_needed() const { return show_ime_if_needed_; }
-  bool focused_node_is_editable() const { return focused_node_is_editable_; }
-
-  gfx::Rect caret_rect() const { return caret_rect_; }
-  size_t selection_cursor_position() const { return selection_cursor_position_; }
-  size_t selection_anchor_position() const { return selection_anchor_position_; }
-
-  base::string16 GetSelectedText() const;
-  const base::string16& GetSelectionText() const;
-
  private:
   WebView(WebViewClient* client);
 
@@ -364,8 +338,13 @@
   virtual const ScriptMessageHandler* GetScriptMessageHandlerAt(
       size_t index) const override;
 
+  // InputMethodContextObserver implementation
+  void InputPanelVisibilityChanged() override;
+
+  // CompositorObserver implementation
+  void CompositorDidCommit() final;
+
   // CompositorClient implementation
-  void CompositorDidCommit() final;
   void CompositorSwapFrame(CompositorFrameHandle* handle) final;
 
   // WebPreferencesObserver implementation
@@ -376,18 +355,20 @@
                const content::NotificationSource& source,
                const content::NotificationDetails& details) final;
 
-  // RenderWidgetHostViewDelegate implementation
-  void EvictCurrentFrame() final;
-  void UpdateCursor(const content::WebCursor& cursor) final;
-  void TextInputStateChanged(ui::TextInputType type,
-                             bool show_ime_if_needed) final;
-  void FocusedNodeChanged(bool is_editable_node) final;
-  void ImeCancelComposition() final;
-  void SelectionBoundsChanged(const gfx::Rect& caret_rect,
-                              size_t selection_cursor_position,
-                              size_t selection_anchor_position) final;
-  void SelectionChanged() final;
+  // RenderWidgetHostViewContainer implementation
   Compositor* GetCompositor() const final;
+  void AttachLayer(scoped_refptr<cc::Layer> layer) final;
+  void DetachLayer(scoped_refptr<cc::Layer> layer) final;
+  void CursorChanged() final;
+  bool HasFocus(const RenderWidgetHostView* view) const final;
+  void ShowContextMenu(content::RenderFrameHost* render_frame_host,
+                       const content::ContextMenuParams& params) final;
+  void ShowPopupMenu(content::RenderFrameHost* render_frame_host,
+                     const gfx::Rect& bounds,
+                     int selected_item,
+                     const std::vector<content::MenuItem>& items,
+                     bool allow_multiple_selection) final;
+  void HidePopupMenu() final;
 
   // content::WebContentsDelegate implementation
   content::WebContents* OpenURLFromTab(content::WebContents* source,
@@ -502,14 +483,6 @@
 
   WebViewClient* client_;
 
-  ui::TextInputType text_input_type_;
-  bool show_ime_if_needed_;
-  bool focused_node_is_editable_;
-
-  gfx::Rect caret_rect_;
-  size_t selection_cursor_position_;
-  size_t selection_anchor_position_;
-
   struct WebContentsDeleter {
     void operator()(content::WebContents* contents);
   };
@@ -520,6 +493,7 @@
   WebViewContentsHelper* web_contents_helper_;
 
   scoped_ptr<Compositor> compositor_;
+  scoped_refptr<cc::SolidColorLayer> root_layer_;
 
   scoped_refptr<CompositorFrameHandle> current_compositor_frame_;
   std::vector<scoped_refptr<CompositorFrameHandle> > previous_compositor_frames_;

=== modified file 'shared/browser/oxide_web_view_client.cc'
--- shared/browser/oxide_web_view_client.cc	2015-10-08 15:56:22 +0000
+++ shared/browser/oxide_web_view_client.cc	2015-10-21 17:31:00 +0000
@@ -23,10 +23,6 @@
 
 WebViewClient::~WebViewClient() {}
 
-bool WebViewClient::IsInputPanelVisible() const {
-  return false;
-}
-
 JavaScriptDialog* WebViewClient::CreateJavaScriptDialog(
     content::JavaScriptMessageType javascript_message_type) {
   return nullptr;
@@ -137,15 +133,9 @@
 
 void WebViewClient::EvictCurrentFrame() {}
 
-void WebViewClient::TextInputStateChanged() {}
-
-void WebViewClient::FocusedNodeChanged() {}
-
-void WebViewClient::SelectionBoundsChanged() {}
-
-void WebViewClient::ImeCancelComposition() {}
-
-void WebViewClient::SelectionChanged() {}
+InputMethodContext* WebViewClient::GetInputMethodContext() const {
+  return nullptr;
+}
 
 void WebViewClient::UpdateCursor(const content::WebCursor& cursor) {}
 

=== modified file 'shared/browser/oxide_web_view_client.h'
--- shared/browser/oxide_web_view_client.h	2015-10-08 15:56:22 +0000
+++ shared/browser/oxide_web_view_client.h	2015-10-21 17:31:00 +0000
@@ -48,6 +48,7 @@
 
 class CertificateError;
 class FilePicker;
+class InputMethodContext;
 class JavaScriptDialog;
 class ResourceDispatcherHostLoginDelegate;
 class SecurityStatus;
@@ -69,9 +70,6 @@
 
   virtual bool HasFocus() const = 0;
 
-  // XXX(chrisccoulson): This is global state, so it doesn't belong here
-  virtual bool IsInputPanelVisible() const;
-
   // TODO(chrisccoulson): Make a delegate for JavaScriptDialogManager and move there
   virtual JavaScriptDialog* CreateJavaScriptDialog(
       content::JavaScriptMessageType javascript_message_type);
@@ -168,20 +166,7 @@
 
   virtual void EvictCurrentFrame();
 
-  // XXX(chrisccoulson): Rethink all of these IME related bits:
-  //    - Move some logic down from qt/ to shared/
-  //    - The implementations of some of these only touch process-global
-  //      stuff - should we have an InputMethod singleton in shared/
-  //      rather than dumping it all in WebView?
-  virtual void TextInputStateChanged();
-
-  virtual void FocusedNodeChanged();
-
-  virtual void SelectionBoundsChanged();
-
-  virtual void ImeCancelComposition();
-
-  virtual void SelectionChanged();
+  virtual InputMethodContext* GetInputMethodContext() const;
 
   virtual void UpdateCursor(const content::WebCursor& cursor);
 

=== added file 'shared/common/oxide_unowned_user_data.h'
--- shared/common/oxide_unowned_user_data.h	1970-01-01 00:00:00 +0000
+++ shared/common/oxide_unowned_user_data.h	2015-10-21 17:31:00 +0000
@@ -0,0 +1,41 @@
+// vim:expandtab:shiftwidth=2:tabstop=2:
+// Copyright (C) 2013-2015 Canonical Ltd.
+
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#ifndef _OXIDE_SHARED_COMMON_UNOWNED_USER_DATA_H_
+#define _OXIDE_SHARED_COMMON_UNOWNED_USER_DATA_H_
+
+#include "base/macros.h"
+#include "base/supports_user_data.h"
+
+namespace {
+
+template <class T>
+class UnownedUserData : public base::SupportsUserData::Data {
+ public:
+  UnownedUserData(T* ptr) : ptr_(ptr) {}
+
+  T* get() const { return ptr_; }
+
+ private:
+  T* ptr_;
+
+  DISALLOW_COPY_AND_ASSIGN(UnownedUserData);
+};
+
+} // namespace oxide
+
+#endif // _OXIDE_SHARED_COMMON_UNOWNED_USER_DATA_H_

=== modified file 'shared/shared.gyp'
--- shared/shared.gyp	2015-10-08 15:56:22 +0000
+++ shared/shared.gyp	2015-10-21 17:31:00 +0000
@@ -293,6 +293,8 @@
         'browser/compositor/oxide_compositor_frame_handle.h',
         'browser/compositor/oxide_compositor_gpu_shims.cc',
         'browser/compositor/oxide_compositor_gpu_shims.h',
+        'browser/compositor/oxide_compositor_observer.cc',
+        'browser/compositor/oxide_compositor_observer.h',
         'browser/compositor/oxide_compositor_output_surface.cc',
         'browser/compositor/oxide_compositor_output_surface.h',
         'browser/compositor/oxide_compositor_output_surface_gl.cc',
@@ -307,6 +309,14 @@
         'browser/compositor/oxide_compositor_utils.h',
         'browser/compositor/oxide_mailbox_buffer_map.cc',
         'browser/compositor/oxide_mailbox_buffer_map.h',
+        'browser/input/oxide_ime_bridge.cc',
+        'browser/input/oxide_ime_bridge.h',
+        'browser/input/oxide_ime_bridge_impl.cc',
+        'browser/input/oxide_ime_bridge_impl.h',
+        'browser/input/oxide_input_method_context.cc',
+        'browser/input/oxide_input_method_context.h',
+        'browser/input/oxide_input_method_context_observer.cc',
+        'browser/input/oxide_input_method_context_observer.h',
         'browser/media/oxide_media_capture_devices_context.cc',
         'browser/media/oxide_media_capture_devices_context.h',
         'browser/media/oxide_media_capture_devices_context_client.h',
@@ -401,7 +411,7 @@
         'browser/oxide_render_process_initializer.h',
         'browser/oxide_render_widget_host_view.cc',
         'browser/oxide_render_widget_host_view.h',
-        'browser/oxide_render_widget_host_view_delegate.h',
+        'browser/oxide_render_widget_host_view_container.h',
         'browser/oxide_resource_dispatcher_host_delegate.cc',
         'browser/oxide_resource_dispatcher_host_delegate.h',
         'browser/oxide_resource_dispatcher_host_login_delegate.cc',
@@ -498,6 +508,7 @@
         'common/oxide_script_message_params.h',
         'common/oxide_script_message_request.cc',
         'common/oxide_script_message_request.h',
+        'common/oxide_unowned_user_data.h',
         'common/oxide_user_agent.cc',
         'common/oxide_user_agent.h',
         'common/oxide_user_agent_override_set.cc',