Extract minimal RenderViewHost interface for embedders, leaving

content/browser/renderer_host/gtk_im_context_wrapper.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/gtk_im_context_wrapper.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
@@ skipping 265 matching lines @@
   // enabled by WebKit.
   if (is_enabled_)
     gtk_im_context_focus_in(context_);
 
   // context_simple_ is always enabled.
   // Actually it doesn't care focus state at all.
   gtk_im_context_focus_in(context_simple_);
 
   // Enables RenderWidget's IME related events, so that we can be notified
   // when WebKit wants to enable or disable IME.
-  if (host_view_->GetRenderWidgetHost())
-    static_cast<RenderWidgetHostImpl*>(
+  if (host_view_->GetRenderWidgetHost()) {
+    RenderWidgetHostImpl::From(
         host_view_->GetRenderWidgetHost())->SetInputMethodActive(true);
+  }
 }
 
 void GtkIMContextWrapper::OnFocusOut() {
   if (!is_focused_)
     return;
 
   // Tracks the focused state so that we won't give focus to the
   // GtkIMContext object unexpectly.
   is_focused_ = false;
 
   // Notify the GtkIMContext object of this focus-out event only if IME is
   // enabled by WebKit.
   if (is_enabled_) {
     // To reset the GtkIMContext object and prevent data loss.
     ConfirmComposition();
     gtk_im_context_focus_out(context_);
   }
 
   // To make sure it'll be in correct state when focused in again.
   gtk_im_context_reset(context_simple_);
   gtk_im_context_focus_out(context_simple_);
 
   is_composing_text_ = false;
 
   // Disable RenderWidget's IME related events to save bandwidth.
-  if (host_view_->GetRenderWidgetHost())
-    static_cast<RenderWidgetHostImpl*>(
+  if (host_view_->GetRenderWidgetHost()) {
+    RenderWidgetHostImpl::From(
         host_view_->GetRenderWidgetHost())->SetInputMethodActive(false);
+  }
 }
 
 #if !defined(TOOLKIT_VIEWS)
 // Not defined for views because the views context menu doesn't
 // implement input methods yet.
 GtkWidget* GtkIMContextWrapper::BuildInputMethodsGtkMenu() {
   GtkWidget* submenu = gtk_menu_new();
   gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(context_),
                                        GTK_MENU_SHELL(submenu));
   return submenu;
@@ skipping 75 matching lines @@
   // see WebInputEventFactory::keyboardEvent() for details.
   if (wke->text[0]) {
     wke->type = WebKit::WebInputEvent::Char;
     wke->skip_in_browser = true;
     host_view_->ForwardKeyboardEvent(*wke);
   }
 }
 
 void GtkIMContextWrapper::ProcessInputMethodResult(const GdkEventKey* event,
                                                    bool filtered) {
-  RenderWidgetHostImpl* host = RenderWidgetHostImpl::FromRWHV(host_view_);
+  RenderWidgetHostImpl* host = RenderWidgetHostImpl::From(
+      host_view_->GetRenderWidgetHost());
   if (!host)
     return;
 
   bool committed = false;
   // We do commit before preedit change, so that we can optimize some
   // unnecessary preedit changes.
   if (commit_text_.length()) {
     if (filtered && NeedCommitByForwardingCharEvent()) {
       // Send a Char event when we input a composed character without IMEs
       // so that this event is to be dispatched to onkeypress() handlers,
@@ skipping 41 matching lines @@
   }
 }
 
 void GtkIMContextWrapper::ConfirmComposition() {
   if (!is_enabled_)
     return;
 
   DCHECK(!is_in_key_event_handler_);
 
   if (is_composing_text_) {
-    if (host_view_->GetRenderWidgetHost())
-      static_cast<RenderWidgetHostImpl*>(
+    if (host_view_->GetRenderWidgetHost()) {
+      RenderWidgetHostImpl::From(
           host_view_->GetRenderWidgetHost())->ImeConfirmComposition();
+    }
 
     // Reset the input method.
     CancelComposition();
   }
 }
 
 void GtkIMContextWrapper::HandleCommit(const string16& text) {
   if (suppress_next_commit_) {
     suppress_next_commit_ = false;
     return;
   }
 
   // Append the text to the buffer, because commit signal might be fired
   // multiple times when processing a key event.
   commit_text_.append(text);
   // Nothing needs to do, if it's currently in ProcessKeyEvent()
   // handler, which will send commit text to webkit later. Otherwise,
   // we need send it here.
   // It's possible that commit signal is fired without a key event, for
   // example when user input via a voice or handwriting recognition software.
   // In this case, the text must be committed directly.
   if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost()) {
     // Workaround http://crbug.com/45478 by sending fake key down/up events.
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
-    static_cast<RenderWidgetHostImpl*>(
+    RenderWidgetHostImpl::From(
         host_view_->GetRenderWidgetHost())->ImeConfirmComposition(text);
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
   }
 }
 
 void GtkIMContextWrapper::HandlePreeditStart() {
   // Ignore preedit related signals triggered by CancelComposition() method.
   if (suppress_next_commit_)
     return;
   is_composing_text_ = true;
@@ skipping 28 matching lines @@
   // Otherwise, we need send it here if it's been changed.
   if (!is_in_key_event_handler_ && is_composing_text_ &&
       host_view_->GetRenderWidgetHost()) {
     // Workaround http://crbug.com/45478 by sending fake key down/up events.
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
     // TODO(suzhe): convert both renderer_host and renderer to use
     // ui::CompositionText.
     const std::vector<WebKit::WebCompositionUnderline>& underlines =
         reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
             composition_.underlines);
-    static_cast<RenderWidgetHostImpl*>(
+    RenderWidgetHostImpl::From(
         host_view_->GetRenderWidgetHost())->ImeSetComposition(
-        composition_.text, underlines, composition_.selection.start(),
-        composition_.selection.end());
+            composition_.text, underlines, composition_.selection.start(),
+            composition_.selection.end());
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
   }
 }
 
 void GtkIMContextWrapper::HandlePreeditEnd() {
   if (composition_.text.length()) {
     // The composition session has been finished.
     composition_.Clear();
     is_composition_changed_ = true;
 
     // If there is still a preedit text when firing "preedit-end" signal,
     // we need inform webkit to clear it.
     // It's only necessary when it's not in ProcessKeyEvent ().
-    if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost())
-      static_cast<RenderWidgetHostImpl*>(
+    if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost()) {
+      RenderWidgetHostImpl::From(
           host_view_->GetRenderWidgetHost())->ImeCancelComposition();
+    }
   }
 
   // Don't set is_composing_text_ to false here, because "preedit_end"
   // signal may be fired before "commit" signal.
 }
 
 gboolean GtkIMContextWrapper::HandleRetrieveSurrounding(GtkIMContext* context) {
   if (!is_enabled_)
     return TRUE;
 
@@ skipping 69 matching lines @@
 
 void GtkIMContextWrapper::HandleHostViewRealizeThunk(
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewRealize(widget);
 }
 
 void GtkIMContextWrapper::HandleHostViewUnrealizeThunk(
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewUnrealize();
 }