Rename WebKit namespace to blink (part 3)

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 23 matching lines @@
 //   http://msdn.microsoft.com/en-us/library/ms645540(VS.85).aspx
 // - How the IME System Works
 //   http://msdn.microsoft.com/en-us/library/cc194848.aspx
 // - ImmGetVirtualKey Function
 //   http://msdn.microsoft.com/en-us/library/dd318570(VS.85).aspx
 const int kCompositionEventKeyCode = 229;
 
 }  // namespace
 
 // ui::CompositionUnderline should be identical to
-// WebKit::WebCompositionUnderline, so that we can do reinterpret_cast safely.
+// blink::WebCompositionUnderline, so that we can do reinterpret_cast safely.
 // TODO(suzhe): remove it after migrating all code in chrome to use
 // ui::CompositionUnderline.
 COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
-               sizeof(WebKit::WebCompositionUnderline),
+               sizeof(blink::WebCompositionUnderline),
                ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
 
 GtkIMContextWrapper::GtkIMContextWrapper(RenderWidgetHostViewGtk* host_view)
     : host_view_(host_view),
       context_(gtk_im_multicontext_new()),
       context_simple_(gtk_im_context_simple_new()),
       is_focused_(false),
       is_composing_text_(false),
       is_enabled_(false),
       is_in_key_event_handler_(false),
@@ skipping 336 matching lines @@
   // 1. The given key event is a control-key event, (e.g. return, page up,
   //    page down, tab, arrows, etc.) or;
   // 2. The given key event is not a control-key event but printable
   //    characters aren't assigned to the event, (e.g. alt+d, etc.)
   // Create a Char event manually from this key event and send it to the
   // renderer when this Char event contains a printable character which
   // should be processed by WebKit.
   // isSystemKey will be set to true if this key event has Alt modifier,
   // see WebInputEventFactory::keyboardEvent() for details.
   if (wke->text[0]) {
-    wke->type = WebKit::WebInputEvent::Char;
+    wke->type = blink::WebInputEvent::Char;
     wke->skip_in_browser = true;
     host_view_->ForwardKeyboardEvent(*wke);
   }
 }
 
 void GtkIMContextWrapper::ProcessInputMethodResult(const GdkEventKey* event,
                                                    bool filtered) {
   RenderWidgetHostImpl* host = RenderWidgetHostImpl::From(
       host_view_->GetRenderWidgetHost());
   if (!host)
@@ skipping 32 matching lines @@
 
   // Send preedit text only if it's changed.
   // If a text has been committed, then we don't need to send the empty
   // preedit text again.
   if (is_composition_changed_) {
     if (composition_.text.length()) {
       // Another composition session has been started.
       is_composing_text_ = true;
       // TODO(suzhe): convert both renderer_host and renderer to use
       // ui::CompositionText.
-      const std::vector<WebKit::WebCompositionUnderline>& underlines =
-          reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+      const std::vector<blink::WebCompositionUnderline>& underlines =
+          reinterpret_cast<const std::vector<blink::WebCompositionUnderline>&>(
               composition_.underlines);
       host->ImeSetComposition(composition_.text, underlines,
                               composition_.selection.start(),
                               composition_.selection.end());
     } else if (!committed) {
       host->ImeCancelComposition();
     }
   }
 }
 
@@ skipping 23 matching lines @@
   // 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);
+    SendFakeCompositionKeyEvent(blink::WebInputEvent::RawKeyDown);
     RenderWidgetHostImpl::From(
         host_view_->GetRenderWidgetHost())->ImeConfirmComposition(
             text, gfx::Range::InvalidRange(), false);
-    SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
+    SendFakeCompositionKeyEvent(blink::WebInputEvent::KeyUp);
   }
 }
 
 void GtkIMContextWrapper::HandlePreeditStart() {
   // Ignore preedit related signals triggered by CancelComposition() method.
   if (suppress_next_commit_)
     return;
   is_composing_text_ = true;
 }
 
@@ skipping 20 matching lines @@
   // "preedit_start" signal.
   if (composition_.text.length())
     is_composing_text_ = true;
 
   // Nothing needs to do, if it's currently in ProcessKeyEvent()
   // handler, which will send preedit text to webkit later.
   // Otherwise, we need send it here if it's been changed.
   if (!is_in_key_event_handler_ && is_composing_text_ &&
       host_view_->GetRenderWidgetHost()) {
     // Workaround http://crbug.com/45478 by sending fake key down/up events.
-    SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
+    SendFakeCompositionKeyEvent(blink::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>&>(
+    const std::vector<blink::WebCompositionUnderline>& underlines =
+        reinterpret_cast<const std::vector<blink::WebCompositionUnderline>&>(
             composition_.underlines);
     RenderWidgetHostImpl::From(
         host_view_->GetRenderWidgetHost())->ImeSetComposition(
             composition_.text, underlines, composition_.selection.start(),
             composition_.selection.end());
-    SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
+    SendFakeCompositionKeyEvent(blink::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,
@@ skipping 37 matching lines @@
     gtk_im_context_set_client_window(context_simple_, gdk_window);
   }
 }
 
 void GtkIMContextWrapper::HandleHostViewUnrealize() {
   gtk_im_context_set_client_window(context_, NULL);
   gtk_im_context_set_client_window(context_simple_, NULL);
 }
 
 void GtkIMContextWrapper::SendFakeCompositionKeyEvent(
-    WebKit::WebInputEvent::Type type) {
+    blink::WebInputEvent::Type type) {
   NativeWebKeyboardEvent fake_event;
   fake_event.windowsKeyCode = kCompositionEventKeyCode;
   fake_event.skip_in_browser = true;
   fake_event.type = type;
   host_view_->ForwardKeyboardEvent(fake_event);
 }
 
 void GtkIMContextWrapper::HandleCommitThunk(
     GtkIMContext* context, gchar* text, GtkIMContextWrapper* self) {
   self->HandleCommit(UTF8ToUTF16(text));
@@ skipping 29 matching lines @@
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewRealize(widget);
 }
 
 void GtkIMContextWrapper::HandleHostViewUnrealizeThunk(
     GtkWidget* widget, GtkIMContextWrapper* self) {
   self->HandleHostViewUnrealize();
 }
 
 }  // namespace content