Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/ime_adapter_android.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/ime_adapter_android.h"
 
 #include <android/input.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 22 matching lines @@
 // as a key press of character \r.
 NativeWebKeyboardEvent NativeWebKeyboardEventFromKeyEvent(
     JNIEnv* env,
     jobject java_key_event,
     int action,
     int modifiers,
     long time_ms,
     int key_code,
     bool is_system_key,
     int unicode_char) {
-  WebKit::WebInputEvent::Type type = WebKit::WebInputEvent::Undefined;
+  blink::WebInputEvent::Type type = blink::WebInputEvent::Undefined;
   if (action == AKEY_EVENT_ACTION_DOWN)
-    type = WebKit::WebInputEvent::RawKeyDown;
+    type = blink::WebInputEvent::RawKeyDown;
   else if (action == AKEY_EVENT_ACTION_UP)
-    type = WebKit::WebInputEvent::KeyUp;
+    type = blink::WebInputEvent::KeyUp;
   return NativeWebKeyboardEvent(java_key_event, type, modifiers,
       time_ms, key_code, unicode_char, is_system_key);
 }
 
 }  // anonymous namespace
 
 bool RegisterImeAdapter(JNIEnv* env) {
   if (!RegisterNativesImpl(env))
     return false;
 
   Java_ImeAdapter_initializeWebInputEvents(env,
-                                           WebKit::WebInputEvent::RawKeyDown,
-                                           WebKit::WebInputEvent::KeyUp,
-                                           WebKit::WebInputEvent::Char,
-                                           WebKit::WebInputEvent::ShiftKey,
-                                           WebKit::WebInputEvent::AltKey,
-                                           WebKit::WebInputEvent::ControlKey,
-                                           WebKit::WebInputEvent::CapsLockOn,
-                                           WebKit::WebInputEvent::NumLockOn);
+                                           blink::WebInputEvent::RawKeyDown,
+                                           blink::WebInputEvent::KeyUp,
+                                           blink::WebInputEvent::Char,
+                                           blink::WebInputEvent::ShiftKey,
+                                           blink::WebInputEvent::AltKey,
+                                           blink::WebInputEvent::ControlKey,
+                                           blink::WebInputEvent::CapsLockOn,
+                                           blink::WebInputEvent::NumLockOn);
   Java_ImeAdapter_initializeTextInputTypes(
       env,
       ui::TEXT_INPUT_TYPE_NONE,
       ui::TEXT_INPUT_TYPE_TEXT,
       ui::TEXT_INPUT_TYPE_TEXT_AREA,
       ui::TEXT_INPUT_TYPE_PASSWORD,
       ui::TEXT_INPUT_TYPE_SEARCH,
       ui::TEXT_INPUT_TYPE_URL,
       ui::TEXT_INPUT_TYPE_EMAIL,
       ui::TEXT_INPUT_TYPE_TELEPHONE,
@@ skipping 12 matching lines @@
   if (!obj.is_null())
     Java_ImeAdapter_detach(env, obj.obj());
 }
 
 bool ImeAdapterAndroid::SendSyntheticKeyEvent(JNIEnv*,
                                               jobject,
                                               int type,
                                               long time_ms,
                                               int key_code,
                                               int text) {
-  NativeWebKeyboardEvent event(static_cast<WebKit::WebInputEvent::Type>(type),
+  NativeWebKeyboardEvent event(static_cast<blink::WebInputEvent::Type>(type),
                                0 /* modifiers */, time_ms / 1000.0, key_code,
                                text, false /* is_system_key */);
   rwhva_->SendKeyEvent(event);
   return true;
 }
 
 bool ImeAdapterAndroid::SendKeyEvent(JNIEnv* env, jobject,
                                      jobject original_key_event,
                                      int action, int modifiers,
                                      long time_ms, int key_code,
                                      bool is_system_key, int unicode_char) {
   NativeWebKeyboardEvent event = NativeWebKeyboardEventFromKeyEvent(
           env, original_key_event, action, modifiers,
           time_ms, key_code, is_system_key, unicode_char);
   bool key_down_text_insertion =
-      event.type == WebKit::WebInputEvent::RawKeyDown && event.text[0];
+      event.type == blink::WebInputEvent::RawKeyDown && event.text[0];
   // If we are going to follow up with a synthetic Char event, then that's the
   // one we expect to test if it's handled or unhandled, so skip handling the
   // "real" event in the browser.
   event.skip_in_browser = key_down_text_insertion;
   rwhva_->SendKeyEvent(event);
   if (key_down_text_insertion) {
     // Send a Char event, but without an os_event since we don't want to
     // roundtrip back to java such synthetic event.
-    NativeWebKeyboardEvent char_event(WebKit::WebInputEvent::Char, modifiers,
+    NativeWebKeyboardEvent char_event(blink::WebInputEvent::Char, modifiers,
                                       time_ms, key_code, unicode_char,
                                       is_system_key);
     char_event.skip_in_browser = key_down_text_insertion;
     rwhva_->SendKeyEvent(char_event);
   }
   return true;
 }
 
 void ImeAdapterAndroid::SetComposingText(JNIEnv* env, jobject, jstring text,
                                          int new_cursor_pos) {
   RenderWidgetHostImpl* rwhi = GetRenderWidgetHostImpl();
   if (!rwhi)
     return;
 
   string16 text16 = ConvertJavaStringToUTF16(env, text);
-  std::vector<WebKit::WebCompositionUnderline> underlines;
+  std::vector<blink::WebCompositionUnderline> underlines;
   underlines.push_back(
-      WebKit::WebCompositionUnderline(0, text16.length(), SK_ColorBLACK,
+      blink::WebCompositionUnderline(0, text16.length(), SK_ColorBLACK,
                                       false));
   // new_cursor_position is as described in the Android API for
   // InputConnection#setComposingText, whereas the parameters for
   // ImeSetComposition are relative to the start of the composition.
   if (new_cursor_pos > 0)
     new_cursor_pos = text16.length() + new_cursor_pos - 1;
 
   rwhi->ImeSetComposition(text16, underlines, new_cursor_pos, new_cursor_pos);
 }
 
@@ skipping 34 matching lines @@
   rwhi->Send(new ViewMsg_SetEditableSelectionOffsets(rwhi->GetRoutingID(),
                                                      start, end));
 }
 
 void ImeAdapterAndroid::SetComposingRegion(JNIEnv*, jobject,
                                            int start, int end) {
   RenderWidgetHostImpl* rwhi = GetRenderWidgetHostImpl();
   if (!rwhi)
     return;
 
-  std::vector<WebKit::WebCompositionUnderline> underlines;
+  std::vector<blink::WebCompositionUnderline> underlines;
   underlines.push_back(
-      WebKit::WebCompositionUnderline(0, end - start, SK_ColorBLACK, false));
+      blink::WebCompositionUnderline(0, end - start, SK_ColorBLACK, false));
 
   rwhi->Send(new ViewMsg_SetCompositionFromExistingText(
       rwhi->GetRoutingID(), start, end, underlines));
 }
 
 void ImeAdapterAndroid::DeleteSurroundingText(JNIEnv*, jobject,
                                               int before, int after) {
   RenderWidgetHostImpl* rwhi = GetRenderWidgetHostImpl();
   if (!rwhi)
     return;
@@ skipping 49 matching lines @@
 RenderWidgetHostImpl* ImeAdapterAndroid::GetRenderWidgetHostImpl() {
   DCHECK(rwhva_);
   RenderWidgetHost* rwh = rwhva_->GetRenderWidgetHost();
   if (!rwh)
     return NULL;
 
   return RenderWidgetHostImpl::From(rwh);
 }
 
 }  // namespace content