diff options
Diffstat (limited to 'content/browser/renderer_host')
92 files changed, 788 insertions, 788 deletions
diff --git a/content/browser/renderer_host/basic_mouse_wheel_smooth_scroll_gesture.cc b/content/browser/renderer_host/basic_mouse_wheel_smooth_scroll_gesture.cc index e456337..f43e077 100644 --- a/content/browser/renderer_host/basic_mouse_wheel_smooth_scroll_gesture.cc +++ b/content/browser/renderer_host/basic_mouse_wheel_smooth_scroll_gesture.cc @@ -31,8 +31,8 @@ bool BasicMouseWheelSmoothScrollGesture::ForwardInputEvents( RenderWidgetHostImpl::From(host)->GetSyntheticGestureMessageInterval()); - WebKit::WebMouseWheelEvent event; - event.type = WebKit::WebInputEvent::MouseWheel; + blink::WebMouseWheelEvent event; + event.type = blink::WebInputEvent::MouseWheel; event.hasPreciseScrollingDeltas = 0; event.deltaY = scroll_down_ ? -position_delta : position_delta; // TODO(vollick): find a proper way to access diff --git a/content/browser/renderer_host/compositor_impl_android.cc b/content/browser/renderer_host/compositor_impl_android.cc index 3687a41..3189e9f 100644 --- a/content/browser/renderer_host/compositor_impl_android.cc +++ b/content/browser/renderer_host/compositor_impl_android.cc @@ -272,15 +272,15 @@ void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) { ui_resource_map_.erase(it); } -WebKit::WebGLId CompositorImpl::GenerateTexture(gfx::JavaBitmap& bitmap) { +blink::WebGLId CompositorImpl::GenerateTexture(gfx::JavaBitmap& bitmap) { unsigned int texture_id = BuildBasicTexture(); - WebKit::WebGraphicsContext3D* context = + blink::WebGraphicsContext3D* context = ImageTransportFactoryAndroid::GetInstance()->GetContext3D(); if (texture_id == 0 || context->isContextLost() || !context->makeContextCurrent()) return 0; - WebKit::WebGLId format = GetGLFormatForBitmap(bitmap); - WebKit::WebGLId type = GetGLTypeForBitmap(bitmap); + blink::WebGLId format = GetGLFormatForBitmap(bitmap); + blink::WebGLId type = GetGLTypeForBitmap(bitmap); context->texImage2D(GL_TEXTURE_2D, 0, @@ -295,11 +295,11 @@ WebKit::WebGLId CompositorImpl::GenerateTexture(gfx::JavaBitmap& bitmap) { return texture_id; } -WebKit::WebGLId CompositorImpl::GenerateCompressedTexture(gfx::Size& size, +blink::WebGLId CompositorImpl::GenerateCompressedTexture(gfx::Size& size, int data_size, void* data) { unsigned int texture_id = BuildBasicTexture(); - WebKit::WebGraphicsContext3D* context = + blink::WebGraphicsContext3D* context = ImageTransportFactoryAndroid::GetInstance()->GetContext3D(); if (texture_id == 0 || context->isContextLost() || !context->makeContextCurrent()) @@ -316,8 +316,8 @@ WebKit::WebGLId CompositorImpl::GenerateCompressedTexture(gfx::Size& size, return texture_id; } -void CompositorImpl::DeleteTexture(WebKit::WebGLId texture_id) { - WebKit::WebGraphicsContext3D* context = +void CompositorImpl::DeleteTexture(blink::WebGLId texture_id) { + blink::WebGraphicsContext3D* context = ImageTransportFactoryAndroid::GetInstance()->GetContext3D(); if (context->isContextLost() || !context->makeContextCurrent()) return; @@ -325,12 +325,12 @@ void CompositorImpl::DeleteTexture(WebKit::WebGLId texture_id) { context->shallowFlushCHROMIUM(); } -bool CompositorImpl::CopyTextureToBitmap(WebKit::WebGLId texture_id, +bool CompositorImpl::CopyTextureToBitmap(blink::WebGLId texture_id, gfx::JavaBitmap& bitmap) { return CopyTextureToBitmap(texture_id, gfx::Rect(bitmap.size()), bitmap); } -bool CompositorImpl::CopyTextureToBitmap(WebKit::WebGLId texture_id, +bool CompositorImpl::CopyTextureToBitmap(blink::WebGLId texture_id, const gfx::Rect& sub_rect, gfx::JavaBitmap& bitmap) { // The sub_rect should match the bitmap size. @@ -346,7 +346,7 @@ bool CompositorImpl::CopyTextureToBitmap(WebKit::WebGLId texture_id, static scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateGpuProcessViewContext( - const WebKit::WebGraphicsContext3D::Attributes attributes, + const blink::WebGraphicsContext3D::Attributes attributes, int surface_id, base::WeakPtr<CompositorImpl> compositor_impl) { BrowserGpuChannelHostFactory* factory = @@ -384,7 +384,7 @@ CreateGpuProcessViewContext( scoped_ptr<cc::OutputSurface> CompositorImpl::CreateOutputSurface( bool fallback) { - WebKit::WebGraphicsContext3D::Attributes attrs; + blink::WebGraphicsContext3D::Attributes attrs; attrs.shareResources = true; attrs.noAutomaticFlushes = true; @@ -439,12 +439,12 @@ void CompositorImpl::OnViewContextSwapBuffersAborted() { client_->OnSwapBuffersCompleted(); } -WebKit::WebGLId CompositorImpl::BuildBasicTexture() { - WebKit::WebGraphicsContext3D* context = +blink::WebGLId CompositorImpl::BuildBasicTexture() { + blink::WebGraphicsContext3D* context = ImageTransportFactoryAndroid::GetInstance()->GetContext3D(); if (context->isContextLost() || !context->makeContextCurrent()) return 0; - WebKit::WebGLId texture_id = context->createTexture(); + blink::WebGLId texture_id = context->createTexture(); context->bindTexture(GL_TEXTURE_2D, texture_id); context->texParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); context->texParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); @@ -453,7 +453,7 @@ WebKit::WebGLId CompositorImpl::BuildBasicTexture() { return texture_id; } -WebKit::WGC3Denum CompositorImpl::GetGLFormatForBitmap( +blink::WGC3Denum CompositorImpl::GetGLFormatForBitmap( gfx::JavaBitmap& bitmap) { switch (bitmap.format()) { case ANDROID_BITMAP_FORMAT_A_8: @@ -471,7 +471,7 @@ WebKit::WGC3Denum CompositorImpl::GetGLFormatForBitmap( } } -WebKit::WGC3Denum CompositorImpl::GetGLTypeForBitmap(gfx::JavaBitmap& bitmap) { +blink::WGC3Denum CompositorImpl::GetGLTypeForBitmap(gfx::JavaBitmap& bitmap) { switch (bitmap.format()) { case ANDROID_BITMAP_FORMAT_A_8: return GL_UNSIGNED_BYTE; diff --git a/content/browser/renderer_host/compositor_impl_android.h b/content/browser/renderer_host/compositor_impl_android.h index ece532d..95546000 100644 --- a/content/browser/renderer_host/compositor_impl_android.h +++ b/content/browser/renderer_host/compositor_impl_android.h @@ -62,13 +62,13 @@ class CONTENT_EXPORT CompositorImpl virtual cc::UIResourceId GenerateUIResource( const cc::UIResourceBitmap& bitmap) OVERRIDE; virtual void DeleteUIResource(cc::UIResourceId resource_id) OVERRIDE; - virtual WebKit::WebGLId GenerateTexture(gfx::JavaBitmap& bitmap) OVERRIDE; - virtual WebKit::WebGLId GenerateCompressedTexture( + virtual blink::WebGLId GenerateTexture(gfx::JavaBitmap& bitmap) OVERRIDE; + virtual blink::WebGLId GenerateCompressedTexture( gfx::Size& size, int data_size, void* data) OVERRIDE; - virtual void DeleteTexture(WebKit::WebGLId texture_id) OVERRIDE; - virtual bool CopyTextureToBitmap(WebKit::WebGLId texture_id, + virtual void DeleteTexture(blink::WebGLId texture_id) OVERRIDE; + virtual bool CopyTextureToBitmap(blink::WebGLId texture_id, gfx::JavaBitmap& bitmap) OVERRIDE; - virtual bool CopyTextureToBitmap(WebKit::WebGLId texture_id, + virtual bool CopyTextureToBitmap(blink::WebGLId texture_id, const gfx::Rect& sub_rect, gfx::JavaBitmap& bitmap) OVERRIDE; @@ -103,9 +103,9 @@ class CONTENT_EXPORT CompositorImpl virtual void OnLostResources() OVERRIDE; private: - WebKit::WebGLId BuildBasicTexture(); - WebKit::WGC3Denum GetGLFormatForBitmap(gfx::JavaBitmap& bitmap); - WebKit::WGC3Denum GetGLTypeForBitmap(gfx::JavaBitmap& bitmap); + blink::WebGLId BuildBasicTexture(); + blink::WGC3Denum GetGLFormatForBitmap(gfx::JavaBitmap& bitmap); + blink::WGC3Denum GetGLTypeForBitmap(gfx::JavaBitmap& bitmap); scoped_refptr<cc::Layer> root_layer_; scoped_ptr<cc::LayerTreeHost> host_; diff --git a/content/browser/renderer_host/gtk_im_context_wrapper.cc b/content/browser/renderer_host/gtk_im_context_wrapper.cc index e79faba..7ce6558 100644 --- a/content/browser/renderer_host/gtk_im_context_wrapper.cc +++ b/content/browser/renderer_host/gtk_im_context_wrapper.cc @@ -41,11 +41,11 @@ 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) @@ -402,7 +402,7 @@ void GtkIMContextWrapper::ProcessUnfilteredKeyPressEvent( // 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); } @@ -455,8 +455,8 @@ void GtkIMContextWrapper::ProcessInputMethodResult(const GdkEventKey* event, 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(), @@ -500,11 +500,11 @@ void GtkIMContextWrapper::HandleCommit(const string16& text) { // 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); } } @@ -545,17 +545,17 @@ void GtkIMContextWrapper::HandlePreeditChanged(const gchar* text, 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); } } @@ -613,7 +613,7 @@ void GtkIMContextWrapper::HandleHostViewUnrealize() { } void GtkIMContextWrapper::SendFakeCompositionKeyEvent( - WebKit::WebInputEvent::Type type) { + blink::WebInputEvent::Type type) { NativeWebKeyboardEvent fake_event; fake_event.windowsKeyCode = kCompositionEventKeyCode; fake_event.skip_in_browser = true; diff --git a/content/browser/renderer_host/gtk_im_context_wrapper.h b/content/browser/renderer_host/gtk_im_context_wrapper.h index 9f13551..1647df1 100644 --- a/content/browser/renderer_host/gtk_im_context_wrapper.h +++ b/content/browser/renderer_host/gtk_im_context_wrapper.h @@ -101,7 +101,7 @@ class GtkIMContextWrapper { // Sends a fake composition key event with specified event type. A composition // key event is a key event with special key code 229. - void SendFakeCompositionKeyEvent(WebKit::WebInputEvent::Type type); + void SendFakeCompositionKeyEvent(blink::WebInputEvent::Type type); // Signal handlers of GtkIMContext object. static void HandleCommitThunk(GtkIMContext* context, gchar* text, diff --git a/content/browser/renderer_host/gtk_key_bindings_handler.cc b/content/browser/renderer_host/gtk_key_bindings_handler.cc index 5a05eeb..3830364 100644 --- a/content/browser/renderer_host/gtk_key_bindings_handler.cc +++ b/content/browser/renderer_host/gtk_key_bindings_handler.cc @@ -29,7 +29,7 @@ GtkKeyBindingsHandler::~GtkKeyBindingsHandler() { bool GtkKeyBindingsHandler::Match(const NativeWebKeyboardEvent& wke, EditCommands* edit_commands) { - if (wke.type == WebKit::WebInputEvent::Char || !wke.os_event) + if (wke.type == blink::WebInputEvent::Char || !wke.os_event) return false; edit_commands_.clear(); diff --git a/content/browser/renderer_host/gtk_window_utils.cc b/content/browser/renderer_host/gtk_window_utils.cc index f05cdca..b176323 100644 --- a/content/browser/renderer_host/gtk_window_utils.cc +++ b/content/browser/renderer_host/gtk_window_utils.cc @@ -45,7 +45,7 @@ gfx::Rect GetWorkArea(Window window) { property[start_index + 2], property[start_index + 3]); } -WebKit::WebScreenInfo GetScreenInfo(XDisplay* display, int screenNumber) { +blink::WebScreenInfo GetScreenInfo(XDisplay* display, int screenNumber) { // XDisplayWidth() and XDisplayHeight() return cached values. To ensure that // we return the correct dimensions after the screen is resized, query the // root window's geometry each time. @@ -56,11 +56,11 @@ WebKit::WebScreenInfo GetScreenInfo(XDisplay* display, int screenNumber) { XGetGeometry( display, root, &root_ret, &x, &y, &width, &height, &border, &depth); - WebKit::WebScreenInfo results; + blink::WebScreenInfo results; results.depthPerComponent = 8; // Assume 8bpp, which is usually right. results.depth = depth; results.isMonochrome = depth == 1; - results.rect = WebKit::WebRect(x, y, width, height); + results.rect = blink::WebRect(x, y, width, height); results.availableRect = results.rect; return results; } @@ -68,7 +68,7 @@ WebKit::WebScreenInfo GetScreenInfo(XDisplay* display, int screenNumber) { } // namespace void GetScreenInfoFromNativeWindow( - GdkWindow* gdk_window, WebKit::WebScreenInfo* results) { + GdkWindow* gdk_window, blink::WebScreenInfo* results) { GdkScreen* screen = gdk_window_get_screen(gdk_window); *results = GetScreenInfo(gdk_x11_drawable_get_xdisplay(gdk_window), gdk_x11_screen_get_screen_number(screen)); @@ -76,7 +76,7 @@ void GetScreenInfoFromNativeWindow( int monitor_number = gdk_screen_get_monitor_at_window(screen, gdk_window); GdkRectangle monitor_rect; gdk_screen_get_monitor_geometry(screen, monitor_number, &monitor_rect); - results->rect = WebKit::WebRect(monitor_rect.x, monitor_rect.y, + results->rect = blink::WebRect(monitor_rect.x, monitor_rect.y, monitor_rect.width, monitor_rect.height); gfx::Rect available_rect = results->rect; diff --git a/content/browser/renderer_host/gtk_window_utils.h b/content/browser/renderer_host/gtk_window_utils.h index ed0cfe1..93f1d68 100644 --- a/content/browser/renderer_host/gtk_window_utils.h +++ b/content/browser/renderer_host/gtk_window_utils.h @@ -9,14 +9,14 @@ typedef struct _GdkDrawable GdkWindow; -namespace WebKit { +namespace blink { struct WebScreenInfo; } namespace content { CONTENT_EXPORT void GetScreenInfoFromNativeWindow( - GdkWindow* gdk_window, WebKit::WebScreenInfo* results); + GdkWindow* gdk_window, blink::WebScreenInfo* results); } // namespace content diff --git a/content/browser/renderer_host/image_transport_factory_android.cc b/content/browser/renderer_host/image_transport_factory_android.cc index 1c5d891..380cc7a 100644 --- a/content/browser/renderer_host/image_transport_factory_android.cc +++ b/content/browser/renderer_host/image_transport_factory_android.cc @@ -20,7 +20,7 @@ base::LazyInstance<ObserverList<ImageTransportFactoryAndroidObserver> >::Leaky g_factory_observers = LAZY_INSTANCE_INITIALIZER; class GLContextLostListener - : public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback { + : public blink::WebGraphicsContext3D::WebGraphicsContextLostCallback { public: // WebGraphicsContextLostCallback implementation. virtual void onContextLost() OVERRIDE; @@ -43,7 +43,7 @@ class CmdBufferImageTransportFactory : public ImageTransportFactoryAndroid { virtual void DeleteTexture(uint32_t id) OVERRIDE; virtual void AcquireTexture( uint32 texture_id, const signed char* mailbox_name) OVERRIDE; - virtual WebKit::WebGraphicsContext3D* GetContext3D() OVERRIDE { + virtual blink::WebGraphicsContext3D* GetContext3D() OVERRIDE { return context_.get(); } virtual GLHelper* GetGLHelper() OVERRIDE; @@ -62,7 +62,7 @@ CmdBufferImageTransportFactory::CmdBufferImageTransportFactory() { CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE)); DCHECK(gpu_channel_host); - WebKit::WebGraphicsContext3D::Attributes attrs; + blink::WebGraphicsContext3D::Attributes attrs; attrs.shareResources = true; GURL url("chrome://gpu/ImageTransportFactoryAndroid"); base::WeakPtr<WebGraphicsContext3DSwapBuffersClient> swap_client; diff --git a/content/browser/renderer_host/image_transport_factory_android.h b/content/browser/renderer_host/image_transport_factory_android.h index 22dc09e..e6d5f9b 100644 --- a/content/browser/renderer_host/image_transport_factory_android.h +++ b/content/browser/renderer_host/image_transport_factory_android.h @@ -12,7 +12,7 @@ namespace gfx { class GLShareGroup; } -namespace WebKit { +namespace blink { class WebGraphicsContext3D; } @@ -39,7 +39,7 @@ class ImageTransportFactoryAndroid { virtual void AcquireTexture( uint32 texture_id, const signed char* mailbox_name) = 0; - virtual WebKit::WebGraphicsContext3D* GetContext3D() = 0; + virtual blink::WebGraphicsContext3D* GetContext3D() = 0; virtual GLHelper* GetGLHelper() = 0; static void AddObserver(ImageTransportFactoryAndroidObserver* observer); diff --git a/content/browser/renderer_host/ime_adapter_android.cc b/content/browser/renderer_host/ime_adapter_android.cc index abda01f..9e7fe47 100644 --- a/content/browser/renderer_host/ime_adapter_android.cc +++ b/content/browser/renderer_host/ime_adapter_android.cc @@ -40,11 +40,11 @@ NativeWebKeyboardEvent NativeWebKeyboardEventFromKeyEvent( 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); } @@ -56,14 +56,14 @@ bool RegisterImeAdapter(JNIEnv* 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, @@ -96,7 +96,7 @@ bool ImeAdapterAndroid::SendSyntheticKeyEvent(JNIEnv*, 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); @@ -112,7 +112,7 @@ bool ImeAdapterAndroid::SendKeyEvent(JNIEnv* env, jobject, 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. @@ -121,7 +121,7 @@ bool ImeAdapterAndroid::SendKeyEvent(JNIEnv* env, jobject, 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; @@ -137,9 +137,9 @@ void ImeAdapterAndroid::SetComposingText(JNIEnv* env, jobject, jstring text, 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 @@ -194,9 +194,9 @@ void ImeAdapterAndroid::SetComposingRegion(JNIEnv*, jobject, 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)); diff --git a/content/browser/renderer_host/ime_adapter_android.h b/content/browser/renderer_host/ime_adapter_android.h index a3e273e..ce3c335 100644 --- a/content/browser/renderer_host/ime_adapter_android.h +++ b/content/browser/renderer_host/ime_adapter_android.h @@ -27,7 +27,7 @@ class ImeAdapterAndroid { // Called from java -> native // The java side is responsible to translate android KeyEvent various enums - // and values into the corresponding WebKit::WebInputEvent. + // and values into the corresponding blink::WebInputEvent. bool SendKeyEvent(JNIEnv* env, jobject, jobject original_key_event, int action, int meta_state, diff --git a/content/browser/renderer_host/input/gesture_event_filter.cc b/content/browser/renderer_host/input/gesture_event_filter.cc index 4ab6f77..cb8f4a3 100644 --- a/content/browser/renderer_host/input/gesture_event_filter.cc +++ b/content/browser/renderer_host/input/gesture_event_filter.cc @@ -11,8 +11,8 @@ #include "content/browser/renderer_host/input/touchscreen_tap_suppression_controller.h" #include "content/public/common/content_switches.h" -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; +using blink::WebGestureEvent; +using blink::WebInputEvent; namespace content { namespace { diff --git a/content/browser/renderer_host/input/gesture_event_filter.h b/content/browser/renderer_host/input/gesture_event_filter.h index 61cb7f7..7ed57de 100644 --- a/content/browser/renderer_host/input/gesture_event_filter.h +++ b/content/browser/renderer_host/input/gesture_event_filter.h @@ -74,7 +74,7 @@ class CONTENT_EXPORT GestureEventFilter { // with state |ack_result| and event |type|. May send events if the queue is // not empty. void ProcessGestureAck(InputEventAckState ack_result, - WebKit::WebInputEvent::Type type, + blink::WebInputEvent::Type type, const ui::LatencyInfo& latency); // Sets the state of the |fling_in_progress_| field to indicate that a fling @@ -93,7 +93,7 @@ class CONTENT_EXPORT GestureEventFilter { friend class MockRenderWidgetHost; friend class GestureEventFilterTest; - static bool ShouldIgnoreAckForGestureType(WebKit::WebInputEvent::Type type); + static bool ShouldIgnoreAckForGestureType(blink::WebInputEvent::Type type); // TODO(mohsen): There are a bunch of ShouldForward.../ShouldDiscard... // methods that are getting confusing. This should be somehow fixed. Maybe diff --git a/content/browser/renderer_host/input/gesture_event_filter_unittest.cc b/content/browser/renderer_host/input/gesture_event_filter_unittest.cc index c852ef4..4dfda33 100644 --- a/content/browser/renderer_host/input/gesture_event_filter_unittest.cc +++ b/content/browser/renderer_host/input/gesture_event_filter_unittest.cc @@ -17,8 +17,8 @@ #include "third_party/WebKit/public/web/WebInputEvent.h" using base::TimeDelta; -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; +using blink::WebGestureEvent; +using blink::WebInputEvent; namespace content { diff --git a/content/browser/renderer_host/input/immediate_input_router.cc b/content/browser/renderer_host/input/immediate_input_router.cc index 444678f..06bbc95 100644 --- a/content/browser/renderer_host/input/immediate_input_router.cc +++ b/content/browser/renderer_host/input/immediate_input_router.cc @@ -30,11 +30,11 @@ using base::Time; using base::TimeDelta; using base::TimeTicks; -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebKeyboardEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebKeyboardEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; namespace content { namespace { @@ -355,8 +355,8 @@ bool ImmediateInputRouter::OfferToOverscrollController( if (disposition == OverscrollController::SHOULD_FORWARD_TO_GESTURE_FILTER) { DCHECK(WebInputEvent::isGestureEventType(input_event.type)); - const WebKit::WebGestureEvent& gesture_event = - static_cast<const WebKit::WebGestureEvent&>(input_event); + const blink::WebGestureEvent& gesture_event = + static_cast<const blink::WebGestureEvent&>(input_event); // An ACK is expected for the event, so mark it as consumed. consumed = !gesture_event_filter_->ShouldForward( GestureEventWithLatencyInfo(gesture_event, latency_info)); @@ -497,7 +497,7 @@ void ImmediateInputRouter::ProcessInputEventAck( } void ImmediateInputRouter::ProcessKeyboardAck( - WebKit::WebInputEvent::Type type, + blink::WebInputEvent::Type type, InputEventAckState ack_result) { if (key_queue_.empty()) { ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK); @@ -518,7 +518,7 @@ void ImmediateInputRouter::ProcessKeyboardAck( } } -void ImmediateInputRouter::ProcessMouseAck(WebKit::WebInputEvent::Type type, +void ImmediateInputRouter::ProcessMouseAck(blink::WebInputEvent::Type type, InputEventAckState ack_result) { if (type != WebInputEvent::MouseMove) return; diff --git a/content/browser/renderer_host/input/immediate_input_router.h b/content/browser/renderer_host/input/immediate_input_router.h index cc760bd..0c6a71a 100644 --- a/content/browser/renderer_host/input/immediate_input_router.h +++ b/content/browser/renderer_host/input/immediate_input_router.h @@ -91,33 +91,33 @@ private: bool Send(IPC::Message* message); // Filters and forwards |input_event| to the appropriate handler. - void FilterAndSendWebInputEvent(const WebKit::WebInputEvent& input_event, + void FilterAndSendWebInputEvent(const blink::WebInputEvent& input_event, const ui::LatencyInfo& latency_info, bool is_keyboard_shortcut); // Utility routine for filtering and forwarding |input_event| to the // appropriate handler. |input_event| will be offered to the overscroll // controller, client and renderer, in that order. - void OfferToHandlers(const WebKit::WebInputEvent& input_event, + void OfferToHandlers(const blink::WebInputEvent& input_event, const ui::LatencyInfo& latency_info, bool is_keyboard_shortcut); // Returns true if |input_event| was consumed by the overscroll controller. - bool OfferToOverscrollController(const WebKit::WebInputEvent& input_event, + bool OfferToOverscrollController(const blink::WebInputEvent& input_event, const ui::LatencyInfo& latency_info); // Returns true if |input_event| was consumed by the client. - bool OfferToClient(const WebKit::WebInputEvent& input_event, + bool OfferToClient(const blink::WebInputEvent& input_event, const ui::LatencyInfo& latency_info); // Returns true if |input_event| was successfully sent to the renderer // as an async IPC Message. - bool OfferToRenderer(const WebKit::WebInputEvent& input_event, + bool OfferToRenderer(const blink::WebInputEvent& input_event, const ui::LatencyInfo& latency_info, bool is_keyboard_shortcut); // IPC message handlers - void OnInputEventAck(WebKit::WebInputEvent::Type event_type, + void OnInputEventAck(blink::WebInputEvent::Type event_type, InputEventAckState ack_result, const ui::LatencyInfo& latency_info); void OnMsgMoveCaretAck(); @@ -134,17 +134,17 @@ private: }; // Note: This function may result in |this| being deleted, and as such // should be the last method called in any internal chain of event handling. - void ProcessInputEventAck(WebKit::WebInputEvent::Type event_type, + void ProcessInputEventAck(blink::WebInputEvent::Type event_type, InputEventAckState ack_result, const ui::LatencyInfo& latency_info, AckSource ack_source); // Dispatches the ack'ed event to |ack_handler_|. - void ProcessKeyboardAck(WebKit::WebInputEvent::Type type, + void ProcessKeyboardAck(blink::WebInputEvent::Type type, InputEventAckState ack_result); // Forwards a valid |next_mouse_move_| if |type| is MouseMove. - void ProcessMouseAck(WebKit::WebInputEvent::Type type, + void ProcessMouseAck(blink::WebInputEvent::Type type, InputEventAckState ack_result); // Dispatches the ack'ed event to |ack_handler_|, forwarding queued events @@ -154,7 +154,7 @@ private: // Forwards the event ack to |gesture_event_filter|, potentially triggering // dispatch of queued gesture events. - void ProcessGestureAck(WebKit::WebInputEvent::Type type, + void ProcessGestureAck(blink::WebInputEvent::Type type, InputEventAckState ack_result, const ui::LatencyInfo& latency); @@ -164,7 +164,7 @@ private: const ui::LatencyInfo& latency); // Forwards |ack_result| to the client's OverscrollController, if necessary. - void ProcessAckForOverscroll(const WebKit::WebInputEvent& event, + void ProcessAckForOverscroll(const blink::WebInputEvent& event, InputEventAckState ack_result); void HandleGestureScroll(const GestureEventWithLatencyInfo& gesture_event); diff --git a/content/browser/renderer_host/input/immediate_input_router_unittest.cc b/content/browser/renderer_host/input/immediate_input_router_unittest.cc index 63ef7d2..5162555 100644 --- a/content/browser/renderer_host/input/immediate_input_router_unittest.cc +++ b/content/browser/renderer_host/input/immediate_input_router_unittest.cc @@ -25,12 +25,12 @@ #endif using base::TimeDelta; -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebTouchEvent; -using WebKit::WebTouchPoint; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; +using blink::WebTouchEvent; +using blink::WebTouchPoint; namespace content { @@ -117,7 +117,7 @@ class ImmediateInputRouterTest : public InputRouterTest { new ImmediateInputRouter(process, client, handler, routing_id)); } - void SendInputEventACK(WebKit::WebInputEvent::Type type, + void SendInputEventACK(blink::WebInputEvent::Type type, InputEventAckState ack_result) { scoped_ptr<IPC::Message> response( new InputHostMsg_HandleInputEvent_ACK(0, type, ack_result, diff --git a/content/browser/renderer_host/input/input_router_client.h b/content/browser/renderer_host/input/input_router_client.h index ebe04c6..fefcb10 100644 --- a/content/browser/renderer_host/input/input_router_client.h +++ b/content/browser/renderer_host/input/input_router_client.h @@ -30,7 +30,7 @@ class CONTENT_EXPORT InputRouterClient { // * |CONSUMED| or |NO_CONSUMER_EXISTS| will trigger the appropriate ack. // * |UNKNOWN| will result in |input_event| being dropped. virtual InputEventAckState FilterInputEvent( - const WebKit::WebInputEvent& input_event, + const blink::WebInputEvent& input_event, const ui::LatencyInfo& latency_info) = 0; // Called each time a WebInputEvent IPC is sent. diff --git a/content/browser/renderer_host/input/input_router_unittest.cc b/content/browser/renderer_host/input/input_router_unittest.cc index 48ec3bf..55ee320 100644 --- a/content/browser/renderer_host/input/input_router_unittest.cc +++ b/content/browser/renderer_host/input/input_router_unittest.cc @@ -7,12 +7,12 @@ #include "content/browser/renderer_host/input/input_router.h" #include "content/common/input_messages.h" -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebTouchEvent; -using WebKit::WebTouchPoint; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; +using blink::WebTouchEvent; +using blink::WebTouchPoint; namespace content { diff --git a/content/browser/renderer_host/input/input_router_unittest.h b/content/browser/renderer_host/input/input_router_unittest.h index bd1e6f4..50c8184 100644 --- a/content/browser/renderer_host/input/input_router_unittest.h +++ b/content/browser/renderer_host/input/input_router_unittest.h @@ -36,16 +36,16 @@ class InputRouterTest : public testing::Test { virtual void SetUp() OVERRIDE; virtual void TearDown() OVERRIDE; - void SendInputEventACK(WebKit::WebInputEvent::Type type, + void SendInputEventACK(blink::WebInputEvent::Type type, InputEventAckState ack_result); - void SimulateKeyboardEvent(WebKit::WebInputEvent::Type type, + void SimulateKeyboardEvent(blink::WebInputEvent::Type type, bool is_shortcut); void SimulateWheelEvent(float dX, float dY, int modifiers, bool precise); void SimulateMouseMove(int x, int y, int modifiers); - void SimulateWheelEventWithPhase(WebKit::WebMouseWheelEvent::Phase phase); - void SimulateGestureEvent(const WebKit::WebGestureEvent& event); - void SimulateGestureEvent(WebKit::WebInputEvent::Type type, - WebKit::WebGestureEvent::SourceDevice sourceDevice); + void SimulateWheelEventWithPhase(blink::WebMouseWheelEvent::Phase phase); + void SimulateGestureEvent(const blink::WebGestureEvent& event); + void SimulateGestureEvent(blink::WebInputEvent::Type type, + blink::WebGestureEvent::SourceDevice sourceDevice); void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers); void SimulateGesturePinchUpdateEvent(float scale, float anchorX, @@ -54,7 +54,7 @@ class InputRouterTest : public testing::Test { void SimulateGestureFlingStartEvent( float velocityX, float velocityY, - WebKit::WebGestureEvent::SourceDevice sourceDevice); + blink::WebGestureEvent::SourceDevice sourceDevice); void SimulateTouchEvent(int x, int y); void SetTouchTimestamp(base::TimeDelta timestamp); diff --git a/content/browser/renderer_host/input/mock_input_ack_handler.cc b/content/browser/renderer_host/input/mock_input_ack_handler.cc index 04f1cf8..0ab903f 100644 --- a/content/browser/renderer_host/input/mock_input_ack_handler.cc +++ b/content/browser/renderer_host/input/mock_input_ack_handler.cc @@ -8,12 +8,12 @@ #include "testing/gtest/include/gtest/gtest.h" using base::TimeDelta; -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebTouchEvent; -using WebKit::WebTouchPoint; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; +using blink::WebTouchEvent; +using blink::WebTouchPoint; namespace content { diff --git a/content/browser/renderer_host/input/mock_input_ack_handler.h b/content/browser/renderer_host/input/mock_input_ack_handler.h index 27b8229..88ca9e1 100644 --- a/content/browser/renderer_host/input/mock_input_ack_handler.h +++ b/content/browser/renderer_host/input/mock_input_ack_handler.h @@ -50,13 +50,13 @@ class MockInputAckHandler : public InputAckHandler { const NativeWebKeyboardEvent& acked_keyboard_event() const { return acked_key_event_; } - const WebKit::WebMouseWheelEvent& acked_wheel_event() const { + const blink::WebMouseWheelEvent& acked_wheel_event() const { return acked_wheel_event_; } const TouchEventWithLatencyInfo& acked_touch_event() const { return acked_touch_event_; } - const WebKit::WebGestureEvent& acked_gesture_event() const { + const blink::WebGestureEvent& acked_gesture_event() const { return acked_gesture_event_; } @@ -69,9 +69,9 @@ class MockInputAckHandler : public InputAckHandler { bool unexpected_event_ack_called_; InputEventAckState ack_state_; NativeWebKeyboardEvent acked_key_event_; - WebKit::WebMouseWheelEvent acked_wheel_event_; + blink::WebMouseWheelEvent acked_wheel_event_; TouchEventWithLatencyInfo acked_touch_event_; - WebKit::WebGestureEvent acked_gesture_event_; + blink::WebGestureEvent acked_gesture_event_; scoped_ptr<GestureEventWithLatencyInfo> gesture_followup_event_; scoped_ptr<TouchEventWithLatencyInfo> touch_followup_event_; diff --git a/content/browser/renderer_host/input/mock_input_router_client.cc b/content/browser/renderer_host/input/mock_input_router_client.cc index 1484d22..436f0b0 100644 --- a/content/browser/renderer_host/input/mock_input_router_client.cc +++ b/content/browser/renderer_host/input/mock_input_router_client.cc @@ -9,12 +9,12 @@ #include "testing/gtest/include/gtest/gtest.h" using base::TimeDelta; -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebTouchEvent; -using WebKit::WebTouchPoint; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; +using blink::WebTouchEvent; +using blink::WebTouchPoint; namespace content { diff --git a/content/browser/renderer_host/input/mock_input_router_client.h b/content/browser/renderer_host/input/mock_input_router_client.h index 05513728..d2ea81d 100644 --- a/content/browser/renderer_host/input/mock_input_router_client.h +++ b/content/browser/renderer_host/input/mock_input_router_client.h @@ -20,7 +20,7 @@ class MockInputRouterClient : public InputRouterClient { // InputRouterClient virtual InputEventAckState FilterInputEvent( - const WebKit::WebInputEvent& input_event, + const blink::WebInputEvent& input_event, const ui::LatencyInfo& latency_info) OVERRIDE; virtual void IncrementInFlightEventCount() OVERRIDE; virtual void DecrementInFlightEventCount() OVERRIDE; diff --git a/content/browser/renderer_host/input/synthetic_gesture_controller_new_unittest.cc b/content/browser/renderer_host/input/synthetic_gesture_controller_new_unittest.cc index 5d00354..0740440 100644 --- a/content/browser/renderer_host/input/synthetic_gesture_controller_new_unittest.cc +++ b/content/browser/renderer_host/input/synthetic_gesture_controller_new_unittest.cc @@ -99,10 +99,10 @@ class MockSyntheticSmoothScrollMouseTarget : public MockSyntheticGestureTarget { virtual ~MockSyntheticSmoothScrollMouseTarget() {} virtual void QueueInputEventToPlatform(const InputEvent& event) OVERRIDE { - const WebKit::WebInputEvent* web_event = event.web_event.get(); - DCHECK_EQ(web_event->type, WebKit::WebInputEvent::MouseWheel); - const WebKit::WebMouseWheelEvent* mouse_wheel_event = - static_cast<const WebKit::WebMouseWheelEvent*>(web_event); + const blink::WebInputEvent* web_event = event.web_event.get(); + DCHECK_EQ(web_event->type, blink::WebInputEvent::MouseWheel); + const blink::WebMouseWheelEvent* mouse_wheel_event = + static_cast<const blink::WebMouseWheelEvent*>(web_event); DCHECK_EQ(mouse_wheel_event->deltaX, 0); scroll_distance_ += mouse_wheel_event->deltaY; } @@ -120,23 +120,23 @@ class MockSyntheticSmoothScrollTouchTarget : public MockSyntheticGestureTarget { virtual ~MockSyntheticSmoothScrollTouchTarget() {} virtual void QueueInputEventToPlatform(const InputEvent& event) OVERRIDE { - const WebKit::WebInputEvent* web_event = event.web_event.get(); - DCHECK(WebKit::WebInputEvent::isTouchEventType(web_event->type)); - const WebKit::WebTouchEvent* touch_event = - static_cast<const WebKit::WebTouchEvent*>(web_event); + const blink::WebInputEvent* web_event = event.web_event.get(); + DCHECK(blink::WebInputEvent::isTouchEventType(web_event->type)); + const blink::WebTouchEvent* touch_event = + static_cast<const blink::WebTouchEvent*>(web_event); DCHECK_EQ(touch_event->touchesLength, (unsigned int)1); if (!started_) { - DCHECK_EQ(touch_event->type, WebKit::WebInputEvent::TouchStart); + DCHECK_EQ(touch_event->type, blink::WebInputEvent::TouchStart); anchor_y_ = touch_event->touches[0].position.y; started_ = true; } else { - DCHECK_NE(touch_event->type, WebKit::WebInputEvent::TouchStart); - DCHECK_NE(touch_event->type, WebKit::WebInputEvent::TouchCancel); + DCHECK_NE(touch_event->type, blink::WebInputEvent::TouchStart); + DCHECK_NE(touch_event->type, blink::WebInputEvent::TouchCancel); // Ignore move events. - if (touch_event->type == WebKit::WebInputEvent::TouchEnd) + if (touch_event->type == blink::WebInputEvent::TouchEnd) scroll_distance_ = touch_event->touches[0].position.y - anchor_y_; } } diff --git a/content/browser/renderer_host/input/synthetic_smooth_scroll_gesture_new.cc b/content/browser/renderer_host/input/synthetic_smooth_scroll_gesture_new.cc index a508070..06d4ff3 100644 --- a/content/browser/renderer_host/input/synthetic_smooth_scroll_gesture_new.cc +++ b/content/browser/renderer_host/input/synthetic_smooth_scroll_gesture_new.cc @@ -97,7 +97,7 @@ void SyntheticSmoothScrollGestureNew::ForwardTouchEvent( void SyntheticSmoothScrollGestureNew::ForwardMouseWheelEvent( SyntheticGestureTarget* target, float delta) { - WebKit::WebMouseWheelEvent mouse_wheel_event = + blink::WebMouseWheelEvent mouse_wheel_event = SyntheticWebMouseWheelEventBuilder::Build(0, delta, 0, false); target->QueueInputEventToPlatform( diff --git a/content/browser/renderer_host/input/synthetic_web_input_event_builders.cc b/content/browser/renderer_host/input/synthetic_web_input_event_builders.cc index 634299d..d6f782d 100644 --- a/content/browser/renderer_host/input/synthetic_web_input_event_builders.cc +++ b/content/browser/renderer_host/input/synthetic_web_input_event_builders.cc @@ -10,23 +10,23 @@ namespace content { -using WebKit::WebInputEvent; -using WebKit::WebKeyboardEvent; -using WebKit::WebGestureEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebTouchEvent; -using WebKit::WebTouchPoint; +using blink::WebInputEvent; +using blink::WebKeyboardEvent; +using blink::WebGestureEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; +using blink::WebTouchEvent; +using blink::WebTouchPoint; WebMouseEvent SyntheticWebMouseEventBuilder::Build( - WebKit::WebInputEvent::Type type) { + blink::WebInputEvent::Type type) { WebMouseEvent result; result.type = type; return result; } WebMouseEvent SyntheticWebMouseEventBuilder::Build( - WebKit::WebInputEvent::Type type, + blink::WebInputEvent::Type type, int window_x, int window_y, int modifiers) { diff --git a/content/browser/renderer_host/input/synthetic_web_input_event_builders.h b/content/browser/renderer_host/input/synthetic_web_input_event_builders.h index 3b0d7a3..0139686 100644 --- a/content/browser/renderer_host/input/synthetic_web_input_event_builders.h +++ b/content/browser/renderer_host/input/synthetic_web_input_event_builders.h @@ -16,8 +16,8 @@ namespace content { class CONTENT_EXPORT SyntheticWebMouseEventBuilder { public: - static WebKit::WebMouseEvent Build(WebKit::WebInputEvent::Type type); - static WebKit::WebMouseEvent Build(WebKit::WebInputEvent::Type type, + static blink::WebMouseEvent Build(blink::WebInputEvent::Type type); + static blink::WebMouseEvent Build(blink::WebInputEvent::Type type, int window_x, int window_y, int modifiers); @@ -25,9 +25,9 @@ class CONTENT_EXPORT SyntheticWebMouseEventBuilder { class CONTENT_EXPORT SyntheticWebMouseWheelEventBuilder { public: - static WebKit::WebMouseWheelEvent Build( - WebKit::WebMouseWheelEvent::Phase phase); - static WebKit::WebMouseWheelEvent Build(float dx, + static blink::WebMouseWheelEvent Build( + blink::WebMouseWheelEvent::Phase phase); + static blink::WebMouseWheelEvent Build(float dx, float dy, int modifiers, bool precise); @@ -35,29 +35,29 @@ class CONTENT_EXPORT SyntheticWebMouseWheelEventBuilder { class CONTENT_EXPORT SyntheticWebKeyboardEventBuilder { public: - static NativeWebKeyboardEvent Build(WebKit::WebInputEvent::Type type); + static NativeWebKeyboardEvent Build(blink::WebInputEvent::Type type); }; class CONTENT_EXPORT SyntheticWebGestureEventBuilder { public: - static WebKit::WebGestureEvent Build( - WebKit::WebInputEvent::Type type, - WebKit::WebGestureEvent::SourceDevice sourceDevice); - static WebKit::WebGestureEvent BuildScrollUpdate(float dx, + static blink::WebGestureEvent Build( + blink::WebInputEvent::Type type, + blink::WebGestureEvent::SourceDevice sourceDevice); + static blink::WebGestureEvent BuildScrollUpdate(float dx, float dY, int modifiers); - static WebKit::WebGestureEvent BuildPinchUpdate(float scale, + static blink::WebGestureEvent BuildPinchUpdate(float scale, float anchor_x, float anchor_y, int modifiers); - static WebKit::WebGestureEvent BuildFling( + static blink::WebGestureEvent BuildFling( float velocity_x, float velocity_y, - WebKit::WebGestureEvent::SourceDevice source_device); + blink::WebGestureEvent::SourceDevice source_device); }; class CONTENT_EXPORT SyntheticWebTouchEvent - : public NON_EXPORTED_BASE(WebKit::WebTouchEvent) { + : public NON_EXPORTED_BASE(blink::WebTouchEvent) { public: SyntheticWebTouchEvent(); @@ -74,7 +74,7 @@ class CONTENT_EXPORT SyntheticWebTouchEvent class CONTENT_EXPORT SyntheticWebTouchEventBuilder { public: - static SyntheticWebTouchEvent Build(WebKit::WebInputEvent::Type type); + static SyntheticWebTouchEvent Build(blink::WebInputEvent::Type type); }; } // namespace content diff --git a/content/browser/renderer_host/input/touch_event_queue.cc b/content/browser/renderer_host/input/touch_event_queue.cc index 3371790..ecc12056 100644 --- a/content/browser/renderer_host/input/touch_event_queue.cc +++ b/content/browser/renderer_host/input/touch_event_queue.cc @@ -120,21 +120,21 @@ void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result, return; // Update the ACK status for each touch point in the ACKed event. - const WebKit::WebTouchEvent& event = + const blink::WebTouchEvent& event = touch_queue_.front()->coalesced_event().event; - if (event.type == WebKit::WebInputEvent::TouchEnd || - event.type == WebKit::WebInputEvent::TouchCancel) { + if (event.type == blink::WebInputEvent::TouchEnd || + event.type == blink::WebInputEvent::TouchCancel) { // The points have been released. Erase the ACK states. for (unsigned i = 0; i < event.touchesLength; ++i) { - const WebKit::WebTouchPoint& point = event.touches[i]; - if (point.state == WebKit::WebTouchPoint::StateReleased || - point.state == WebKit::WebTouchPoint::StateCancelled) + const blink::WebTouchPoint& point = event.touches[i]; + if (point.state == blink::WebTouchPoint::StateReleased || + point.state == blink::WebTouchPoint::StateCancelled) touch_ack_states_.erase(point.id); } - } else if (event.type == WebKit::WebInputEvent::TouchStart) { + } else if (event.type == blink::WebInputEvent::TouchStart) { for (unsigned i = 0; i < event.touchesLength; ++i) { - const WebKit::WebTouchPoint& point = event.touches[i]; - if (point.state == WebKit::WebTouchPoint::StatePressed) + const blink::WebTouchPoint& point = event.touches[i]; + if (point.state == blink::WebTouchPoint::StatePressed) touch_ack_states_[point.id] = ack_result; } } @@ -161,8 +161,8 @@ void TouchEventQueue::TryForwardNextEventToRenderer() { void TouchEventQueue::OnGestureScrollEvent( const GestureEventWithLatencyInfo& gesture_event) { - WebKit::WebInputEvent::Type type = gesture_event.event.type; - if (type == WebKit::WebInputEvent::GestureScrollBegin) { + blink::WebInputEvent::Type type = gesture_event.event.type; + if (type == blink::WebInputEvent::GestureScrollBegin) { // We assume the scroll event are generated synchronously from // dispatching a touch event ack, so that we can fake a cancel // event that has the correct touch ids as the touch event that @@ -174,10 +174,10 @@ void TouchEventQueue::OnGestureScrollEvent( // that is currently being acked. TouchEventWithLatencyInfo cancel_event = dispatching_touch_ack_->coalesced_event(); - cancel_event.event.type = WebKit::WebInputEvent::TouchCancel; + cancel_event.event.type = blink::WebInputEvent::TouchCancel; for (size_t i = 0; i < cancel_event.event.touchesLength; i++) cancel_event.event.touches[i].state = - WebKit::WebTouchPoint::StateCancelled; + blink::WebTouchPoint::StateCancelled; CoalescedWebTouchEvent* coalesced_cancel_event = new CoalescedWebTouchEvent(cancel_event); // Ignore the ack of the touch cancel so when it is acked, it won't get @@ -188,8 +188,8 @@ void TouchEventQueue::OnGestureScrollEvent( // in the queue is waiting for ack from renderer. So we can just insert // the touch cancel at the beginning of the queue. touch_queue_.push_front(coalesced_cancel_event); - } else if (type == WebKit::WebInputEvent::GestureScrollEnd || - type == WebKit::WebInputEvent::GestureFlingStart) { + } else if (type == blink::WebInputEvent::GestureScrollEnd || + type == blink::WebInputEvent::GestureFlingStart) { no_touch_to_renderer_ = false; } } @@ -234,19 +234,19 @@ void TouchEventQueue::PopTouchEventToClient( } bool TouchEventQueue::ShouldForwardToRenderer( - const WebKit::WebTouchEvent& event) const { + const blink::WebTouchEvent& event) const { if (no_touch_to_renderer_ && - event.type != WebKit::WebInputEvent::TouchCancel) + event.type != blink::WebInputEvent::TouchCancel) return false; // Touch press events should always be forwarded to the renderer. - if (event.type == WebKit::WebInputEvent::TouchStart) + if (event.type == blink::WebInputEvent::TouchStart) return true; for (unsigned int i = 0; i < event.touchesLength; ++i) { - const WebKit::WebTouchPoint& point = event.touches[i]; + const blink::WebTouchPoint& point = event.touches[i]; // If a point has been stationary, then don't take it into account. - if (point.state == WebKit::WebTouchPoint::StateStationary) + if (point.state == blink::WebTouchPoint::StateStationary) continue; if (touch_ack_states_.count(point.id) > 0) { diff --git a/content/browser/renderer_host/input/touch_event_queue.h b/content/browser/renderer_host/input/touch_event_queue.h index 0382288..a3053c4 100644 --- a/content/browser/renderer_host/input/touch_event_queue.h +++ b/content/browser/renderer_host/input/touch_event_queue.h @@ -87,7 +87,7 @@ class CONTENT_EXPORT TouchEventQueue { void PopTouchEventToClient(InputEventAckState ack_result, const ui::LatencyInfo& renderer_latency_info); - bool ShouldForwardToRenderer(const WebKit::WebTouchEvent& event) const; + bool ShouldForwardToRenderer(const blink::WebTouchEvent& event) const; // Handles touch event forwarding and ack'ed event dispatch. TouchEventQueueClient* client_; diff --git a/content/browser/renderer_host/input/touch_event_queue_unittest.cc b/content/browser/renderer_host/input/touch_event_queue_unittest.cc index 61f51fe..c57cbbe 100644 --- a/content/browser/renderer_host/input/touch_event_queue_unittest.cc +++ b/content/browser/renderer_host/input/touch_event_queue_unittest.cc @@ -10,10 +10,10 @@ #include "testing/gtest/include/gtest/gtest.h" #include "third_party/WebKit/public/web/WebInputEvent.h" -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebTouchEvent; -using WebKit::WebTouchPoint; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebTouchEvent; +using blink::WebTouchPoint; namespace content { @@ -757,7 +757,7 @@ TEST_F(TouchEventQueueTest, NoTouchOnScroll) { EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state()); // GestureScrollEnd will resume the sending of TouchEvents to renderer. - SendGestureEvent(WebKit::WebInputEvent::GestureScrollEnd); + SendGestureEvent(blink::WebInputEvent::GestureScrollEnd); EXPECT_FALSE(no_touch_to_renderer()); // Now TouchEvents should be forwarded normally. diff --git a/content/browser/renderer_host/input/web_input_event_builders_android.cc b/content/browser/renderer_host/input/web_input_event_builders_android.cc index b5c96c6..43e9bb8 100644 --- a/content/browser/renderer_host/input/web_input_event_builders_android.cc +++ b/content/browser/renderer_host/input/web_input_event_builders_android.cc @@ -12,11 +12,11 @@ namespace content { -using WebKit::WebInputEvent; -using WebKit::WebKeyboardEvent; -using WebKit::WebGestureEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; +using blink::WebInputEvent; +using blink::WebKeyboardEvent; +using blink::WebGestureEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; WebKeyboardEvent WebKeyboardEventBuilder::Build(WebInputEvent::Type type, int modifiers, @@ -48,7 +48,7 @@ WebKeyboardEvent WebKeyboardEventBuilder::Build(WebInputEvent::Type type, return result; } -WebMouseEvent WebMouseEventBuilder::Build(WebKit::WebInputEvent::Type type, +WebMouseEvent WebMouseEventBuilder::Build(blink::WebInputEvent::Type type, WebMouseEvent::Button button, double time_sec, int window_x, diff --git a/content/browser/renderer_host/input/web_input_event_builders_android.h b/content/browser/renderer_host/input/web_input_event_builders_android.h index 4488375..1059572 100644 --- a/content/browser/renderer_host/input/web_input_event_builders_android.h +++ b/content/browser/renderer_host/input/web_input_event_builders_android.h @@ -11,8 +11,8 @@ namespace content { class WebMouseEventBuilder { public: - static WebKit::WebMouseEvent Build(WebKit::WebInputEvent::Type type, - WebKit::WebMouseEvent::Button button, + static blink::WebMouseEvent Build(blink::WebInputEvent::Type type, + blink::WebMouseEvent::Button button, double time_sec, int window_x, int window_y, @@ -29,7 +29,7 @@ class WebMouseWheelEventBuilder { DIRECTION_RIGHT, }; - static WebKit::WebMouseWheelEvent Build(Direction direction, + static blink::WebMouseWheelEvent Build(Direction direction, double time_sec, int window_x, int window_y); @@ -37,7 +37,7 @@ class WebMouseWheelEventBuilder { class WebKeyboardEventBuilder { public: - static WebKit::WebKeyboardEvent Build(WebKit::WebInputEvent::Type type, + static blink::WebKeyboardEvent Build(blink::WebInputEvent::Type type, int modifiers, double time_sec, int keycode, @@ -47,7 +47,7 @@ class WebKeyboardEventBuilder { class WebGestureEventBuilder { public: - static WebKit::WebGestureEvent Build(WebKit::WebInputEvent::Type type, + static blink::WebGestureEvent Build(blink::WebInputEvent::Type type, double time_sec, int x, int y); diff --git a/content/browser/renderer_host/input/web_input_event_builders_gtk.cc b/content/browser/renderer_host/input/web_input_event_builders_gtk.cc index c101595..d5c2bde 100644 --- a/content/browser/renderer_host/input/web_input_event_builders_gtk.cc +++ b/content/browser/renderer_host/input/web_input_event_builders_gtk.cc @@ -13,10 +13,10 @@ #include "third_party/WebKit/public/web/WebInputEvent.h" #include "ui/events/keycodes/keyboard_code_conversion_gtk.h" -using WebKit::WebInputEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebKeyboardEvent; +using blink::WebInputEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; +using blink::WebKeyboardEvent; namespace { @@ -53,7 +53,7 @@ void ResetClickCountState() { last_click_time = 0; last_click_x = 0; last_click_y = 0; - last_click_button = WebKit::WebMouseEvent::ButtonNone; + last_click_button = blink::WebMouseEvent::ButtonNone; } bool IsKeyPadKeyval(guint keyval) { @@ -395,7 +395,7 @@ WebKeyboardEvent WebKeyboardEventBuilder::Build(wchar_t character, // function creates a WebInputEvent::Char event without using a // GdkEventKey object. WebKeyboardEvent result; - result.type = WebKit::WebInputEvent::Char; + result.type = blink::WebInputEvent::Char; result.timeStampSeconds = timeStampSeconds; result.modifiers = GdkStateToWebEventModifiers(state); result.windowsKeyCode = character; diff --git a/content/browser/renderer_host/input/web_input_event_builders_gtk.h b/content/browser/renderer_host/input/web_input_event_builders_gtk.h index 6fe1642..0d0250b 100644 --- a/content/browser/renderer_host/input/web_input_event_builders_gtk.h +++ b/content/browser/renderer_host/input/web_input_event_builders_gtk.h @@ -19,23 +19,23 @@ namespace content { class CONTENT_EXPORT WebKeyboardEventBuilder { public: - static WebKit::WebKeyboardEvent Build(const GdkEventKey* event); - static WebKit::WebKeyboardEvent Build(wchar_t character, + static blink::WebKeyboardEvent Build(const GdkEventKey* event); + static blink::WebKeyboardEvent Build(wchar_t character, int state, double time_secs); }; class CONTENT_EXPORT WebMouseEventBuilder { public: - static WebKit::WebMouseEvent Build(const GdkEventButton* event); - static WebKit::WebMouseEvent Build(const GdkEventMotion* event); - static WebKit::WebMouseEvent Build(const GdkEventCrossing* event); + static blink::WebMouseEvent Build(const GdkEventButton* event); + static blink::WebMouseEvent Build(const GdkEventMotion* event); + static blink::WebMouseEvent Build(const GdkEventCrossing* event); }; class CONTENT_EXPORT WebMouseWheelEventBuilder { public: static float ScrollbarPixelsPerTick(); - static WebKit::WebMouseWheelEvent Build( + static blink::WebMouseWheelEvent Build( const GdkEventScroll* event); }; diff --git a/content/browser/renderer_host/input/web_input_event_builders_gtk_unittest.cc b/content/browser/renderer_host/input/web_input_event_builders_gtk_unittest.cc index 9498c9e..b5e2d42 100644 --- a/content/browser/renderer_host/input/web_input_event_builders_gtk_unittest.cc +++ b/content/browser/renderer_host/input/web_input_event_builders_gtk_unittest.cc @@ -11,9 +11,9 @@ #include "third_party/WebKit/public/web/WebInputEvent.h" #include "ui/events/keycodes/keyboard_code_conversion_gtk.h" -using WebKit::WebInputEvent; -using WebKit::WebKeyboardEvent; -using WebKit::WebMouseEvent; +using blink::WebInputEvent; +using blink::WebKeyboardEvent; +using blink::WebMouseEvent; using content::WebMouseEventBuilder; using content::WebKeyboardEventBuilder; diff --git a/content/browser/renderer_host/input/web_input_event_builders_win.cc b/content/browser/renderer_host/input/web_input_event_builders_win.cc index ba081fd..8c63e44 100644 --- a/content/browser/renderer_host/input/web_input_event_builders_win.cc +++ b/content/browser/renderer_host/input/web_input_event_builders_win.cc @@ -7,10 +7,10 @@ #include "base/logging.h" #include "content/browser/renderer_host/input/web_input_event_util.h" -using WebKit::WebInputEvent; -using WebKit::WebKeyboardEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; +using blink::WebInputEvent; +using blink::WebKeyboardEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; namespace content { diff --git a/content/browser/renderer_host/input/web_input_event_builders_win.h b/content/browser/renderer_host/input/web_input_event_builders_win.h index f01cd29..d3ec4a7 100644 --- a/content/browser/renderer_host/input/web_input_event_builders_win.h +++ b/content/browser/renderer_host/input/web_input_event_builders_win.h @@ -13,19 +13,19 @@ namespace content { class WebKeyboardEventBuilder { public: - static WebKit::WebKeyboardEvent Build(HWND hwnd, UINT message, + static blink::WebKeyboardEvent Build(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam); }; class WebMouseEventBuilder { public: - static WebKit::WebMouseEvent Build(HWND hwnd, UINT message, + static blink::WebMouseEvent Build(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam); }; class WebMouseWheelEventBuilder { public: - static WebKit::WebMouseWheelEvent Build(HWND hwnd, UINT message, + static blink::WebMouseWheelEvent Build(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam); }; diff --git a/content/browser/renderer_host/input/web_input_event_util.cc b/content/browser/renderer_host/input/web_input_event_util.cc index e3c2899..804c0b1 100644 --- a/content/browser/renderer_host/input/web_input_event_util.cc +++ b/content/browser/renderer_host/input/web_input_event_util.cc @@ -129,7 +129,7 @@ const char* GetKeyIdentifier(ui::KeyboardCode key_code) { namespace content { -void UpdateWindowsKeyCodeAndKeyIdentifier(WebKit::WebKeyboardEvent* event, +void UpdateWindowsKeyCodeAndKeyIdentifier(blink::WebKeyboardEvent* event, ui::KeyboardCode windows_key_code) { event->windowsKeyCode = windows_key_code; diff --git a/content/browser/renderer_host/input/web_input_event_util.h b/content/browser/renderer_host/input/web_input_event_util.h index 1abaf8c..f0680f2 100644 --- a/content/browser/renderer_host/input/web_input_event_util.h +++ b/content/browser/renderer_host/input/web_input_event_util.h @@ -8,7 +8,7 @@ #include "content/common/content_export.h" #include "ui/events/keycodes/keyboard_codes.h" -namespace WebKit { +namespace blink { class WebKeyboardEvent; } @@ -17,7 +17,7 @@ namespace content { // Update |event|'s windowsKeyCode and keyIdentifer properties using the // provided |windows_key_code|. CONTENT_EXPORT void UpdateWindowsKeyCodeAndKeyIdentifier( - WebKit::WebKeyboardEvent* event, + blink::WebKeyboardEvent* event, ui::KeyboardCode windows_key_code); } diff --git a/content/browser/renderer_host/input/web_input_event_util_posix.cc b/content/browser/renderer_host/input/web_input_event_util_posix.cc index 72786c8..7ae2242 100644 --- a/content/browser/renderer_host/input/web_input_event_util_posix.cc +++ b/content/browser/renderer_host/input/web_input_event_util_posix.cc @@ -22,21 +22,21 @@ ui::KeyboardCode GetWindowsKeyCodeWithoutLocation(ui::KeyboardCode key_code) { } } -WebKit::WebInputEvent::Modifiers GetLocationModifiersFromWindowsKeyCode( +blink::WebInputEvent::Modifiers GetLocationModifiersFromWindowsKeyCode( ui::KeyboardCode key_code) { switch (key_code) { case ui::VKEY_LCONTROL: case ui::VKEY_LSHIFT: case ui::VKEY_LMENU: case ui::VKEY_LWIN: - return WebKit::WebKeyboardEvent::IsLeft; + return blink::WebKeyboardEvent::IsLeft; case ui::VKEY_RCONTROL: case ui::VKEY_RSHIFT: case ui::VKEY_RMENU: case ui::VKEY_RWIN: - return WebKit::WebKeyboardEvent::IsRight; + return blink::WebKeyboardEvent::IsRight; default: - return static_cast<WebKit::WebInputEvent::Modifiers>(0); + return static_cast<blink::WebInputEvent::Modifiers>(0); } } diff --git a/content/browser/renderer_host/input/web_input_event_util_posix.h b/content/browser/renderer_host/input/web_input_event_util_posix.h index e7dc154..9f2f4c0 100644 --- a/content/browser/renderer_host/input/web_input_event_util_posix.h +++ b/content/browser/renderer_host/input/web_input_event_util_posix.h @@ -11,7 +11,7 @@ namespace content { ui::KeyboardCode GetWindowsKeyCodeWithoutLocation(ui::KeyboardCode key_code); -WebKit::WebInputEvent::Modifiers GetLocationModifiersFromWindowsKeyCode( +blink::WebInputEvent::Modifiers GetLocationModifiersFromWindowsKeyCode( ui::KeyboardCode key_code); } // namespace content diff --git a/content/browser/renderer_host/java/java_bound_object.cc b/content/browser/renderer_host/java/java_bound_object.cc index 27b9f42..e2ad87a 100644 --- a/content/browser/renderer_host/java/java_bound_object.cc +++ b/content/browser/renderer_host/java/java_bound_object.cc @@ -22,7 +22,7 @@ using base::android::GetClass; using base::android::JavaRef; using base::android::ScopedJavaGlobalRef; using base::android::ScopedJavaLocalRef; -using WebKit::WebBindings; +using blink::WebBindings; // The conversion between JavaScript and Java types is based on the Live // Connect 2 spec. See diff --git a/content/browser/renderer_host/java/java_bridge_dispatcher_host.cc b/content/browser/renderer_host/java/java_bridge_dispatcher_host.cc index ece3056..6d792e7 100644 --- a/content/browser/renderer_host/java/java_bridge_dispatcher_host.cc +++ b/content/browser/renderer_host/java/java_bridge_dispatcher_host.cc @@ -128,7 +128,7 @@ void JavaBridgeDispatcherHost::CreateNPVariantParam(NPObject* object, int route_id = JavaBridgeChannelHost::ThreadsafeGenerateRouteID(); param->npobject_routing_id = route_id; - WebKit::WebBindings::retainObject(object); + blink::WebBindings::retainObject(object); g_background_thread.Get().message_loop()->PostTask( FROM_HERE, base::Bind(&JavaBridgeDispatcherHost::CreateObjectStub, this, object, @@ -161,7 +161,7 @@ void JavaBridgeDispatcherHost::CreateObjectStub(NPObject* object, // The NPObjectStub takes a reference to the NPObject. Release the ref added // in CreateNPVariantParam(). - WebKit::WebBindings::releaseObject(object); + blink::WebBindings::releaseObject(object); } } // namespace content diff --git a/content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.cc b/content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.cc index a3822a0..f06d9fe 100644 --- a/content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.cc +++ b/content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.cc @@ -26,7 +26,7 @@ JavaBridgeDispatcherHostManager::JavaBridgeDispatcherHostManager( JavaBridgeDispatcherHostManager::~JavaBridgeDispatcherHostManager() { for (ObjectMap::iterator iter = objects_.begin(); iter != objects_.end(); ++iter) { - WebKit::WebBindings::releaseObject(iter->second); + blink::WebBindings::releaseObject(iter->second); } DCHECK_EQ(0U, instances_.size()); } @@ -37,7 +37,7 @@ void JavaBridgeDispatcherHostManager::AddNamedObject(const string16& name, // created later. The JavaBridgeDispatcherHost instances will take a // reference to the object, but we take one too, because this method can be // called before there are any such instances. - WebKit::WebBindings::retainObject(object); + blink::WebBindings::retainObject(object); objects_[name] = object; for (InstanceMap::iterator iter = instances_.begin(); @@ -73,7 +73,7 @@ void JavaBridgeDispatcherHostManager::RemoveNamedObject(const string16& name) { return; } - WebKit::WebBindings::releaseObject(iter->second); + blink::WebBindings::releaseObject(iter->second); objects_.erase(iter); for (InstanceMap::iterator iter = instances_.begin(); diff --git a/content/browser/renderer_host/native_web_keyboard_event_android.cc b/content/browser/renderer_host/native_web_keyboard_event_android.cc index ad5f1f1..d202918 100644 --- a/content/browser/renderer_host/native_web_keyboard_event_android.cc +++ b/content/browser/renderer_host/native_web_keyboard_event_android.cc @@ -30,7 +30,7 @@ NativeWebKeyboardEvent::NativeWebKeyboardEvent() } NativeWebKeyboardEvent::NativeWebKeyboardEvent( - WebKit::WebInputEvent::Type type, + blink::WebInputEvent::Type type, int modifiers, double time_secs, int keycode, int unicode_character, bool is_system_key) : WebKeyboardEvent(WebKeyboardEventBuilder::Build( @@ -41,7 +41,7 @@ NativeWebKeyboardEvent::NativeWebKeyboardEvent( } NativeWebKeyboardEvent::NativeWebKeyboardEvent( - jobject android_key_event, WebKit::WebInputEvent::Type type, + jobject android_key_event, blink::WebInputEvent::Type type, int modifiers, double time_secs, int keycode, int unicode_character, bool is_system_key) : WebKeyboardEvent(WebKeyboardEventBuilder::Build( diff --git a/content/browser/renderer_host/native_web_keyboard_event_aura.cc b/content/browser/renderer_host/native_web_keyboard_event_aura.cc index ad3aae3..1587bba 100644 --- a/content/browser/renderer_host/native_web_keyboard_event_aura.cc +++ b/content/browser/renderer_host/native_web_keyboard_event_aura.cc @@ -20,15 +20,15 @@ ui::Event* CopyEvent(ui::Event* event) { int EventFlagsToWebInputEventModifiers(int flags) { return - (flags & ui::EF_SHIFT_DOWN ? WebKit::WebInputEvent::ShiftKey : 0) | - (flags & ui::EF_CONTROL_DOWN ? WebKit::WebInputEvent::ControlKey : 0) | - (flags & ui::EF_CAPS_LOCK_DOWN ? WebKit::WebInputEvent::CapsLockOn : 0) | - (flags & ui::EF_ALT_DOWN ? WebKit::WebInputEvent::AltKey : 0); + (flags & ui::EF_SHIFT_DOWN ? blink::WebInputEvent::ShiftKey : 0) | + (flags & ui::EF_CONTROL_DOWN ? blink::WebInputEvent::ControlKey : 0) | + (flags & ui::EF_CAPS_LOCK_DOWN ? blink::WebInputEvent::CapsLockOn : 0) | + (flags & ui::EF_ALT_DOWN ? blink::WebInputEvent::AltKey : 0); } } // namespace -using WebKit::WebKeyboardEvent; +using blink::WebKeyboardEvent; namespace content { @@ -61,11 +61,11 @@ NativeWebKeyboardEvent::NativeWebKeyboardEvent( skip_in_browser(false) { switch (key_event_type) { case ui::ET_KEY_PRESSED: - type = is_char ? WebKit::WebInputEvent::Char : - WebKit::WebInputEvent::RawKeyDown; + type = is_char ? blink::WebInputEvent::Char : + blink::WebInputEvent::RawKeyDown; break; case ui::ET_KEY_RELEASED: - type = WebKit::WebInputEvent::KeyUp; + type = blink::WebInputEvent::KeyUp; break; default: NOTREACHED(); diff --git a/content/browser/renderer_host/native_web_keyboard_event_mac.mm b/content/browser/renderer_host/native_web_keyboard_event_mac.mm index 5b4f38c..fea2939 100644 --- a/content/browser/renderer_host/native_web_keyboard_event_mac.mm +++ b/content/browser/renderer_host/native_web_keyboard_event_mac.mm @@ -8,7 +8,7 @@ #include "third_party/WebKit/public/web/mac/WebInputEventFactory.h" -using WebKit::WebInputEventFactory; +using blink::WebInputEventFactory; namespace content { diff --git a/content/browser/renderer_host/native_web_keyboard_event_win.cc b/content/browser/renderer_host/native_web_keyboard_event_win.cc index 42d3cce..0f54a89 100644 --- a/content/browser/renderer_host/native_web_keyboard_event_win.cc +++ b/content/browser/renderer_host/native_web_keyboard_event_win.cc @@ -6,7 +6,7 @@ #include "content/browser/renderer_host/input/web_input_event_builders_win.h" -using WebKit::WebKeyboardEvent; +using blink::WebKeyboardEvent; namespace content { diff --git a/content/browser/renderer_host/overscroll_controller.cc b/content/browser/renderer_host/overscroll_controller.cc index 052eedb..4c33aa8 100644 --- a/content/browser/renderer_host/overscroll_controller.cc +++ b/content/browser/renderer_host/overscroll_controller.cc @@ -10,7 +10,7 @@ #include "content/public/browser/overscroll_configuration.h" #include "content/public/common/content_switches.h" -using WebKit::WebInputEvent; +using blink::WebInputEvent; namespace { @@ -35,29 +35,29 @@ OverscrollController::~OverscrollController() { } OverscrollController::Disposition OverscrollController::DispatchEvent( - const WebKit::WebInputEvent& event, + const blink::WebInputEvent& event, const ui::LatencyInfo& latency_info) { if (scroll_state_ != STATE_UNKNOWN) { switch (event.type) { - case WebKit::WebInputEvent::GestureScrollEnd: - case WebKit::WebInputEvent::GestureFlingStart: + case blink::WebInputEvent::GestureScrollEnd: + case blink::WebInputEvent::GestureFlingStart: scroll_state_ = STATE_UNKNOWN; break; - case WebKit::WebInputEvent::MouseWheel: { - const WebKit::WebMouseWheelEvent& wheel = - static_cast<const WebKit::WebMouseWheelEvent&>(event); + case blink::WebInputEvent::MouseWheel: { + const blink::WebMouseWheelEvent& wheel = + static_cast<const blink::WebMouseWheelEvent&>(event); if (!wheel.hasPreciseScrollingDeltas || - wheel.phase == WebKit::WebMouseWheelEvent::PhaseEnded || - wheel.phase == WebKit::WebMouseWheelEvent::PhaseCancelled) { + wheel.phase == blink::WebMouseWheelEvent::PhaseEnded || + wheel.phase == blink::WebMouseWheelEvent::PhaseCancelled) { scroll_state_ = STATE_UNKNOWN; } break; } default: - if (WebKit::WebInputEvent::isMouseEventType(event.type) || - WebKit::WebInputEvent::isKeyboardEventType(event.type)) { + if (blink::WebInputEvent::isMouseEventType(event.type) || + blink::WebInputEvent::isKeyboardEventType(event.type)) { scroll_state_ = STATE_UNKNOWN; } break; @@ -72,7 +72,7 @@ OverscrollController::Disposition OverscrollController::DispatchEvent( // touch-scrolls maintain state in the renderer side (in the compositor, for // example), and the event that completes this action needs to be sent to // the renderer so that those states can be updated/reset appropriately. - if (WebKit::WebInputEvent::isGestureEventType(event.type)) { + if (blink::WebInputEvent::isGestureEventType(event.type)) { // A gesture-event isn't sent to the GestureEventFilter when overscroll is // in progress. So dispatch the event through the RenderWidgetHost so that // it can reach the GestureEventFilter. @@ -84,7 +84,7 @@ OverscrollController::Disposition OverscrollController::DispatchEvent( if (overscroll_mode_ != OVERSCROLL_NONE && DispatchEventResetsState(event)) { SetOverscrollMode(OVERSCROLL_NONE); - if (WebKit::WebInputEvent::isGestureEventType(event.type)) { + if (blink::WebInputEvent::isGestureEventType(event.type)) { // A gesture-event isn't sent to the GestureEventFilter when overscroll is // in progress. So dispatch the event through the RenderWidgetHost so that // it can reach the GestureEventFilter. @@ -104,15 +104,15 @@ OverscrollController::Disposition OverscrollController::DispatchEvent( return SHOULD_FORWARD_TO_RENDERER; } -void OverscrollController::ReceivedEventACK(const WebKit::WebInputEvent& event, +void OverscrollController::ReceivedEventACK(const blink::WebInputEvent& event, bool processed) { if (processed) { // If a scroll event is consumed by the page, i.e. some content on the page // has been scrolled, then there is not going to be an overscroll gesture, // until the current scroll ends, and a new scroll gesture starts. if (scroll_state_ == STATE_UNKNOWN && - (event.type == WebKit::WebInputEvent::MouseWheel || - event.type == WebKit::WebInputEvent::GestureScrollUpdate)) { + (event.type == blink::WebInputEvent::MouseWheel || + event.type == blink::WebInputEvent::GestureScrollUpdate)) { scroll_state_ = STATE_CONTENT_SCROLLING; } return; @@ -121,10 +121,10 @@ void OverscrollController::ReceivedEventACK(const WebKit::WebInputEvent& event, } void OverscrollController::DiscardingGestureEvent( - const WebKit::WebGestureEvent& gesture) { + const blink::WebGestureEvent& gesture) { if (scroll_state_ != STATE_UNKNOWN && - (gesture.type == WebKit::WebInputEvent::GestureScrollEnd || - gesture.type == WebKit::WebInputEvent::GestureFlingStart)) { + (gesture.type == blink::WebInputEvent::GestureScrollEnd || + gesture.type == blink::WebInputEvent::GestureFlingStart)) { scroll_state_ = STATE_UNKNOWN; } } @@ -142,15 +142,15 @@ void OverscrollController::Cancel() { } bool OverscrollController::DispatchEventCompletesAction ( - const WebKit::WebInputEvent& event) const { + const blink::WebInputEvent& event) const { if (overscroll_mode_ == OVERSCROLL_NONE) return false; // Complete the overscroll gesture if there was a mouse move or a scroll-end // after the threshold. - if (event.type != WebKit::WebInputEvent::MouseMove && - event.type != WebKit::WebInputEvent::GestureScrollEnd && - event.type != WebKit::WebInputEvent::GestureFlingStart) + if (event.type != blink::WebInputEvent::MouseMove && + event.type != blink::WebInputEvent::GestureScrollEnd && + event.type != blink::WebInputEvent::GestureFlingStart) return false; if (!delegate_) @@ -160,10 +160,10 @@ bool OverscrollController::DispatchEventCompletesAction ( if (bounds.IsEmpty()) return false; - if (event.type == WebKit::WebInputEvent::GestureFlingStart) { + if (event.type == blink::WebInputEvent::GestureFlingStart) { // Check to see if the fling is in the same direction of the overscroll. - const WebKit::WebGestureEvent gesture = - static_cast<const WebKit::WebGestureEvent&>(event); + const blink::WebGestureEvent gesture = + static_cast<const blink::WebGestureEvent&>(event); switch (overscroll_mode_) { case OVERSCROLL_EAST: if (gesture.data.flingStart.velocityX < 0) @@ -201,34 +201,34 @@ bool OverscrollController::DispatchEventCompletesAction ( } bool OverscrollController::DispatchEventResetsState( - const WebKit::WebInputEvent& event) const { + const blink::WebInputEvent& event) const { switch (event.type) { - case WebKit::WebInputEvent::MouseWheel: { + case blink::WebInputEvent::MouseWheel: { // Only wheel events with precise deltas (i.e. from trackpad) contribute // to the overscroll gesture. - const WebKit::WebMouseWheelEvent& wheel = - static_cast<const WebKit::WebMouseWheelEvent&>(event); + const blink::WebMouseWheelEvent& wheel = + static_cast<const blink::WebMouseWheelEvent&>(event); return !wheel.hasPreciseScrollingDeltas; } - case WebKit::WebInputEvent::GestureScrollUpdate: - case WebKit::WebInputEvent::GestureFlingCancel: + case blink::WebInputEvent::GestureScrollUpdate: + case blink::WebInputEvent::GestureFlingCancel: return false; default: // Touch events can arrive during an overscroll gesture initiated by // touch-scrolling. These events should not reset the overscroll state. - return !WebKit::WebInputEvent::isTouchEventType(event.type); + return !blink::WebInputEvent::isTouchEventType(event.type); } } bool OverscrollController::ProcessEventForOverscroll( - const WebKit::WebInputEvent& event) { + const blink::WebInputEvent& event) { bool event_processed = false; switch (event.type) { - case WebKit::WebInputEvent::MouseWheel: { - const WebKit::WebMouseWheelEvent& wheel = - static_cast<const WebKit::WebMouseWheelEvent&>(event); + case blink::WebInputEvent::MouseWheel: { + const blink::WebMouseWheelEvent& wheel = + static_cast<const blink::WebMouseWheelEvent&>(event); if (!wheel.hasPreciseScrollingDeltas) break; @@ -238,19 +238,19 @@ bool OverscrollController::ProcessEventForOverscroll( event_processed = true; break; } - case WebKit::WebInputEvent::GestureScrollUpdate: { - const WebKit::WebGestureEvent& gesture = - static_cast<const WebKit::WebGestureEvent&>(event); + case blink::WebInputEvent::GestureScrollUpdate: { + const blink::WebGestureEvent& gesture = + static_cast<const blink::WebGestureEvent&>(event); ProcessOverscroll(gesture.data.scrollUpdate.deltaX, gesture.data.scrollUpdate.deltaY, gesture.type); event_processed = true; break; } - case WebKit::WebInputEvent::GestureFlingStart: { + case blink::WebInputEvent::GestureFlingStart: { const float kFlingVelocityThreshold = 1100.f; - const WebKit::WebGestureEvent& gesture = - static_cast<const WebKit::WebGestureEvent&>(event); + const blink::WebGestureEvent& gesture = + static_cast<const blink::WebGestureEvent&>(event); float velocity_x = gesture.data.flingStart.velocityX; float velocity_y = gesture.data.flingStart.velocityY; if (fabs(velocity_x) > kFlingVelocityThreshold) { @@ -275,8 +275,8 @@ bool OverscrollController::ProcessEventForOverscroll( } default: - DCHECK(WebKit::WebInputEvent::isGestureEventType(event.type) || - WebKit::WebInputEvent::isTouchEventType(event.type)) + DCHECK(blink::WebInputEvent::isGestureEventType(event.type) || + blink::WebInputEvent::isTouchEventType(event.type)) << "Received unexpected event: " << event.type; } return event_processed; @@ -284,7 +284,7 @@ bool OverscrollController::ProcessEventForOverscroll( void OverscrollController::ProcessOverscroll(float delta_x, float delta_y, - WebKit::WebInputEvent::Type type) { + blink::WebInputEvent::Type type) { if (scroll_state_ != STATE_CONTENT_SCROLLING) overscroll_delta_x_ += delta_x; overscroll_delta_y_ += delta_y; diff --git a/content/browser/renderer_host/overscroll_controller.h b/content/browser/renderer_host/overscroll_controller.h index 8586c8a..c68eb9b 100644 --- a/content/browser/renderer_host/overscroll_controller.h +++ b/content/browser/renderer_host/overscroll_controller.h @@ -48,16 +48,16 @@ class OverscrollController { // This must be called when dispatching any event from the // RenderWidgetHostView so that the state of the overscroll gesture can be // updated properly. - Disposition DispatchEvent(const WebKit::WebInputEvent& event, + Disposition DispatchEvent(const blink::WebInputEvent& event, const ui::LatencyInfo& latency_info); // This must be called when the ACK for any event comes in. This updates the // overscroll gesture status as appropriate. - void ReceivedEventACK(const WebKit::WebInputEvent& event, bool processed); + void ReceivedEventACK(const blink::WebInputEvent& event, bool processed); // This must be called when a gesture event is filtered out and not sent to // the renderer. - void DiscardingGestureEvent(const WebKit::WebGestureEvent& event); + void DiscardingGestureEvent(const blink::WebGestureEvent& event); OverscrollMode overscroll_mode() const { return overscroll_mode_; } @@ -86,22 +86,22 @@ class OverscrollController { // Returns true if the event indicates that the in-progress overscroll gesture // can now be completed. bool DispatchEventCompletesAction( - const WebKit::WebInputEvent& event) const; + const blink::WebInputEvent& event) const; // Returns true to indicate that dispatching the event should reset the // overscroll gesture status. - bool DispatchEventResetsState(const WebKit::WebInputEvent& event) const; + bool DispatchEventResetsState(const blink::WebInputEvent& event) const; // Processes an event to update the internal state for overscroll. Returns // true if the state is updated, false otherwise. - bool ProcessEventForOverscroll(const WebKit::WebInputEvent& event); + bool ProcessEventForOverscroll(const blink::WebInputEvent& event); // Processes horizontal overscroll. This can update both the overscroll mode // and the over scroll amount (i.e. |overscroll_mode_|, |overscroll_delta_x_| // and |overscroll_delta_y_|). void ProcessOverscroll(float delta_x, float delta_y, - WebKit::WebInputEvent::Type event_type); + blink::WebInputEvent::Type event_type); // Completes the desired action from the current gesture. void CompleteAction(); diff --git a/content/browser/renderer_host/pepper/pepper_gamepad_host_unittest.cc b/content/browser/renderer_host/pepper/pepper_gamepad_host_unittest.cc index 3dfbe2b..43ff117 100644 --- a/content/browser/renderer_host/pepper/pepper_gamepad_host_unittest.cc +++ b/content/browser/renderer_host/pepper/pepper_gamepad_host_unittest.cc @@ -31,7 +31,7 @@ class PepperGamepadHostTest virtual ~PepperGamepadHostTest() { } - void ConstructService(const WebKit::WebGamepads& test_data) { + void ConstructService(const blink::WebGamepads& test_data) { service_.reset(new GamepadServiceTestConstructor(test_data)); } @@ -68,15 +68,15 @@ TEST_F(PepperGamepadHostTest, ValidateHardwareBuffersMatch) { TEST_F(PepperGamepadHostTest, ValidateGamepadsMatch) { // Gamepads. COMPILE_ASSERT(sizeof(ppapi::WebKitGamepads) == - sizeof(WebKit::WebGamepads), + sizeof(blink::WebGamepads), gamepads_data_must_match); ppapi::WebKitGamepads ppapi_gamepads; - WebKit::WebGamepads web_gamepads; + blink::WebGamepads web_gamepads; EXPECT_EQ(AddressDiff(&web_gamepads.length, &web_gamepads), AddressDiff(&ppapi_gamepads.length, &ppapi_gamepads)); // See comment below on storage & the EXPECT macro. - size_t webkit_items_length_cap = WebKit::WebGamepads::itemsLengthCap; + size_t webkit_items_length_cap = blink::WebGamepads::itemsLengthCap; size_t ppapi_items_length_cap = ppapi::WebKitGamepads::kItemsLengthCap; EXPECT_EQ(webkit_items_length_cap, ppapi_items_length_cap); @@ -89,23 +89,23 @@ TEST_F(PepperGamepadHostTest, ValidateGamepadsMatch) { TEST_F(PepperGamepadHostTest, ValidateGamepadMatch) { // Gamepad. COMPILE_ASSERT(sizeof(ppapi::WebKitGamepad) == - sizeof(WebKit::WebGamepad), + sizeof(blink::WebGamepad), gamepad_data_must_match); ppapi::WebKitGamepad ppapi_gamepad; - WebKit::WebGamepad web_gamepad; + blink::WebGamepad web_gamepad; // Using EXPECT seems to force storage for the parameter, which the constants // in the WebKit/PPAPI headers don't have. So we have to use temporaries // before comparing them. - size_t webkit_id_length_cap = WebKit::WebGamepad::idLengthCap; + size_t webkit_id_length_cap = blink::WebGamepad::idLengthCap; size_t ppapi_id_length_cap = ppapi::WebKitGamepad::kIdLengthCap; EXPECT_EQ(webkit_id_length_cap, ppapi_id_length_cap); - size_t webkit_axes_length_cap = WebKit::WebGamepad::axesLengthCap; + size_t webkit_axes_length_cap = blink::WebGamepad::axesLengthCap; size_t ppapi_axes_length_cap = ppapi::WebKitGamepad::kAxesLengthCap; EXPECT_EQ(webkit_axes_length_cap, ppapi_axes_length_cap); - size_t webkit_buttons_length_cap = WebKit::WebGamepad::buttonsLengthCap; + size_t webkit_buttons_length_cap = blink::WebGamepad::buttonsLengthCap; size_t ppapi_buttons_length_cap = ppapi::WebKitGamepad::kButtonsLengthCap; EXPECT_EQ(webkit_buttons_length_cap, ppapi_buttons_length_cap); @@ -126,8 +126,8 @@ TEST_F(PepperGamepadHostTest, ValidateGamepadMatch) { } TEST_F(PepperGamepadHostTest, WaitForReply) { - WebKit::WebGamepads default_data; - memset(&default_data, 0, sizeof(WebKit::WebGamepads)); + blink::WebGamepads default_data; + memset(&default_data, 0, sizeof(blink::WebGamepads)); default_data.length = 1; default_data.items[0].connected = true; default_data.items[0].buttonsLength = 1; @@ -163,7 +163,7 @@ TEST_F(PepperGamepadHostTest, WaitForReply) { // will issue the callback on our thread. Waiting for it to read twice // ensures that it was able to issue callbacks for the first read (if it // issued one) before we try to check for it. - WebKit::WebGamepads button_down_data = default_data; + blink::WebGamepads button_down_data = default_data; button_down_data.items[0].buttons[0] = 1.f; fetcher->SetTestData(button_down_data); fetcher->WaitForDataRead(); diff --git a/content/browser/renderer_host/render_message_filter.cc b/content/browser/renderer_host/render_message_filter.cc index f926ff6..03d8798 100644 --- a/content/browser/renderer_host/render_message_filter.cc +++ b/content/browser/renderer_host/render_message_filter.cc @@ -497,7 +497,7 @@ void RenderMessageFilter::OnCreateWindow( } void RenderMessageFilter::OnCreateWidget(int opener_id, - WebKit::WebPopupType popup_type, + blink::WebPopupType popup_type, int* route_id, int* surface_id) { render_widget_helper_->CreateNewWidget( @@ -857,7 +857,7 @@ void RenderMessageFilter::OnCheckNotificationPermission( CheckDesktopNotificationPermission(source_origin, resource_context_, render_process_id_); #else - *result = WebKit::WebNotificationPresenter::PermissionAllowed; + *result = blink::WebNotificationPresenter::PermissionAllowed; #endif } diff --git a/content/browser/renderer_host/render_message_filter.h b/content/browser/renderer_host/render_message_filter.h index d0a4386..9d95459 100644 --- a/content/browser/renderer_host/render_message_filter.h +++ b/content/browser/renderer_host/render_message_filter.h @@ -40,7 +40,7 @@ struct FontDescriptor; struct ViewHostMsg_CreateWindow_Params; -namespace WebKit { +namespace blink { struct WebScreenInfo; } @@ -126,7 +126,7 @@ class RenderMessageFilter : public BrowserMessageFilter { int* surface_id, int64* cloned_session_storage_namespace_id); void OnCreateWidget(int opener_id, - WebKit::WebPopupType popup_type, + blink::WebPopupType popup_type, int* route_id, int* surface_id); void OnCreateFullscreenWidget(int opener_id, diff --git a/content/browser/renderer_host/render_sandbox_host_linux.cc b/content/browser/renderer_host/render_sandbox_host_linux.cc index 8153718..986bff9 100644 --- a/content/browser/renderer_host/render_sandbox_host_linux.cc +++ b/content/browser/renderer_host/render_sandbox_host_linux.cc @@ -39,10 +39,10 @@ #include "third_party/skia/include/ports/SkFontConfigInterface.h" #include "ui/gfx/font_render_params_linux.h" -using WebKit::WebCString; -using WebKit::WebFontInfo; -using WebKit::WebUChar; -using WebKit::WebUChar32; +using blink::WebCString; +using blink::WebFontInfo; +using blink::WebUChar; +using blink::WebUChar32; namespace content { @@ -260,7 +260,7 @@ class SandboxIPCProcess { if (!pickle.ReadString(&iter, &preferred_locale)) return; - WebKit::WebFontFamily family; + blink::WebFontFamily family; WebFontInfo::familyForChar(c, preferred_locale.c_str(), &family); Pickle reply; @@ -286,7 +286,7 @@ class SandboxIPCProcess { } EnsureWebKitInitialized(); - WebKit::WebFontRenderStyle style; + blink::WebFontRenderStyle style; WebFontInfo::renderStyleForStrike(family.c_str(), sizeAndStyle, &style); Pickle reply; @@ -654,14 +654,14 @@ class SandboxIPCProcess { SandboxIPCProcess::~SandboxIPCProcess() { paths_.deleteAll(); if (webkit_platform_support_) - WebKit::shutdownWithoutV8(); + blink::shutdownWithoutV8(); } void SandboxIPCProcess::EnsureWebKitInitialized() { if (webkit_platform_support_) return; webkit_platform_support_.reset(new WebKitPlatformSupportImpl); - WebKit::initializeWithoutV8(webkit_platform_support_.get()); + blink::initializeWithoutV8(webkit_platform_support_.get()); } // ----------------------------------------------------------------------------- diff --git a/content/browser/renderer_host/render_view_host_delegate.h b/content/browser/renderer_host/render_view_host_delegate.h index f3f31e4..dfefdec 100644 --- a/content/browser/renderer_host/render_view_host_delegate.h +++ b/content/browser/renderer_host/render_view_host_delegate.h @@ -404,7 +404,7 @@ class CONTENT_EXPORT RenderViewHostDelegate { // |popup_type| indicates if the widget is a popup and what kind of popup it // is (select, autofill...). virtual void CreateNewWidget(int route_id, - WebKit::WebPopupType popup_type) {} + blink::WebPopupType popup_type) {} // Creates a full screen RenderWidget. Similar to above. virtual void CreateNewFullscreenWidget(int route_id) {} diff --git a/content/browser/renderer_host/render_view_host_impl.cc b/content/browser/renderer_host/render_view_host_impl.cc index 44b4d8c..8d36fd2 100644 --- a/content/browser/renderer_host/render_view_host_impl.cc +++ b/content/browser/renderer_host/render_view_host_impl.cc @@ -86,13 +86,13 @@ #endif using base::TimeDelta; -using WebKit::WebConsoleMessage; -using WebKit::WebDragOperation; -using WebKit::WebDragOperationNone; -using WebKit::WebDragOperationsMask; -using WebKit::WebInputEvent; -using WebKit::WebMediaPlayerAction; -using WebKit::WebPluginAction; +using blink::WebConsoleMessage; +using blink::WebDragOperation; +using blink::WebDragOperationNone; +using blink::WebDragOperationsMask; +using blink::WebInputEvent; +using blink::WebMediaPlayerAction; +using blink::WebPluginAction; namespace content { namespace { @@ -103,11 +103,11 @@ const int kUnloadTimeoutMS = 1000; // Translate a WebKit text direction into a base::i18n one. base::i18n::TextDirection WebTextDirectionToChromeTextDirection( - WebKit::WebTextDirection dir) { + blink::WebTextDirection dir) { switch (dir) { - case WebKit::WebTextDirectionLeftToRight: + case blink::WebTextDirectionLeftToRight: return base::i18n::LEFT_TO_RIGHT; - case WebKit::WebTextDirectionRightToLeft: + case blink::WebTextDirectionRightToLeft: return base::i18n::RIGHT_TO_LEFT; default: NOTREACHED(); @@ -1308,7 +1308,7 @@ void RenderViewHostImpl::CreateNewWindow( } void RenderViewHostImpl::CreateNewWidget(int route_id, - WebKit::WebPopupType popup_type) { + blink::WebPopupType popup_type) { delegate_->CreateNewWidget(route_id, popup_type); } @@ -1515,7 +1515,7 @@ void RenderViewHostImpl::OnUpdateState(int32 page_id, const PageState& state) { void RenderViewHostImpl::OnUpdateTitle( int32 page_id, const string16& title, - WebKit::WebTextDirection title_direction) { + blink::WebTextDirection title_direction) { if (title.length() > kMaxTitleChars) { NOTREACHED() << "Renderer sent too many characters in title."; return; @@ -1870,11 +1870,11 @@ gfx::Rect RenderViewHostImpl::GetRootWindowResizerRect() const { } void RenderViewHostImpl::ForwardMouseEvent( - const WebKit::WebMouseEvent& mouse_event) { + const blink::WebMouseEvent& mouse_event) { // We make a copy of the mouse event because // RenderWidgetHost::ForwardMouseEvent will delete |mouse_event|. - WebKit::WebMouseEvent event_copy(mouse_event); + blink::WebMouseEvent event_copy(mouse_event); RenderWidgetHostImpl::ForwardMouseEvent(event_copy); switch (event_copy.type) { @@ -2019,7 +2019,7 @@ void RenderViewHostImpl::DisownOpener() { } void RenderViewHostImpl::SetAccessibilityCallbackForTesting( - const base::Callback<void(WebKit::WebAXEvent)>& callback) { + const base::Callback<void(blink::WebAXEvent)>& callback) { accessibility_testing_callback_ = callback; } @@ -2056,7 +2056,7 @@ void RenderViewHostImpl::ReloadFrame() { void RenderViewHostImpl::Find(int request_id, const string16& search_text, - const WebKit::WebFindOptions& options) { + const blink::WebFindOptions& options) { Send(new ViewMsg_Find(GetRoutingID(), request_id, search_text, options)); } @@ -2099,12 +2099,12 @@ void RenderViewHostImpl::CopyImageAt(int x, int y) { } void RenderViewHostImpl::ExecuteMediaPlayerActionAtLocation( - const gfx::Point& location, const WebKit::WebMediaPlayerAction& action) { + const gfx::Point& location, const blink::WebMediaPlayerAction& action) { Send(new ViewMsg_MediaPlayerActionAt(GetRoutingID(), location, action)); } void RenderViewHostImpl::ExecutePluginActionAtLocation( - const gfx::Point& location, const WebKit::WebPluginAction& action) { + const gfx::Point& location, const blink::WebPluginAction& action) { Send(new ViewMsg_PluginActionAt(GetRoutingID(), location, action)); } @@ -2131,9 +2131,9 @@ void RenderViewHostImpl::OnAccessibilityEvents( for (unsigned i = 0; i < params.size(); i++) { const AccessibilityHostMsg_EventParams& param = params[i]; - WebKit::WebAXEvent src_type = param.event_type; - if (src_type == WebKit::WebAXEventLayoutComplete || - src_type == WebKit::WebAXEventLoadComplete) { + blink::WebAXEvent src_type = param.event_type; + if (src_type == blink::WebAXEventLayoutComplete || + src_type == blink::WebAXEventLoadComplete) { MakeAccessibilityNodeDataTree(param.nodes, &accessibility_tree_); } accessibility_testing_callback_.Run(src_type); diff --git a/content/browser/renderer_host/render_view_host_impl.h b/content/browser/renderer_host/render_view_host_impl.h index ed963cd..c6d6016 100644 --- a/content/browser/renderer_host/render_view_host_impl.h +++ b/content/browser/renderer_host/render_view_host_impl.h @@ -144,7 +144,7 @@ class CONTENT_EXPORT RenderViewHostImpl virtual void DisableScrollbarsForThreshold(const gfx::Size& size) OVERRIDE; virtual void DragSourceEndedAt( int client_x, int client_y, int screen_x, int screen_y, - WebKit::WebDragOperation operation) OVERRIDE; + blink::WebDragOperation operation) OVERRIDE; virtual void DragSourceMovedTo( int client_x, int client_y, int screen_x, int screen_y) OVERRIDE; virtual void DragSourceSystemDragEnded() OVERRIDE; @@ -152,12 +152,12 @@ class CONTENT_EXPORT RenderViewHostImpl const DropData& drop_data, const gfx::Point& client_pt, const gfx::Point& screen_pt, - WebKit::WebDragOperationsMask operations_allowed, + blink::WebDragOperationsMask operations_allowed, int key_modifiers) OVERRIDE; virtual void DragTargetDragOver( const gfx::Point& client_pt, const gfx::Point& screen_pt, - WebKit::WebDragOperationsMask operations_allowed, + blink::WebDragOperationsMask operations_allowed, int key_modifiers) OVERRIDE; virtual void DragTargetDragLeave() OVERRIDE; virtual void DragTargetDrop(const gfx::Point& client_pt, @@ -171,7 +171,7 @@ class CONTENT_EXPORT RenderViewHostImpl int action, const CustomContextMenuContext& context) OVERRIDE; virtual void ExecuteMediaPlayerActionAtLocation( const gfx::Point& location, - const WebKit::WebMediaPlayerAction& action) OVERRIDE; + const blink::WebMediaPlayerAction& action) OVERRIDE; virtual void ExecuteJavascriptInWebFrame(const string16& frame_xpath, const string16& jscript) OVERRIDE; virtual void ExecuteJavascriptInWebFrameCallbackResult( @@ -180,10 +180,10 @@ class CONTENT_EXPORT RenderViewHostImpl const JavascriptResultCallback& callback) OVERRIDE; virtual void ExecutePluginActionAtLocation( const gfx::Point& location, - const WebKit::WebPluginAction& action) OVERRIDE; + const blink::WebPluginAction& action) OVERRIDE; virtual void ExitFullscreen() OVERRIDE; virtual void Find(int request_id, const string16& search_text, - const WebKit::WebFindOptions& options) OVERRIDE; + const blink::WebFindOptions& options) OVERRIDE; virtual void StopFinding(StopFindAction action) OVERRIDE; virtual void FirePageBeforeUnload(bool for_cross_site_transition) OVERRIDE; virtual void FilesSelectedInChooser( @@ -384,7 +384,7 @@ class CONTENT_EXPORT RenderViewHostImpl virtual void LostCapture() OVERRIDE; virtual void LostMouseLock() OVERRIDE; virtual void ForwardMouseEvent( - const WebKit::WebMouseEvent& mouse_event) OVERRIDE; + const blink::WebMouseEvent& mouse_event) OVERRIDE; virtual void OnPointerEventActivate() OVERRIDE; virtual void ForwardKeyboardEvent( const NativeWebKeyboardEvent& key_event) OVERRIDE; @@ -399,7 +399,7 @@ class CONTENT_EXPORT RenderViewHostImpl // Creates a new RenderWidget with the given route id. |popup_type| indicates // if this widget is a popup and what kind of popup it is (select, autofill). - void CreateNewWidget(int route_id, WebKit::WebPopupType popup_type); + void CreateNewWidget(int route_id, blink::WebPopupType popup_type); // Creates a full screen RenderWidget. void CreateNewFullscreenWidget(int route_id); @@ -440,7 +440,7 @@ class CONTENT_EXPORT RenderViewHostImpl // renderer process, and the accessibility tree it sent can be // retrieved using accessibility_tree_for_testing(). void SetAccessibilityCallbackForTesting( - const base::Callback<void(WebKit::WebAXEvent)>& callback); + const base::Callback<void(blink::WebAXEvent)>& callback); // Only valid if SetAccessibilityCallbackForTesting was called and // the callback was run at least once. Returns a snapshot of the @@ -532,7 +532,7 @@ class CONTENT_EXPORT RenderViewHostImpl void OnUpdateState(int32 page_id, const PageState& state); void OnUpdateTitle(int32 page_id, const string16& title, - WebKit::WebTextDirection title_direction); + blink::WebTextDirection title_direction); void OnUpdateEncoding(const std::string& encoding); void OnUpdateTargetURL(int32 page_id, const GURL& url); void OnClose(); @@ -571,11 +571,11 @@ class CONTENT_EXPORT RenderViewHostImpl bool is_reload, IPC::Message* reply_msg); void OnStartDragging(const DropData& drop_data, - WebKit::WebDragOperationsMask operations_allowed, + blink::WebDragOperationsMask operations_allowed, const SkBitmap& bitmap, const gfx::Vector2d& bitmap_offset_in_dip, const DragEventSourceInfo& event_info); - void OnUpdateDragCursor(WebKit::WebDragOperation drag_operation); + void OnUpdateDragCursor(blink::WebDragOperation drag_operation); void OnTargetDropACK(); void OnTakeFocus(bool reverse); void OnFocusedNodeChanged(bool is_editable_node); @@ -717,7 +717,7 @@ class CONTENT_EXPORT RenderViewHostImpl std::map<int, JavascriptResultCallback> javascript_callbacks_; // Accessibility callback for testing. - base::Callback<void(WebKit::WebAXEvent)> accessibility_testing_callback_; + base::Callback<void(blink::WebAXEvent)> accessibility_testing_callback_; // The most recently received accessibility tree - for testing only. AccessibilityNodeDataTreeNode accessibility_tree_; diff --git a/content/browser/renderer_host/render_view_host_unittest.cc b/content/browser/renderer_host/render_view_host_unittest.cc index 3d13b5e..67e08d2 100644 --- a/content/browser/renderer_host/render_view_host_unittest.cc +++ b/content/browser/renderer_host/render_view_host_unittest.cc @@ -125,14 +125,14 @@ class MockDraggingRenderViewHostDelegateView bool right_aligned, bool allow_multiple_selection) OVERRIDE {} virtual void StartDragging(const DropData& drop_data, - WebKit::WebDragOperationsMask allowed_ops, + blink::WebDragOperationsMask allowed_ops, const gfx::ImageSkia& image, const gfx::Vector2d& image_offset, const DragEventSourceInfo& event_info) OVERRIDE { drag_url_ = drop_data.url; html_base_url_ = drop_data.html_base_url; } - virtual void UpdateDragCursor(WebKit::WebDragOperation operation) OVERRIDE {} + virtual void UpdateDragCursor(blink::WebDragOperation operation) OVERRIDE {} virtual void GotFocus() OVERRIDE {} virtual void TakeFocus(bool reverse) OVERRIDE {} virtual void UpdatePreferredSize(const gfx::Size& pref_size) {} @@ -202,7 +202,7 @@ TEST_F(RenderViewHostTest, DragEnteredFileURLsStillBlocked) { UTF8ToUTF16(dragged_file_path.AsUTF8Unsafe()), string16())); rvh()->DragTargetDragEnter(dropped_data, client_point, screen_point, - WebKit::WebDragOperationNone, 0); + blink::WebDragOperationNone, 0); int id = process()->GetID(); ChildProcessSecurityPolicyImpl* policy = diff --git a/content/browser/renderer_host/render_widget_helper.cc b/content/browser/renderer_host/render_widget_helper.cc index e7e2595..7f772e3 100644 --- a/content/browser/renderer_host/render_widget_helper.cc +++ b/content/browser/renderer_host/render_widget_helper.cc @@ -300,7 +300,7 @@ void RenderWidgetHelper::OnResumeRequestsForView(int route_id) { } void RenderWidgetHelper::CreateNewWidget(int opener_id, - WebKit::WebPopupType popup_type, + blink::WebPopupType popup_type, int* route_id, int* surface_id) { *route_id = GetNextRoutingID(); @@ -327,7 +327,7 @@ void RenderWidgetHelper::CreateNewFullscreenWidget(int opener_id, } void RenderWidgetHelper::OnCreateWidgetOnUI( - int opener_id, int route_id, WebKit::WebPopupType popup_type) { + int opener_id, int route_id, blink::WebPopupType popup_type) { RenderViewHostImpl* host = RenderViewHostImpl::FromID( render_process_id_, opener_id); if (host) diff --git a/content/browser/renderer_host/render_widget_helper.h b/content/browser/renderer_host/render_widget_helper.h index c5e80a1..a81b1de 100644 --- a/content/browser/renderer_host/render_widget_helper.h +++ b/content/browser/renderer_host/render_widget_helper.h @@ -153,7 +153,7 @@ class RenderWidgetHelper int* surface_id, SessionStorageNamespace* session_storage_namespace); void CreateNewWidget(int opener_id, - WebKit::WebPopupType popup_type, + blink::WebPopupType popup_type, int* route_id, int* surface_id); void CreateNewFullscreenWidget(int opener_id, int* route_id, int* surface_id); @@ -207,7 +207,7 @@ class RenderWidgetHelper // Called on the UI thread to finish creating a widget. void OnCreateWidgetOnUI(int opener_id, int route_id, - WebKit::WebPopupType popup_type); + blink::WebPopupType popup_type); // Called on the UI thread to create a fullscreen widget. void OnCreateFullscreenWidgetOnUI(int opener_id, int route_id); diff --git a/content/browser/renderer_host/render_widget_host_delegate.cc b/content/browser/renderer_host/render_widget_host_delegate.cc index 73f5325..efc1915 100644 --- a/content/browser/renderer_host/render_widget_host_delegate.cc +++ b/content/browser/renderer_host/render_widget_host_delegate.cc @@ -13,7 +13,7 @@ bool RenderWidgetHostDelegate::PreHandleKeyboardEvent( } bool RenderWidgetHostDelegate::PreHandleWheelEvent( - const WebKit::WebMouseWheelEvent& event) { + const blink::WebMouseWheelEvent& event) { return false; } diff --git a/content/browser/renderer_host/render_widget_host_delegate.h b/content/browser/renderer_host/render_widget_host_delegate.h index 9e8d36e..22f5a19 100644 --- a/content/browser/renderer_host/render_widget_host_delegate.h +++ b/content/browser/renderer_host/render_widget_host_delegate.h @@ -9,7 +9,7 @@ #include "content/common/content_export.h" #include "ui/gfx/native_widget_types.h" -namespace WebKit { +namespace blink { class WebMouseWheelEvent; } @@ -44,7 +44,7 @@ class CONTENT_EXPORT RenderWidgetHostDelegate { // Callback to give the browser a chance to handle the specified mouse wheel // event before sending it to the renderer. // Returns true if the |event| was handled. - virtual bool PreHandleWheelEvent(const WebKit::WebMouseWheelEvent& event); + virtual bool PreHandleWheelEvent(const blink::WebMouseWheelEvent& event); // Notifies that screen rects were sent to renderer process. virtual void DidSendScreenRects(RenderWidgetHostImpl* rwh) {} diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc index c1917a1..fb3adb3 100644 --- a/content/browser/renderer_host/render_widget_host_impl.cc +++ b/content/browser/renderer_host/render_widget_host_impl.cc @@ -73,12 +73,12 @@ using base::Time; using base::TimeDelta; using base::TimeTicks; -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebKeyboardEvent; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebTextDirection; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebKeyboardEvent; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; +using blink::WebTextDirection; namespace content { namespace { @@ -182,7 +182,7 @@ RenderWidgetHostImpl::RenderWidgetHostImpl(RenderWidgetHostDelegate* delegate, ignore_input_events_(false), input_method_active_(false), text_direction_updated_(false), - text_direction_(WebKit::WebTextDirectionLeftToRight), + text_direction_(blink::WebTextDirectionLeftToRight), text_direction_canceled_(false), suppress_next_char_events_(false), pending_mouse_lock_request_(false), @@ -631,7 +631,7 @@ void RenderWidgetHostImpl::WasResized() { return; if (!screen_info_) { - screen_info_.reset(new WebKit::WebScreenInfo); + screen_info_.reset(new blink::WebScreenInfo); GetWebScreenInfo(screen_info_.get()); } @@ -1009,12 +1009,12 @@ void RenderWidgetHostImpl::ForwardWheelEventWithLatencyInfo( } void RenderWidgetHostImpl::ForwardGestureEvent( - const WebKit::WebGestureEvent& gesture_event) { + const blink::WebGestureEvent& gesture_event) { ForwardGestureEventWithLatencyInfo(gesture_event, ui::LatencyInfo()); } void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo( - const WebKit::WebGestureEvent& gesture_event, + const blink::WebGestureEvent& gesture_event, const ui::LatencyInfo& ui_latency) { TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardGestureEvent"); // Early out if necessary, prior to performing latency logic. @@ -1023,7 +1023,7 @@ void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo( ui::LatencyInfo latency_info = CreateRWHLatencyInfoIfNotExist(&ui_latency); - if (gesture_event.type == WebKit::WebInputEvent::GestureScrollUpdate) { + if (gesture_event.type == blink::WebInputEvent::GestureScrollUpdate) { latency_info.AddLatencyNumber( ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT, GetLatencyComponentId(), @@ -1051,7 +1051,7 @@ void RenderWidgetHostImpl::ForwardGestureEventWithLatencyInfo( } void RenderWidgetHostImpl::ForwardTouchEventWithLatencyInfo( - const WebKit::WebTouchEvent& touch_event, + const blink::WebTouchEvent& touch_event, const ui::LatencyInfo& ui_latency) { TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardTouchEvent"); @@ -1191,7 +1191,7 @@ void RenderWidgetHostImpl::RemoveMouseEventCallback( } } -void RenderWidgetHostImpl::GetWebScreenInfo(WebKit::WebScreenInfo* result) { +void RenderWidgetHostImpl::GetWebScreenInfo(blink::WebScreenInfo* result) { TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::GetWebScreenInfo"); if (GetView()) static_cast<RenderWidgetHostViewPort*>(GetView())->GetScreenInfo(result); @@ -1324,7 +1324,7 @@ void RenderWidgetHostImpl::SetInputMethodActive(bool activate) { void RenderWidgetHostImpl::ImeSetComposition( const string16& text, - const std::vector<WebKit::WebCompositionUnderline>& underlines, + const std::vector<blink::WebCompositionUnderline>& underlines, int selection_start, int selection_end) { Send(new ViewMsg_ImeSetComposition( @@ -1341,7 +1341,7 @@ void RenderWidgetHostImpl::ImeConfirmComposition( void RenderWidgetHostImpl::ImeCancelComposition() { Send(new ViewMsg_ImeSetComposition(GetRoutingID(), string16(), - std::vector<WebKit::WebCompositionUnderline>(), 0, 0)); + std::vector<blink::WebCompositionUnderline>(), 0, 0)); } void RenderWidgetHostImpl::ExtendSelectionAndDelete( @@ -1461,11 +1461,11 @@ void RenderWidgetHostImpl::OnSetTooltipText( // but we use the current approach to match Fx & IE's behavior. string16 wrapped_tooltip_text = tooltip_text; if (!tooltip_text.empty()) { - if (text_direction_hint == WebKit::WebTextDirectionLeftToRight) { + if (text_direction_hint == blink::WebTextDirectionLeftToRight) { // Force the tooltip to have LTR directionality. wrapped_tooltip_text = base::i18n::GetDisplayStringInLTRDirectionality(wrapped_tooltip_text); - } else if (text_direction_hint == WebKit::WebTextDirectionRightToLeft && + } else if (text_direction_hint == blink::WebTextDirectionRightToLeft && !base::i18n::IsRTL()) { // Force the tooltip to have RTL directionality. base::i18n::WrapStringWithRTLFormatting(&wrapped_tooltip_text); @@ -1971,7 +1971,7 @@ bool RenderWidgetHostImpl::KeyPressListenersHandleEvent( } InputEventAckState RenderWidgetHostImpl::FilterInputEvent( - const WebKit::WebInputEvent& event, const ui::LatencyInfo& latency_info) { + const blink::WebInputEvent& event, const ui::LatencyInfo& latency_info) { // Don't ignore touch cancel events, since they may be sent while input // events are being ignored in order to keep the renderer from getting // confused about how many touches are active. diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h index 143362b..2bda1f2 100644 --- a/content/browser/renderer_host/render_widget_host_impl.h +++ b/content/browser/renderer_host/render_widget_host_impl.h @@ -62,7 +62,7 @@ namespace ui { class KeyEvent; } -namespace WebKit { +namespace blink { class WebInputEvent; class WebMouseEvent; struct WebCompositionUnderline; @@ -70,7 +70,7 @@ struct WebScreenInfo; } #if defined(OS_ANDROID) -namespace WebKit { +namespace blink { class WebLayer; } #endif @@ -130,7 +130,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, virtual void Delete() OVERRIDE; virtual void SelectAll() OVERRIDE; virtual void Unselect() OVERRIDE; - virtual void UpdateTextDirection(WebKit::WebTextDirection direction) OVERRIDE; + virtual void UpdateTextDirection(blink::WebTextDirection direction) OVERRIDE; virtual void NotifyTextDirection() OVERRIDE; virtual void Focus() OVERRIDE; virtual void Blur() OVERRIDE; @@ -149,9 +149,9 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, #endif virtual void EnableFullAccessibilityMode() OVERRIDE; virtual void ForwardMouseEvent( - const WebKit::WebMouseEvent& mouse_event) OVERRIDE; + const blink::WebMouseEvent& mouse_event) OVERRIDE; virtual void ForwardWheelEvent( - const WebKit::WebMouseWheelEvent& wheel_event) OVERRIDE; + const blink::WebMouseWheelEvent& wheel_event) OVERRIDE; virtual void ForwardKeyboardEvent( const NativeWebKeyboardEvent& key_event) OVERRIDE; virtual const gfx::Vector2d& GetLastScrollOffset() const OVERRIDE; @@ -179,7 +179,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, const MouseEventCallback& callback) OVERRIDE; virtual void RemoveMouseEventCallback( const MouseEventCallback& callback) OVERRIDE; - virtual void GetWebScreenInfo(WebKit::WebScreenInfo* result) OVERRIDE; + virtual void GetWebScreenInfo(blink::WebScreenInfo* result) OVERRIDE; virtual void GetSnapshotFromRenderer( const gfx::Rect& src_subrect, const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE; @@ -287,12 +287,12 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, // Forwards the given message to the renderer. These are called by the view // when it has received a message. - void ForwardGestureEvent(const WebKit::WebGestureEvent& gesture_event); + void ForwardGestureEvent(const blink::WebGestureEvent& gesture_event); void ForwardGestureEventWithLatencyInfo( - const WebKit::WebGestureEvent& gesture_event, + const blink::WebGestureEvent& gesture_event, const ui::LatencyInfo& ui_latency); void ForwardTouchEventWithLatencyInfo( - const WebKit::WebTouchEvent& touch_event, + const blink::WebTouchEvent& touch_event, const ui::LatencyInfo& ui_latency); void ForwardMouseEventWithLatencyInfo( const MouseEventWithLatencyInfo& mouse_event); @@ -329,7 +329,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, // * when markedText of NSTextInput is called (on Mac). void ImeSetComposition( const string16& text, - const std::vector<WebKit::WebCompositionUnderline>& underlines, + const std::vector<blink::WebCompositionUnderline>& underlines, int selection_start, int selection_end); @@ -567,7 +567,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, // its delegate. // Called when a mousewheel event was not processed by the renderer. - virtual void UnhandledWheelEvent(const WebKit::WebMouseWheelEvent& event) {} + virtual void UnhandledWheelEvent(const blink::WebMouseWheelEvent& event) {} // Notification that the user has made some kind of input that could // perform an action. The gestures that count are 1) any mouse down @@ -646,7 +646,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, void OnUpdateScreenRectsAck(); void OnRequestMove(const gfx::Rect& pos); void OnSetTooltipText(const string16& tooltip_text, - WebKit::WebTextDirection text_direction_hint); + blink::WebTextDirection text_direction_hint); void OnPaintAtSizeAck(int tag, const gfx::Size& size); #if defined(OS_MACOSX) void OnCompositorSurfaceBuffersSwapped( @@ -719,7 +719,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, // InputRouterClient virtual InputEventAckState FilterInputEvent( - const WebKit::WebInputEvent& event, + const blink::WebInputEvent& event, const ui::LatencyInfo& latency_info) OVERRIDE; virtual void IncrementInFlightEventCount() OVERRIDE; virtual void DecrementInFlightEventCount() OVERRIDE; @@ -783,7 +783,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, // Cached copy of the screen info so that it doesn't need to be updated every // time the window is resized. - scoped_ptr<WebKit::WebScreenInfo> screen_info_; + scoped_ptr<blink::WebScreenInfo> screen_info_; // Set if screen_info_ may have changed and should be recomputed and force a // resize message. @@ -866,7 +866,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost, // Set when we update the text direction of the selected input element. bool text_direction_updated_; - WebKit::WebTextDirection text_direction_; + blink::WebTextDirection text_direction_; // Set when we cancel updating the text direction. // This flag also ignores succeeding update requests until we call diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc index ec77564..49b631c 100644 --- a/content/browser/renderer_host/render_widget_host_unittest.cc +++ b/content/browser/renderer_host/render_widget_host_unittest.cc @@ -46,11 +46,11 @@ #endif using base::TimeDelta; -using WebKit::WebGestureEvent; -using WebKit::WebInputEvent; -using WebKit::WebMouseWheelEvent; -using WebKit::WebTouchEvent; -using WebKit::WebTouchPoint; +using blink::WebGestureEvent; +using blink::WebInputEvent; +using blink::WebMouseWheelEvent; +using blink::WebTouchEvent; +using blink::WebTouchPoint; namespace content { @@ -439,7 +439,7 @@ class TestView : public TestRenderWidgetHostView { const WebTouchEvent& acked_event() const { return acked_event_; } int acked_event_count() const { return acked_event_count_; } void ClearAckedEvent() { - acked_event_.type = WebKit::WebInputEvent::Undefined; + acked_event_.type = blink::WebInputEvent::Undefined; acked_event_count_ = 0; } @@ -601,7 +601,7 @@ class RenderWidgetHostTest : public testing::Test { bool KeyPressEventCallback(const NativeWebKeyboardEvent& /* event */) { return handle_key_press_event_; } - bool MouseEventCallback(const WebKit::WebMouseEvent& /* event */) { + bool MouseEventCallback(const blink::WebMouseEvent& /* event */) { return handle_mouse_event_; } @@ -1943,7 +1943,7 @@ TEST_F(RenderWidgetHostTest, OverscrollWithTouchEvents) { EXPECT_EQ(0U, process_->sink().message_count()); EXPECT_TRUE(host_->TouchEventQueueEmpty()); - SimulateGestureEvent(WebKit::WebInputEvent::GestureScrollEnd, + SimulateGestureEvent(blink::WebInputEvent::GestureScrollEnd, WebGestureEvent::Touchscreen); base::MessageLoop::current()->PostDelayedTask( FROM_HERE, @@ -2001,7 +2001,7 @@ TEST_F(RenderWidgetHostTest, TouchGestureEndDispatchedAfterOverscrollComplete) { EXPECT_EQ(-5.f, host_->overscroll_delegate()->delta_y()); // Send end event. - SimulateGestureEvent(WebKit::WebInputEvent::GestureScrollEnd, + SimulateGestureEvent(blink::WebInputEvent::GestureScrollEnd, WebGestureEvent::Touchscreen); EXPECT_EQ(0U, process_->sink().message_count()); EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode()); @@ -2019,7 +2019,7 @@ TEST_F(RenderWidgetHostTest, TouchGestureEndDispatchedAfterOverscrollComplete) { EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize()); EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize()); - SendInputEventACK(WebKit::WebInputEvent::GestureScrollEnd, + SendInputEventACK(blink::WebInputEvent::GestureScrollEnd, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); EXPECT_EQ(0U, process_->sink().message_count()); EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize()); @@ -2059,7 +2059,7 @@ TEST_F(RenderWidgetHostTest, TouchGestureEndDispatchedAfterOverscrollComplete) { EXPECT_EQ(-5.f, host_->overscroll_delegate()->delta_y()); // Send end event. - SimulateGestureEvent(WebKit::WebInputEvent::GestureScrollEnd, + SimulateGestureEvent(blink::WebInputEvent::GestureScrollEnd, WebGestureEvent::Touchscreen); EXPECT_EQ(0U, process_->sink().message_count()); EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode()); @@ -2078,7 +2078,7 @@ TEST_F(RenderWidgetHostTest, TouchGestureEndDispatchedAfterOverscrollComplete) { EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize()); EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize()); - SendInputEventACK(WebKit::WebInputEvent::GestureScrollEnd, + SendInputEventACK(blink::WebInputEvent::GestureScrollEnd, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); EXPECT_EQ(0U, process_->sink().message_count()); EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize()); diff --git a/content/browser/renderer_host/render_widget_host_view_android.cc b/content/browser/renderer_host/render_widget_host_view_android.cc index 2b7b6f0..b5491f2 100644 --- a/content/browser/renderer_host/render_widget_host_view_android.cc +++ b/content/browser/renderer_host/render_widget_host_view_android.cc @@ -214,7 +214,7 @@ void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) { SetSize(rect.size()); } -WebKit::WebGLId RenderWidgetHostViewAndroid::GetScaledContentTexture( +blink::WebGLId RenderWidgetHostViewAndroid::GetScaledContentTexture( float scale, gfx::Size* out_size) { gfx::Size size(gfx::ToCeiledSize( @@ -254,7 +254,7 @@ bool RenderWidgetHostViewAndroid::PopulateBitmapWithContents(jobject jbitmap) { GLHelper* helper = ImageTransportFactoryAndroid::GetInstance()->GetGLHelper(); - WebKit::WebGLId texture = helper->CopyAndScaleTexture( + blink::WebGLId texture = helper->CopyAndScaleTexture( texture_id_in_layer_, texture_size_in_layer_, bitmap.size(), @@ -267,7 +267,7 @@ bool RenderWidgetHostViewAndroid::PopulateBitmapWithContents(jobject jbitmap) { gfx::Rect(bitmap.size()), static_cast<unsigned char*> (bitmap.pixels())); - WebKit::WebGraphicsContext3D* context = + blink::WebGraphicsContext3D* context = ImageTransportFactoryAndroid::GetInstance()->GetContext3D(); context->deleteTexture(texture); @@ -948,7 +948,7 @@ bool RenderWidgetHostViewAndroid::HasAcceleratedSurface( return false; } -void RenderWidgetHostViewAndroid::GetScreenInfo(WebKit::WebScreenInfo* result) { +void RenderWidgetHostViewAndroid::GetScreenInfo(blink::WebScreenInfo* result) { // ScreenInfo isn't tied to the widget on Android. Always return the default. RenderWidgetHostViewBase::GetDefaultScreenInfo(result); } @@ -980,25 +980,25 @@ void RenderWidgetHostViewAndroid::SetScrollOffsetPinning( } void RenderWidgetHostViewAndroid::UnhandledWheelEvent( - const WebKit::WebMouseWheelEvent& event) { + const blink::WebMouseWheelEvent& event) { // intentionally empty, like RenderWidgetHostViewViews } void RenderWidgetHostViewAndroid::GestureEventAck( int gesture_event_type, InputEventAckState ack_result) { - if (gesture_event_type == WebKit::WebInputEvent::GestureScrollUpdate && + if (gesture_event_type == blink::WebInputEvent::GestureScrollUpdate && ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) { content_view_core_->OnScrollUpdateGestureConsumed(); } - if (gesture_event_type == WebKit::WebInputEvent::GestureFlingStart && + if (gesture_event_type == blink::WebInputEvent::GestureFlingStart && ack_result == INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS) { content_view_core_->UnhandledFlingStartEvent(); } } InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent( - const WebKit::WebInputEvent& input_event) { + const blink::WebInputEvent& input_event) { if (host_) { SynchronousCompositorImpl* compositor = SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(), @@ -1103,26 +1103,26 @@ void RenderWidgetHostViewAndroid::SendKeyEvent( } void RenderWidgetHostViewAndroid::SendTouchEvent( - const WebKit::WebTouchEvent& event) { + const blink::WebTouchEvent& event) { if (host_) host_->ForwardTouchEventWithLatencyInfo(event, ui::LatencyInfo()); } void RenderWidgetHostViewAndroid::SendMouseEvent( - const WebKit::WebMouseEvent& event) { + const blink::WebMouseEvent& event) { if (host_) host_->ForwardMouseEvent(event); } void RenderWidgetHostViewAndroid::SendMouseWheelEvent( - const WebKit::WebMouseWheelEvent& event) { + const blink::WebMouseWheelEvent& event) { if (host_) host_->ForwardWheelEvent(event); } void RenderWidgetHostViewAndroid::SendGestureEvent( - const WebKit::WebGestureEvent& event) { + const blink::WebGestureEvent& event) { // Sending a gesture that may trigger overscroll should resume the effect. if (overscroll_effect_) overscroll_effect_->SetEnabled(true); @@ -1340,7 +1340,7 @@ void RenderWidgetHostViewAndroid::PrepareBitmapCopyOutputResult( // static void RenderWidgetHostViewPort::GetDefaultScreenInfo( - WebKit::WebScreenInfo* results) { + blink::WebScreenInfo* results) { const gfx::Display& display = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay(); results->rect = display.bounds(); diff --git a/content/browser/renderer_host/render_widget_host_view_android.h b/content/browser/renderer_host/render_widget_host_view_android.h index f68de7e..2257301 100644 --- a/content/browser/renderer_host/render_widget_host_view_android.h +++ b/content/browser/renderer_host/render_widget_host_view_android.h @@ -42,7 +42,7 @@ class SingleReleaseCallback; class TextureLayer; } -namespace WebKit { +namespace blink { class WebExternalTextureLayer; class WebTouchEvent; class WebMouseEvent; @@ -140,7 +140,7 @@ class RenderWidgetHostViewAndroid const scoped_refptr<media::VideoFrame>& target, const base::Callback<void(bool)>& callback) OVERRIDE; virtual bool CanCopyToVideoFrame() const OVERRIDE; - virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE; + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE; virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE; virtual void ProcessAckedTouchEvent(const TouchEventWithLatencyInfo& touch, @@ -150,9 +150,9 @@ class RenderWidgetHostViewAndroid virtual void SetScrollOffsetPinning( bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE; virtual void UnhandledWheelEvent( - const WebKit::WebMouseWheelEvent& event) OVERRIDE; + const blink::WebMouseWheelEvent& event) OVERRIDE; virtual InputEventAckState FilterInputEvent( - const WebKit::WebInputEvent& input_event) OVERRIDE; + const blink::WebInputEvent& input_event) OVERRIDE; virtual void OnSetNeedsFlushInput() OVERRIDE; virtual void GestureEventAck(int gesture_event_type, InputEventAckState ack_result) OVERRIDE; @@ -208,10 +208,10 @@ class RenderWidgetHostViewAndroid void SetContentViewCore(ContentViewCoreImpl* content_view_core); SkColor GetCachedBackgroundColor() const; void SendKeyEvent(const NativeWebKeyboardEvent& event); - void SendTouchEvent(const WebKit::WebTouchEvent& event); - void SendMouseEvent(const WebKit::WebMouseEvent& event); - void SendMouseWheelEvent(const WebKit::WebMouseWheelEvent& event); - void SendGestureEvent(const WebKit::WebGestureEvent& event); + void SendTouchEvent(const blink::WebTouchEvent& event); + void SendMouseEvent(const blink::WebMouseEvent& event); + void SendMouseWheelEvent(const blink::WebMouseWheelEvent& event); + void SendGestureEvent(const blink::WebGestureEvent& event); void SendBeginFrame(const cc::BeginFrameArgs& args); void OnTextInputStateChanged(const ViewHostMsg_TextInputState_Params& params); @@ -223,7 +223,7 @@ class RenderWidgetHostViewAndroid void WasResized(); - WebKit::WebGLId GetScaledContentTexture(float scale, gfx::Size* out_size); + blink::WebGLId GetScaledContentTexture(float scale, gfx::Size* out_size); bool PopulateBitmapWithContents(jobject jbitmap); bool HasValidFrame() const; diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc index 59e7508..2f80cf1 100644 --- a/content/browser/renderer_host/render_widget_host_view_aura.cc +++ b/content/browser/renderer_host/render_widget_host_view_aura.cc @@ -88,8 +88,8 @@ using gfx::RectToSkIRect; using gfx::SkIRectToRect; -using WebKit::WebScreenInfo; -using WebKit::WebTouchEvent; +using blink::WebScreenInfo; +using blink::WebTouchEvent; namespace content { @@ -220,10 +220,10 @@ BOOL CALLBACK DismissOwnedPopups(HWND window, LPARAM arg) { } #endif -void UpdateWebTouchEventAfterDispatch(WebKit::WebTouchEvent* event, - WebKit::WebTouchPoint* point) { - if (point->state != WebKit::WebTouchPoint::StateReleased && - point->state != WebKit::WebTouchPoint::StateCancelled) +void UpdateWebTouchEventAfterDispatch(blink::WebTouchEvent* event, + blink::WebTouchPoint* point) { + if (point->state != blink::WebTouchPoint::StateReleased && + point->state != blink::WebTouchPoint::StateCancelled) return; --event->touchesLength; for (unsigned i = point - event->touches; @@ -2109,15 +2109,15 @@ void RenderWidgetHostViewAura::SetCompositionText( return; // 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. COMPILE_ASSERT(sizeof(ui::CompositionUnderline) == - sizeof(WebKit::WebCompositionUnderline), + sizeof(blink::WebCompositionUnderline), ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff); // 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); // TODO(suzhe): due to a bug of webkit, we can't use selection range with @@ -2156,7 +2156,7 @@ void RenderWidgetHostViewAura::InsertChar(char16 ch, int flags) { if (host_) { double now = ui::EventTimeForNow().InSecondsF(); - // Send a WebKit::WebInputEvent::Char event to |host_|. + // Send a blink::WebInputEvent::Char event to |host_|. NativeWebKeyboardEvent webkit_event(ui::ET_KEY_PRESSED, true /* is_char */, ch, @@ -2311,8 +2311,8 @@ bool RenderWidgetHostViewAura::ChangeTextDirectionAndLayoutAlignment( return false; host_->UpdateTextDirection( direction == base::i18n::RIGHT_TO_LEFT ? - WebKit::WebTextDirectionRightToLeft : - WebKit::WebTextDirectionLeftToRight); + blink::WebTextDirectionRightToLeft : + blink::WebTextDirectionLeftToRight); host_->NotifyTextDirection(); return true; } @@ -2393,7 +2393,7 @@ bool RenderWidgetHostViewAura::ShouldDescendIntoChildForEventHandling( } bool RenderWidgetHostViewAura::CanFocus() { - return popup_type_ == WebKit::WebPopupTypeNone; + return popup_type_ == blink::WebPopupTypeNone; } void RenderWidgetHostViewAura::OnCaptureLost() { @@ -2497,7 +2497,7 @@ void RenderWidgetHostViewAura::DidRecreateLayer(ui::Layer *old_layer, scoped_refptr<ui::Texture> new_texture; if (host_->is_accelerated_compositing_active() && gl_helper && current_surface_.get()) { - WebKit::WebGLId texture_id = + blink::WebGLId texture_id = gl_helper->CopyTexture(current_surface_->PrepareTexture(), current_surface_->size()); if (texture_id) { @@ -2603,7 +2603,7 @@ void RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) { DCHECK(!cursor_client || !cursor_client->IsCursorVisible()); if (event->type() == ui::ET_MOUSEWHEEL) { - WebKit::WebMouseWheelEvent mouse_wheel_event = + blink::WebMouseWheelEvent mouse_wheel_event = MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent*>(event)); if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0) host_->ForwardWheelEvent(mouse_wheel_event); @@ -2621,7 +2621,7 @@ void RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) { return; } - WebKit::WebMouseEvent mouse_event = MakeWebMouseEvent(event); + blink::WebMouseEvent mouse_event = MakeWebMouseEvent(event); bool is_move_to_center_event = (event->type() == ui::ET_MOUSE_MOVED || event->type() == ui::ET_MOUSE_DRAGGED) && @@ -2676,13 +2676,13 @@ void RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) { reinterpret_cast<LPARAM>(toplevel_hwnd)); } #endif - WebKit::WebMouseWheelEvent mouse_wheel_event = + blink::WebMouseWheelEvent mouse_wheel_event = MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent*>(event)); if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0) host_->ForwardWheelEvent(mouse_wheel_event); } else if (CanRendererHandleEvent(event) && !(event->flags() & ui::EF_FROM_TOUCH)) { - WebKit::WebMouseEvent mouse_event = MakeWebMouseEvent(event); + blink::WebMouseEvent mouse_event = MakeWebMouseEvent(event); ModifyEventMovementAndCoords(&mouse_event); host_->ForwardMouseEvent(mouse_event); } @@ -2722,16 +2722,16 @@ void RenderWidgetHostViewAura::OnScrollEvent(ui::ScrollEvent* event) { if (event->type() == ui::ET_SCROLL) { if (event->finger_count() != 2) return; - WebKit::WebGestureEvent gesture_event = + blink::WebGestureEvent gesture_event = MakeWebGestureEventFlingCancel(); host_->ForwardGestureEvent(gesture_event); - WebKit::WebMouseWheelEvent mouse_wheel_event = + blink::WebMouseWheelEvent mouse_wheel_event = MakeWebMouseWheelEvent(event); host_->ForwardWheelEvent(mouse_wheel_event); RecordAction(UserMetricsAction("TrackpadScroll")); } else if (event->type() == ui::ET_SCROLL_FLING_START || event->type() == ui::ET_SCROLL_FLING_CANCEL) { - WebKit::WebGestureEvent gesture_event = + blink::WebGestureEvent gesture_event = MakeWebGestureEvent(event); host_->ForwardGestureEvent(gesture_event); if (event->type() == ui::ET_SCROLL_FLING_START) @@ -2747,7 +2747,7 @@ void RenderWidgetHostViewAura::OnTouchEvent(ui::TouchEvent* event) { return; // Update the touch event first. - WebKit::WebTouchPoint* point = UpdateWebTouchEventFromUIEvent(*event, + blink::WebTouchPoint* point = UpdateWebTouchEventFromUIEvent(*event, &touch_event_); // Forward the touch event only if a touch point was updated, and there's a @@ -2780,7 +2780,7 @@ void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) { return; RenderViewHostDelegate* delegate = NULL; - if (popup_type_ == WebKit::WebPopupTypeNone && !is_fullscreen_) + if (popup_type_ == blink::WebPopupTypeNone && !is_fullscreen_) delegate = RenderViewHost::From(host_)->GetDelegate(); if (delegate && event->type() == ui::ET_GESTURE_BEGIN && @@ -2788,17 +2788,17 @@ void RenderWidgetHostViewAura::OnGestureEvent(ui::GestureEvent* event) { delegate->HandleGestureBegin(); } - WebKit::WebGestureEvent gesture = MakeWebGestureEvent(event); + blink::WebGestureEvent gesture = MakeWebGestureEvent(event); if (event->type() == ui::ET_GESTURE_TAP_DOWN) { // Webkit does not stop a fling-scroll on tap-down. So explicitly send an // event to stop any in-progress flings. - WebKit::WebGestureEvent fling_cancel = gesture; - fling_cancel.type = WebKit::WebInputEvent::GestureFlingCancel; - fling_cancel.sourceDevice = WebKit::WebGestureEvent::Touchscreen; + blink::WebGestureEvent fling_cancel = gesture; + fling_cancel.type = blink::WebInputEvent::GestureFlingCancel; + fling_cancel.sourceDevice = blink::WebGestureEvent::Touchscreen; host_->ForwardGestureEvent(fling_cancel); } - if (gesture.type != WebKit::WebInputEvent::Undefined) { + if (gesture.type != blink::WebInputEvent::Undefined) { host_->ForwardGestureEventWithLatencyInfo(gesture, *event->latency()); if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN || @@ -3153,7 +3153,7 @@ ui::InputMethod* RenderWidgetHostViewAura::GetInputMethod() const { } bool RenderWidgetHostViewAura::NeedsInputGrab() { - return popup_type_ == WebKit::WebPopupTypeSelect; + return popup_type_ == blink::WebPopupTypeSelect; } void RenderWidgetHostViewAura::FinishImeCompositionSession() { @@ -3165,11 +3165,11 @@ void RenderWidgetHostViewAura::FinishImeCompositionSession() { } void RenderWidgetHostViewAura::ModifyEventMovementAndCoords( - WebKit::WebMouseEvent* event) { + blink::WebMouseEvent* event) { // If the mouse has just entered, we must report zero movementX/Y. Hence we // reset any global_mouse_position set previously. - if (event->type == WebKit::WebInputEvent::MouseEnter || - event->type == WebKit::WebInputEvent::MouseLeave) + if (event->type == blink::WebInputEvent::MouseEnter || + event->type == blink::WebInputEvent::MouseLeave) global_mouse_position_.SetPoint(event->globalX, event->globalY); // Movement is computed by taking the difference of the new cursor position @@ -3258,7 +3258,7 @@ void RenderWidgetHostViewAura::AddedToRootWindow() { window_->GetDispatcher()->AddRootWindowObserver(this); host_->ParentChanged(GetNativeViewId()); UpdateScreenInfo(window_); - if (popup_type_ != WebKit::WebPopupTypeNone) + if (popup_type_ != blink::WebPopupTypeNone) event_filter_for_popup_exit_.reset(new EventFilterForPopupExit(this)); aura::client::CursorClient* cursor_client = diff --git a/content/browser/renderer_host/render_widget_host_view_aura.h b/content/browser/renderer_host/render_widget_host_view_aura.h index ddf3f9c..206087a 100644 --- a/content/browser/renderer_host/render_widget_host_view_aura.h +++ b/content/browser/renderer_host/render_widget_host_view_aura.h @@ -223,7 +223,7 @@ class CONTENT_EXPORT RenderWidgetHostViewAura virtual void AcceleratedSurfaceSuspend() OVERRIDE; virtual void AcceleratedSurfaceRelease() OVERRIDE; virtual bool HasAcceleratedSurface(const gfx::Size& desired_size) OVERRIDE; - virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE; + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE; virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; virtual void GestureEventAck(int gesture_event_type, InputEventAckState ack_result) OVERRIDE; @@ -438,7 +438,7 @@ class CONTENT_EXPORT RenderWidgetHostViewAura // This method computes movementX/Y and keeps track of mouse location for // mouse lock on all mouse move events. - void ModifyEventMovementAndCoords(WebKit::WebMouseEvent* event); + void ModifyEventMovementAndCoords(blink::WebMouseEvent* event); // Sends an IPC to the renderer process to communicate whether or not // the mouse cursor is visible anywhere on the screen. @@ -591,7 +591,7 @@ class CONTENT_EXPORT RenderWidgetHostViewAura // The touch-event. Its touch-points are updated as necessary. A new // touch-point is added from an ET_TOUCH_PRESSED event, and a touch-point is // removed from the list on an ET_TOUCH_RELEASED event. - WebKit::WebTouchEvent touch_event_; + blink::WebTouchEvent touch_event_; // The current text input type. ui::TextInputType text_input_type_; diff --git a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc index 88669e0..2c27071 100644 --- a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc +++ b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc @@ -416,21 +416,21 @@ TEST_F(RenderWidgetHostViewAuraTest, TouchEventState) { view_->OnTouchEvent(&press); EXPECT_FALSE(press.handled()); - EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StatePressed, + EXPECT_EQ(blink::WebTouchPoint::StatePressed, view_->touch_event_.touches[0].state); view_->OnTouchEvent(&move); EXPECT_FALSE(move.handled()); - EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StateMoved, + EXPECT_EQ(blink::WebTouchPoint::StateMoved, view_->touch_event_.touches[0].state); view_->OnTouchEvent(&release); EXPECT_FALSE(release.handled()); - EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchEnd, view_->touch_event_.type); EXPECT_EQ(0U, view_->touch_event_.touchesLength); // Now install some touch-event handlers and do the same steps. The touch @@ -441,29 +441,29 @@ TEST_F(RenderWidgetHostViewAuraTest, TouchEventState) { view_->OnTouchEvent(&press); EXPECT_TRUE(press.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StatePressed, + EXPECT_EQ(blink::WebTouchPoint::StatePressed, view_->touch_event_.touches[0].state); view_->OnTouchEvent(&move); EXPECT_TRUE(move.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StateMoved, + EXPECT_EQ(blink::WebTouchPoint::StateMoved, view_->touch_event_.touches[0].state); view_->OnTouchEvent(&release); EXPECT_TRUE(release.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchEnd, view_->touch_event_.type); EXPECT_EQ(0U, view_->touch_event_.touchesLength); // Now start a touch event, and remove the event-handlers before the release. view_->OnTouchEvent(&press); EXPECT_TRUE(press.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StatePressed, + EXPECT_EQ(blink::WebTouchPoint::StatePressed, view_->touch_event_.touches[0].state); widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false)); @@ -473,16 +473,16 @@ TEST_F(RenderWidgetHostViewAuraTest, TouchEventState) { base::Time::NowFromSystemTime() - base::Time()); view_->OnTouchEvent(&move2); EXPECT_FALSE(move2.handled()); - EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StateMoved, + EXPECT_EQ(blink::WebTouchPoint::StateMoved, view_->touch_event_.touches[0].state); ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), 0, base::Time::NowFromSystemTime() - base::Time()); view_->OnTouchEvent(&release2); EXPECT_FALSE(release2.handled()); - EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchEnd, view_->touch_event_.type); EXPECT_EQ(0U, view_->touch_event_.touchesLength); } @@ -510,30 +510,30 @@ TEST_F(RenderWidgetHostViewAuraTest, TouchEventSyncAsync) { view_->OnTouchEvent(&press); EXPECT_TRUE(press.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StatePressed, + EXPECT_EQ(blink::WebTouchPoint::StatePressed, view_->touch_event_.touches[0].state); view_->OnTouchEvent(&move); EXPECT_TRUE(move.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StateMoved, + EXPECT_EQ(blink::WebTouchPoint::StateMoved, view_->touch_event_.touches[0].state); // Send the same move event. Since the point hasn't moved, it won't affect the // queue. However, the view should consume the event. view_->OnTouchEvent(&move); EXPECT_TRUE(move.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_.type); EXPECT_EQ(1U, view_->touch_event_.touchesLength); - EXPECT_EQ(WebKit::WebTouchPoint::StateMoved, + EXPECT_EQ(blink::WebTouchPoint::StateMoved, view_->touch_event_.touches[0].state); view_->OnTouchEvent(&release); EXPECT_TRUE(release.stopped_propagation()); - EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type); + EXPECT_EQ(blink::WebInputEvent::TouchEnd, view_->touch_event_.type); EXPECT_EQ(0U, view_->touch_event_.touchesLength); } diff --git a/content/browser/renderer_host/render_widget_host_view_base.cc b/content/browser/renderer_host/render_widget_host_view_base.cc index 320e3e1..5ca099c 100644 --- a/content/browser/renderer_host/render_widget_host_view_base.cc +++ b/content/browser/renderer_host/render_widget_host_view_base.cc @@ -378,7 +378,7 @@ void RenderWidgetHostViewBase::DetachPluginsHelper(HWND parent) { #endif // OS_WIN RenderWidgetHostViewBase::RenderWidgetHostViewBase() - : popup_type_(WebKit::WebPopupTypeNone), + : popup_type_(blink::WebPopupTypeNone), mouse_locked_(false), showing_context_menu_(false), selection_text_offset_(0), @@ -446,12 +446,12 @@ bool RenderWidgetHostViewBase::IsMouseLocked() { } void RenderWidgetHostViewBase::UnhandledWheelEvent( - const WebKit::WebMouseWheelEvent& event) { + const blink::WebMouseWheelEvent& event) { // Most implementations don't need to do anything here. } InputEventAckState RenderWidgetHostViewBase::FilterInputEvent( - const WebKit::WebInputEvent& input_event) { + const blink::WebInputEvent& input_event) { // By default, input events are simply forwarded to the renderer. return INPUT_EVENT_ACK_STATE_NOT_CONSUMED; } @@ -467,11 +467,11 @@ void RenderWidgetHostViewBase::OnSetNeedsFlushInput() { void RenderWidgetHostViewBase::GestureEventAck(int gesture_event_type, InputEventAckState ack_result) {} -void RenderWidgetHostViewBase::SetPopupType(WebKit::WebPopupType popup_type) { +void RenderWidgetHostViewBase::SetPopupType(blink::WebPopupType popup_type) { popup_type_ = popup_type; } -WebKit::WebPopupType RenderWidgetHostViewBase::GetPopupType() { +blink::WebPopupType RenderWidgetHostViewBase::GetPopupType() { return popup_type_; } diff --git a/content/browser/renderer_host/render_widget_host_view_base.h b/content/browser/renderer_host/render_widget_host_view_base.h index 459afee..abe318f 100644 --- a/content/browser/renderer_host/render_widget_host_view_base.h +++ b/content/browser/renderer_host/render_widget_host_view_base.h @@ -58,15 +58,15 @@ class CONTENT_EXPORT RenderWidgetHostViewBase virtual string16 GetSelectedText() const OVERRIDE; virtual bool IsMouseLocked() OVERRIDE; virtual void UnhandledWheelEvent( - const WebKit::WebMouseWheelEvent& event) OVERRIDE; + const blink::WebMouseWheelEvent& event) OVERRIDE; virtual InputEventAckState FilterInputEvent( - const WebKit::WebInputEvent& input_event) OVERRIDE; + const blink::WebInputEvent& input_event) OVERRIDE; virtual void OnSetNeedsFlushInput() OVERRIDE; virtual void OnDidFlushInput() OVERRIDE; virtual void GestureEventAck(int gesture_event_type, InputEventAckState ack_result) OVERRIDE; - virtual void SetPopupType(WebKit::WebPopupType popup_type) OVERRIDE; - virtual WebKit::WebPopupType GetPopupType() OVERRIDE; + virtual void SetPopupType(blink::WebPopupType popup_type) OVERRIDE; + virtual blink::WebPopupType GetPopupType() OVERRIDE; virtual BrowserAccessibilityManager* GetBrowserAccessibilityManager() const OVERRIDE; virtual void ProcessAckedTouchEvent(const TouchEventWithLatencyInfo& touch, @@ -126,7 +126,7 @@ class CONTENT_EXPORT RenderWidgetHostViewBase // Whether this view is a popup and what kind of popup it is (select, // autofill...). - WebKit::WebPopupType popup_type_; + blink::WebPopupType popup_type_; // A custom background to paint behind the web content. This will be tiled // horizontally. Can be null, in which case we fall back to painting white. diff --git a/content/browser/renderer_host/render_widget_host_view_gtk.cc b/content/browser/renderer_host/render_widget_host_view_gtk.cc index 5e182a8..320b96f 100644 --- a/content/browser/renderer_host/render_widget_host_view_gtk.cc +++ b/content/browser/renderer_host/render_widget_host_view_gtk.cc @@ -50,8 +50,8 @@ #include "ui/gfx/text_elider.h" #include "webkit/common/cursors/webcursor_gtk_data.h" -using WebKit::WebMouseWheelEvent; -using WebKit::WebScreenInfo; +using blink::WebMouseWheelEvent; +using blink::WebScreenInfo; namespace content { namespace { @@ -94,7 +94,7 @@ GdkCursor* GetMozSpinningCursor() { return moz_spinning_cursor; } -bool MovedToPoint(const WebKit::WebMouseEvent& mouse_event, +bool MovedToPoint(const blink::WebMouseEvent& mouse_event, const gfx::Point& center) { return mouse_event.globalX == center.x() && mouse_event.globalY == center.y(); @@ -385,7 +385,7 @@ class RenderWidgetHostViewGtkWidget { host_view->ModifyEventForEdgeDragging(widget, event); - WebKit::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event); + blink::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event); if (host_view->mouse_locked_) { gfx::Point center = host_view->GetWidgetCenter(); @@ -435,7 +435,7 @@ class RenderWidgetHostViewGtkWidget { // additionally send this crossing event with the state indicating the // button is down, it causes problems with drag and drop in WebKit.) if (!(event->state & any_button_mask)) { - WebKit::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event); + blink::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event); host_view->ModifyEventMovementAndCoords(&mouse_event); // When crossing out and back into a render view the movement values // must represent the instantaneous movement of the mouse, not the jump @@ -993,11 +993,11 @@ void RenderWidgetHostViewGtk::OnDestroy(GtkWidget* widget) { } bool RenderWidgetHostViewGtk::NeedsInputGrab() { - return popup_type_ == WebKit::WebPopupTypeSelect; + return popup_type_ == blink::WebPopupTypeSelect; } bool RenderWidgetHostViewGtk::IsPopup() const { - return popup_type_ != WebKit::WebPopupTypeNone; + return popup_type_ != blink::WebPopupTypeNone; } void RenderWidgetHostViewGtk::DoSharedInit() { @@ -1450,7 +1450,7 @@ gfx::Point RenderWidgetHostViewGtk::GetWidgetCenter() { } void RenderWidgetHostViewGtk::ModifyEventMovementAndCoords( - WebKit::WebMouseEvent* event) { + blink::WebMouseEvent* event) { // Movement is computed by taking the difference of the new cursor position // and the previous. Under mouse lock the cursor will be warped back to the // center so that we are not limited by clipping boundaries. diff --git a/content/browser/renderer_host/render_widget_host_view_gtk.h b/content/browser/renderer_host/render_widget_host_view_gtk.h index 1f70b04..f256df7 100644 --- a/content/browser/renderer_host/render_widget_host_view_gtk.h +++ b/content/browser/renderer_host/render_widget_host_view_gtk.h @@ -124,7 +124,7 @@ class CONTENT_EXPORT RenderWidgetHostViewGtk bool has_horizontal_scrollbar) OVERRIDE; virtual void SetScrollOffsetPinning( bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE; - virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE; + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE; virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE; virtual void ResizeCompositingSurface(const gfx::Size&) OVERRIDE; @@ -149,7 +149,7 @@ class CONTENT_EXPORT RenderWidgetHostViewGtk // Mouse events always provide a movementX/Y which needs to be computed. // Also, mouse lock requires knowledge of last unlocked cursor coordinates. // State is stored on the host view to do this, and the mouse event modified. - void ModifyEventMovementAndCoords(WebKit::WebMouseEvent* event); + void ModifyEventMovementAndCoords(blink::WebMouseEvent* event); void Paint(const gfx::Rect&); diff --git a/content/browser/renderer_host/render_widget_host_view_guest.cc b/content/browser/renderer_host/render_widget_host_view_guest.cc index 87765b5..49c55fe 100644 --- a/content/browser/renderer_host/render_widget_host_view_guest.cc +++ b/content/browser/renderer_host/render_widget_host_view_guest.cc @@ -35,11 +35,11 @@ bool ShouldSendPinchGesture() { return pinch_allowed; } -WebKit::WebGestureEvent CreateFlingCancelEvent(double time_stamp) { - WebKit::WebGestureEvent gesture_event; +blink::WebGestureEvent CreateFlingCancelEvent(double time_stamp) { + blink::WebGestureEvent gesture_event; gesture_event.timeStampSeconds = time_stamp; - gesture_event.type = WebKit::WebGestureEvent::GestureFlingCancel; - gesture_event.sourceDevice = WebKit::WebGestureEvent::Touchscreen; + gesture_event.type = blink::WebGestureEvent::GestureFlingCancel; + gesture_event.sourceDevice = blink::WebGestureEvent::Touchscreen; return gesture_event; } @@ -398,7 +398,7 @@ void RenderWidgetHostViewGuest::UnlockMouse() { return platform_view_->UnlockMouse(); } -void RenderWidgetHostViewGuest::GetScreenInfo(WebKit::WebScreenInfo* results) { +void RenderWidgetHostViewGuest::GetScreenInfo(blink::WebScreenInfo* results) { RenderWidgetHostViewPort* embedder_view = RenderWidgetHostViewPort::FromRWHV( guest_->GetEmbedderRenderWidgetHostView()); @@ -525,8 +525,8 @@ void RenderWidgetHostViewGuest::DispatchCancelTouchEvent( if (!host_) return; - WebKit::WebTouchEvent cancel_event; - cancel_event.type = WebKit::WebInputEvent::TouchCancel; + blink::WebTouchEvent cancel_event; + cancel_event.type = blink::WebInputEvent::TouchCancel; cancel_event.timeStampSeconds = event->time_stamp().InSecondsF(); host_->ForwardTouchEventWithLatencyInfo(cancel_event, *event->latency()); } @@ -546,7 +546,7 @@ bool RenderWidgetHostViewGuest::ForwardGestureEventToRenderer( return true; } - WebKit::WebGestureEvent web_gesture = + blink::WebGestureEvent web_gesture = MakeWebGestureEventFromUIEvent(*gesture); const gfx::Point& client_point = gesture->location(); const gfx::Point& screen_point = gesture->location(); @@ -556,9 +556,9 @@ bool RenderWidgetHostViewGuest::ForwardGestureEventToRenderer( web_gesture.globalX = screen_point.x(); web_gesture.globalY = screen_point.y(); - if (web_gesture.type == WebKit::WebGestureEvent::Undefined) + if (web_gesture.type == blink::WebGestureEvent::Undefined) return false; - if (web_gesture.type == WebKit::WebGestureEvent::GestureTapDown) { + if (web_gesture.type == blink::WebGestureEvent::GestureTapDown) { host_->ForwardGestureEvent( CreateFlingCancelEvent(gesture->time_stamp().InSecondsF())); } diff --git a/content/browser/renderer_host/render_widget_host_view_guest.h b/content/browser/renderer_host/render_widget_host_view_guest.h index c050aaa..4832eae 100644 --- a/content/browser/renderer_host/render_widget_host_view_guest.h +++ b/content/browser/renderer_host/render_widget_host_view_guest.h @@ -141,7 +141,7 @@ class CONTENT_EXPORT RenderWidgetHostViewGuest #endif // defined(OS_WIN) || defined(USE_AURA) virtual bool LockMouse() OVERRIDE; virtual void UnlockMouse() OVERRIDE; - virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE; + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE; virtual void OnAccessibilityEvents( const std::vector<AccessibilityHostMsg_EventParams>& params) OVERRIDE; diff --git a/content/browser/renderer_host/render_widget_host_view_mac.h b/content/browser/renderer_host/render_widget_host_view_mac.h index da16bc2..93c0143 100644 --- a/content/browser/renderer_host/render_widget_host_view_mac.h +++ b/content/browser/renderer_host/render_widget_host_view_mac.h @@ -114,7 +114,7 @@ class RenderWidgetHostViewMacEditCommandHelper; string16 markedText_; // Underline information of the |markedText_|. - std::vector<WebKit::WebCompositionUnderline> underlines_; + std::vector<blink::WebCompositionUnderline> underlines_; // Indicates if doCommandBySelector method receives any edit command when // handling a key down event. @@ -304,7 +304,7 @@ class RenderWidgetHostViewMac : public RenderWidgetHostViewBase, virtual void AcceleratedSurfaceRelease() OVERRIDE; virtual bool HasAcceleratedSurface(const gfx::Size& desired_size) OVERRIDE; virtual void AboutToWaitForBackingStoreMsg() OVERRIDE; - virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE; + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE; virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE; @@ -315,7 +315,7 @@ class RenderWidgetHostViewMac : public RenderWidgetHostViewBase, virtual bool LockMouse() OVERRIDE; virtual void UnlockMouse() OVERRIDE; virtual void UnhandledWheelEvent( - const WebKit::WebMouseWheelEvent& event) OVERRIDE; + const blink::WebMouseWheelEvent& event) OVERRIDE; // IPC::Sender implementation. virtual bool Send(IPC::Message* message) OVERRIDE; @@ -326,7 +326,7 @@ class RenderWidgetHostViewMac : public RenderWidgetHostViewBase, virtual void ReleaseReferencesToSoftwareFrame() OVERRIDE; // Forwards the mouse event to the renderer. - void ForwardMouseEvent(const WebKit::WebMouseEvent& event); + void ForwardMouseEvent(const blink::WebMouseEvent& event); void KillSelf(); diff --git a/content/browser/renderer_host/render_widget_host_view_mac.mm b/content/browser/renderer_host/render_widget_host_view_mac.mm index 71dfb16..9082dd1 100644 --- a/content/browser/renderer_host/render_widget_host_view_mac.mm +++ b/content/browser/renderer_host/render_widget_host_view_mac.mm @@ -76,10 +76,10 @@ using content::RenderWidgetHostImpl; using content::RenderWidgetHostViewMac; using content::RenderWidgetHostViewMacEditCommandHelper; using content::TextInputClientMac; -using WebKit::WebInputEvent; -using WebKit::WebInputEventFactory; -using WebKit::WebMouseEvent; -using WebKit::WebMouseWheelEvent; +using blink::WebInputEvent; +using blink::WebInputEventFactory; +using blink::WebMouseEvent; +using blink::WebMouseWheelEvent; enum CoreAnimationStatus { CORE_ANIMATION_DISABLED, @@ -287,7 +287,7 @@ namespace { const size_t kMaxTooltipLength = 1024; // TODO(suzhe): Upstream this function. -WebKit::WebColor WebColorFromNSColor(NSColor *color) { +blink::WebColor WebColorFromNSColor(NSColor *color) { CGFloat r, g, b, a; [color getRed:&r green:&g blue:&b alpha:&a]; @@ -302,7 +302,7 @@ WebKit::WebColor WebColorFromNSColor(NSColor *color) { // third_party/WebKit/Source/WebKit/mac/WebView/WebHTMLView.mm void ExtractUnderlines( NSAttributedString* string, - std::vector<WebKit::WebCompositionUnderline>* underlines) { + std::vector<blink::WebCompositionUnderline>* underlines) { int length = [[string string] length]; int i = 0; while (i < length) { @@ -311,13 +311,13 @@ void ExtractUnderlines( longestEffectiveRange:&range inRange:NSMakeRange(i, length - i)]; if (NSNumber *style = [attrs objectForKey:NSUnderlineStyleAttributeName]) { - WebKit::WebColor color = SK_ColorBLACK; + blink::WebColor color = SK_ColorBLACK; if (NSColor *colorAttr = [attrs objectForKey:NSUnderlineColorAttributeName]) { color = WebColorFromNSColor( [colorAttr colorUsingColorSpaceName:NSDeviceRGBColorSpace]); } - underlines->push_back(WebKit::WebCompositionUnderline( + underlines->push_back(blink::WebCompositionUnderline( range.location, NSMaxRange(range), color, [style intValue] > 1)); } i = range.location + range.length; @@ -374,13 +374,13 @@ NSWindow* ApparentWindowForView(NSView* view) { return enclosing_window; } -WebKit::WebScreenInfo GetWebScreenInfo(NSView* view) { +blink::WebScreenInfo GetWebScreenInfo(NSView* view) { gfx::Display display = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(view); NSScreen* screen = [NSScreen deepestScreen]; - WebKit::WebScreenInfo results; + blink::WebScreenInfo results; results.deviceScaleFactor = static_cast<int>(display.device_scale_factor()); results.depth = NSBitsPerPixelFromDepth([screen depth]); @@ -407,7 +407,7 @@ RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget( // static void RenderWidgetHostViewPort::GetDefaultScreenInfo( - WebKit::WebScreenInfo* results) { + blink::WebScreenInfo* results) { *results = GetWebScreenInfo(NULL); } @@ -626,7 +626,7 @@ void RenderWidgetHostViewMac::InitAsChild( void RenderWidgetHostViewMac::InitAsPopup( RenderWidgetHostView* parent_host_view, const gfx::Rect& pos) { - bool activatable = popup_type_ == WebKit::WebPopupTypeNone; + bool activatable = popup_type_ == blink::WebPopupTypeNone; [cocoa_view_ setCloseOnDeactivate:YES]; [cocoa_view_ setCanBeKeyView:activatable ? YES : NO]; @@ -1139,7 +1139,7 @@ void RenderWidgetHostViewMac::SetShowingContextMenu(bool showing) { } bool RenderWidgetHostViewMac::IsPopup() const { - return popup_type_ != WebKit::WebPopupTypeNone; + return popup_type_ != blink::WebPopupTypeNone; } BackingStore* RenderWidgetHostViewMac::AllocBackingStore( @@ -1703,7 +1703,7 @@ void RenderWidgetHostViewMac::OnSwapCompositorFrame( void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() { } -void RenderWidgetHostViewMac::GetScreenInfo(WebKit::WebScreenInfo* results) { +void RenderWidgetHostViewMac::GetScreenInfo(blink::WebScreenInfo* results) { *results = GetWebScreenInfo(GetNativeView()); } @@ -1766,7 +1766,7 @@ void RenderWidgetHostViewMac::UnlockMouse() { } void RenderWidgetHostViewMac::UnhandledWheelEvent( - const WebKit::WebMouseWheelEvent& event) { + const blink::WebMouseWheelEvent& event) { // Only record a wheel event as unhandled if JavaScript handlers got a chance // to see it (no-op wheel events are ignored by the event dispatcher) if (event.deltaX || event.deltaY) @@ -2413,7 +2413,7 @@ void RenderWidgetHostViewMac::FrameSwapped() { // So before sending the real key down event, we need to send a fake key up // event to balance it. NativeWebKeyboardEvent fakeEvent = event; - fakeEvent.type = WebKit::WebInputEvent::KeyUp; + fakeEvent.type = blink::WebInputEvent::KeyUp; fakeEvent.skip_in_browser = true; widgetHost->ForwardKeyboardEvent(fakeEvent); // Not checking |renderWidgetHostView_->render_widget_host_| here because @@ -2439,7 +2439,7 @@ void RenderWidgetHostViewMac::FrameSwapped() { if (!textInserted && textToBeInserted_.length() == 1) { // If a single character was inserted, then we just send it as a keypress // event. - event.type = WebKit::WebInputEvent::Char; + event.type = blink::WebInputEvent::Char; event.text[0] = textToBeInserted_[0]; event.text[1] = 0; event.skip_in_browser = true; @@ -2451,7 +2451,7 @@ void RenderWidgetHostViewMac::FrameSwapped() { // We don't get insertText: calls if ctrl or cmd is down, or the key event // generates an insert command. So synthesize a keypress event for these // cases, unless the key event generated any other command. - event.type = WebKit::WebInputEvent::Char; + event.type = blink::WebInputEvent::Char; event.skip_in_browser = true; widgetHost->ForwardKeyboardEvent(event); } @@ -3538,7 +3538,7 @@ extern NSString *NSTextInputReplacementRangeAttributeName; } else { // Use a thin black underline by default. underlines_.push_back( - WebKit::WebCompositionUnderline(0, length, SK_ColorBLACK, false)); + blink::WebCompositionUnderline(0, length, SK_ColorBLACK, false)); } // If we are handling a key down event, then SetComposition() will be diff --git a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm index 7a152d1..ad37bfd 100644 --- a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm +++ b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm @@ -329,7 +329,7 @@ TEST_F(RenderWidgetHostViewMacTest, GetFirstRectForCharacterRangeCaretCase) { NSRange actual_range; rwhv_mac_->SelectionChanged(kDummyString, kDummyOffset, caret_range); params.anchor_rect = params.focus_rect = caret_rect; - params.anchor_dir = params.focus_dir = WebKit::WebTextDirectionLeftToRight; + params.anchor_dir = params.focus_dir = blink::WebTextDirectionLeftToRight; rwhv_mac_->SelectionBoundsChanged(params); EXPECT_TRUE(rwhv_mac_->GetCachedFirstRectForCharacterRange( caret_range.ToNSRange(), @@ -711,7 +711,7 @@ TEST_F(RenderWidgetHostViewMacTest, ScrollWheelEndEventDelivery) { // Send an ACK for the first wheel event, so that the queue will be flushed. scoped_ptr<IPC::Message> response(new InputHostMsg_HandleInputEvent_ACK( - 0, WebKit::WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED, + 0, blink::WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED, ui::LatencyInfo())); host->OnMessageReceived(*response); @@ -756,7 +756,7 @@ TEST_F(RenderWidgetHostViewMacTest, IgnoreEmptyUnhandledWheelEvent) { // Indicate that the wheel event was unhandled. scoped_ptr<IPC::Message> response1(new InputHostMsg_HandleInputEvent_ACK(0, - WebKit::WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_NOT_CONSUMED, + blink::WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ui::LatencyInfo())); host->OnMessageReceived(*response1); @@ -771,7 +771,7 @@ TEST_F(RenderWidgetHostViewMacTest, IgnoreEmptyUnhandledWheelEvent) { // Indicate that the wheel event was also unhandled. scoped_ptr<IPC::Message> response2(new InputHostMsg_HandleInputEvent_ACK(0, - WebKit::WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_NOT_CONSUMED, + blink::WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ui::LatencyInfo())); host->OnMessageReceived(*response2); diff --git a/content/browser/renderer_host/render_widget_host_view_win.cc b/content/browser/renderer_host/render_widget_host_view_win.cc index 97ec948..f0b25b3 100644 --- a/content/browser/renderer_host/render_widget_host_view_win.cc +++ b/content/browser/renderer_host/render_widget_host_view_win.cc @@ -83,9 +83,9 @@ using base::TimeDelta; using base::TimeTicks; using ui::ViewProp; -using WebKit::WebInputEvent; -using WebKit::WebMouseEvent; -using WebKit::WebTextDirection; +using blink::WebInputEvent; +using blink::WebMouseEvent; +using blink::WebTextDirection; namespace content { namespace { @@ -202,10 +202,10 @@ bool DecodeScrollGesture(const GESTUREINFO& gi, return true; } -WebKit::WebMouseWheelEvent MakeFakeScrollWheelEvent(HWND hwnd, +blink::WebMouseWheelEvent MakeFakeScrollWheelEvent(HWND hwnd, POINT start, POINT delta) { - WebKit::WebMouseWheelEvent result; + blink::WebMouseWheelEvent result; result.type = WebInputEvent::MouseWheel; result.timeStampSeconds = ::GetMessageTime() / 1000.0; result.button = WebMouseEvent::ButtonNone; @@ -236,17 +236,17 @@ inline void SetTouchType(TOUCHINPUT* point, int type) { point->dwFlags = (point->dwFlags & kTouchMask) | type; } -ui::EventType ConvertToUIEvent(WebKit::WebTouchPoint::State t) { +ui::EventType ConvertToUIEvent(blink::WebTouchPoint::State t) { switch (t) { - case WebKit::WebTouchPoint::StatePressed: + case blink::WebTouchPoint::StatePressed: return ui::ET_TOUCH_PRESSED; - case WebKit::WebTouchPoint::StateMoved: + case blink::WebTouchPoint::StateMoved: return ui::ET_TOUCH_MOVED; - case WebKit::WebTouchPoint::StateStationary: + case blink::WebTouchPoint::StateStationary: return ui::ET_TOUCH_STATIONARY; - case WebKit::WebTouchPoint::StateReleased: + case blink::WebTouchPoint::StateReleased: return ui::ET_TOUCH_RELEASED; - case WebKit::WebTouchPoint::StateCancelled: + case blink::WebTouchPoint::StateCancelled: return ui::ET_TOUCH_CANCELLED; default: DCHECK(false) << "Unexpected ui type. " << t; @@ -255,9 +255,9 @@ ui::EventType ConvertToUIEvent(WebKit::WebTouchPoint::State t) { } // Creates a WebGestureEvent corresponding to the given |gesture| -WebKit::WebGestureEvent CreateWebGestureEvent(HWND hwnd, +blink::WebGestureEvent CreateWebGestureEvent(HWND hwnd, const ui::GestureEvent& gesture) { - WebKit::WebGestureEvent gesture_event = + blink::WebGestureEvent gesture_event = MakeWebGestureEventFromUIEvent(gesture); POINT client_point = gesture.location().ToPOINT(); @@ -272,17 +272,17 @@ WebKit::WebGestureEvent CreateWebGestureEvent(HWND hwnd, return gesture_event; } -WebKit::WebGestureEvent CreateFlingCancelEvent(double time_stamp) { - WebKit::WebGestureEvent gesture_event; +blink::WebGestureEvent CreateFlingCancelEvent(double time_stamp) { + blink::WebGestureEvent gesture_event; gesture_event.timeStampSeconds = time_stamp; - gesture_event.type = WebKit::WebGestureEvent::GestureFlingCancel; - gesture_event.sourceDevice = WebKit::WebGestureEvent::Touchscreen; + gesture_event.type = blink::WebGestureEvent::GestureFlingCancel; + gesture_event.sourceDevice = blink::WebGestureEvent::Touchscreen; return gesture_event; } class TouchEventFromWebTouchPoint : public ui::TouchEvent { public: - TouchEventFromWebTouchPoint(const WebKit::WebTouchPoint& touch_point, + TouchEventFromWebTouchPoint(const blink::WebTouchPoint& touch_point, base::TimeDelta& timestamp) : ui::TouchEvent(ConvertToUIEvent(touch_point.state), touch_point.position, @@ -307,7 +307,7 @@ bool ShouldSendPinchGesture() { } void GetScreenInfoForWindow(gfx::NativeViewId id, - WebKit::WebScreenInfo* results) { + blink::WebScreenInfo* results) { HWND window = gfx::NativeViewFromId(id); HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTOPRIMARY); @@ -322,7 +322,7 @@ void GetScreenInfoForWindow(gfx::NativeViewId id, dev_mode.dmDriverExtra = 0; EnumDisplaySettings(monitor_info.szDevice, ENUM_CURRENT_SETTINGS, &dev_mode); - WebKit::WebScreenInfo screen_info; + blink::WebScreenInfo screen_info; screen_info.depth = dev_mode.dmBitsPerPel; screen_info.depthPerComponent = 8; screen_info.deviceScaleFactor = gfx::win::GetDeviceScaleFactor(); @@ -351,18 +351,18 @@ class WebTouchState { bool ReleaseTouchPoints(); // The contained WebTouchEvent. - const WebKit::WebTouchEvent& touch_event() { return touch_event_; } + const blink::WebTouchEvent& touch_event() { return touch_event_; } // Returns if any touches are modified in the event. bool is_changed() { return touch_event_.changedTouchesLength != 0; } private: // Adds a touch point or returns NULL if there's not enough space. - WebKit::WebTouchPoint* AddTouchPoint(TOUCHINPUT* touch_input); + blink::WebTouchPoint* AddTouchPoint(TOUCHINPUT* touch_input); // Copy details from a TOUCHINPUT to an existing WebTouchPoint, returning // true if the resulting point is a stationary move. - bool UpdateTouchPoint(WebKit::WebTouchPoint* touch_point, + bool UpdateTouchPoint(blink::WebTouchPoint* touch_point, TOUCHINPUT* touch_input); // Find (or create) a mapping for _os_touch_id_. @@ -371,7 +371,7 @@ class WebTouchState { // Remove any mappings that are no longer in use. void RemoveExpiredMappings(); - WebKit::WebTouchEvent touch_event_; + blink::WebTouchEvent touch_event_; const RenderWidgetHostViewWin* const window_; ui::SequentialIDGenerator id_generator_; @@ -595,7 +595,7 @@ void RenderWidgetHostViewWin::CleanupCompositorWindow() { bool RenderWidgetHostViewWin::IsActivatable() const { // Popups should not be activated. - return popup_type_ == WebKit::WebPopupTypeNone; + return popup_type_ == blink::WebPopupTypeNone; } void RenderWidgetHostViewWin::Focus() { @@ -962,9 +962,9 @@ void RenderWidgetHostViewWin::DispatchCancelTouchEvent( !render_widget_host_->ShouldForwardTouchEvent()) { return; } - DCHECK(event->type() == WebKit::WebInputEvent::TouchCancel); - WebKit::WebTouchEvent cancel_event; - cancel_event.type = WebKit::WebInputEvent::TouchCancel; + DCHECK(event->type() == blink::WebInputEvent::TouchCancel); + blink::WebTouchEvent cancel_event; + cancel_event.type = blink::WebInputEvent::TouchCancel; cancel_event.timeStampSeconds = event->time_stamp().InSecondsF(); render_widget_host_->ForwardTouchEventWithLatencyInfo( cancel_event, *event->latency()); @@ -987,12 +987,12 @@ void RenderWidgetHostViewWin::SetCompositionText( if (!render_widget_host_) return; // 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. COMPILE_ASSERT(sizeof(ui::CompositionUnderline) == - sizeof(WebKit::WebCompositionUnderline), + sizeof(blink::WebCompositionUnderline), ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff); - 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); render_widget_host_->ImeSetComposition(composition.text, underlines, composition.selection.end(), @@ -1664,9 +1664,9 @@ LRESULT RenderWidgetHostViewWin::OnImeComposition( imm32_manager_->UpdateImeWindow(m_hWnd); // 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. COMPILE_ASSERT(sizeof(ui::CompositionUnderline) == - sizeof(WebKit::WebCompositionUnderline), + sizeof(blink::WebCompositionUnderline), ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff); // Retrieve the result string and its attributes of the ongoing composition @@ -1690,8 +1690,8 @@ LRESULT RenderWidgetHostViewWin::OnImeComposition( // 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); render_widget_host_->ImeSetComposition( composition.text, underlines, @@ -1928,8 +1928,8 @@ LRESULT RenderWidgetHostViewWin::OnKeyEvent(UINT message, WPARAM wparam, if (ui::IMM32Manager::IsCtrlShiftPressed(&dir)) { render_widget_host_->UpdateTextDirection( dir == base::i18n::RIGHT_TO_LEFT ? - WebKit::WebTextDirectionRightToLeft : - WebKit::WebTextDirectionLeftToRight); + blink::WebTextDirectionRightToLeft : + blink::WebTextDirectionLeftToRight); } } else if (wparam != VK_CONTROL) { // Bug 9762: http://crbug.com/9762 A user pressed a key except shift @@ -2006,7 +2006,7 @@ LRESULT RenderWidgetHostViewWin::OnWheelEvent(UINT message, WPARAM wparam, } if (render_widget_host_) { - WebKit::WebMouseWheelEvent wheel_event = + blink::WebMouseWheelEvent wheel_event = WebMouseWheelEventBuilder::Build(m_hWnd, message, wparam, lparam); float scale = gfx::win::GetDeviceScaleFactor(); wheel_event.x /= scale; @@ -2032,14 +2032,14 @@ size_t WebTouchState::UpdateTouchPoints( // and alter/add any touchpoints (from the touch input buffer) that we can // coalesce into a single message. The return value is the number of consumed // input message. - WebKit::WebTouchPoint* point = touch_event_.touches; - WebKit::WebTouchPoint* end = point + touch_event_.touchesLength; + blink::WebTouchPoint* point = touch_event_.touches; + blink::WebTouchPoint* end = point + touch_event_.touchesLength; while (point < end) { - if (point->state == WebKit::WebTouchPoint::StateReleased) { + if (point->state == blink::WebTouchPoint::StateReleased) { *point = *(--end); --touch_event_.touchesLength; } else { - point->state = WebKit::WebTouchPoint::StateStationary; + point->state = blink::WebTouchPoint::StateStationary; point++; } } @@ -2052,7 +2052,7 @@ size_t WebTouchState::UpdateTouchPoints( for (size_t i = 0; i < count; ++i) { unsigned int mapped_id = GetMappedTouch(points[i].dwID); - WebKit::WebTouchPoint* point = NULL; + blink::WebTouchPoint* point = NULL; for (unsigned j = 0; j < touch_event_.touchesLength; ++j) { if (static_cast<DWORD>(touch_event_.touches[j].id) == mapped_id) { point = &touch_event_.touches[j]; @@ -2076,26 +2076,26 @@ size_t WebTouchState::UpdateTouchPoints( case TOUCHEVENTF_DOWN: { if (!(point = AddTouchPoint(&points[i]))) continue; - touch_event_.type = WebKit::WebInputEvent::TouchStart; + touch_event_.type = blink::WebInputEvent::TouchStart; break; } case TOUCHEVENTF_UP: { if (!point) // Just throw away a stray up. continue; - point->state = WebKit::WebTouchPoint::StateReleased; + point->state = blink::WebTouchPoint::StateReleased; UpdateTouchPoint(point, &points[i]); - touch_event_.type = WebKit::WebInputEvent::TouchEnd; + touch_event_.type = blink::WebInputEvent::TouchEnd; break; } case TOUCHEVENTF_MOVE: { if (point) { - point->state = WebKit::WebTouchPoint::StateMoved; + point->state = blink::WebTouchPoint::StateMoved; // Don't update the message if the point didn't really move. if (UpdateTouchPoint(point, &points[i])) continue; - touch_event_.type = WebKit::WebInputEvent::TouchMove; + touch_event_.type = blink::WebInputEvent::TouchMove; } else if (touch_event_.changedTouchesLength) { RemoveExpiredMappings(); // Can't add a point if we're already handling move events. @@ -2106,7 +2106,7 @@ size_t WebTouchState::UpdateTouchPoints( continue; last_type = TOUCHEVENTF_DOWN; SetTouchType(&points[i], TOUCHEVENTF_DOWN); - touch_event_.type = WebKit::WebInputEvent::TouchStart; + touch_event_.type = blink::WebInputEvent::TouchStart; } break; } @@ -2123,10 +2123,10 @@ size_t WebTouchState::UpdateTouchPoints( } void WebTouchState::RemoveExpiredMappings() { - WebKit::WebTouchPoint* point = touch_event_.touches; - WebKit::WebTouchPoint* end = point + touch_event_.touchesLength; + blink::WebTouchPoint* point = touch_event_.touches; + blink::WebTouchPoint* end = point + touch_event_.touchesLength; for (; point < end; ++point) { - if (point->state == WebKit::WebTouchPoint::StateReleased) + if (point->state == blink::WebTouchPoint::StateReleased) id_generator_.ReleaseGeneratedID(point->id); } } @@ -2136,34 +2136,34 @@ bool WebTouchState::ReleaseTouchPoints() { if (touch_event_.touchesLength == 0) return false; // Mark every active touchpoint as released. - touch_event_.type = WebKit::WebInputEvent::TouchEnd; + touch_event_.type = blink::WebInputEvent::TouchEnd; touch_event_.changedTouchesLength = touch_event_.touchesLength; for (unsigned int i = 0; i < touch_event_.touchesLength; ++i) { - touch_event_.touches[i].state = WebKit::WebTouchPoint::StateReleased; + touch_event_.touches[i].state = blink::WebTouchPoint::StateReleased; touch_event_.changedTouches[i].state = - WebKit::WebTouchPoint::StateReleased; + blink::WebTouchPoint::StateReleased; } return true; } -WebKit::WebTouchPoint* WebTouchState::AddTouchPoint( +blink::WebTouchPoint* WebTouchState::AddTouchPoint( TOUCHINPUT* touch_input) { DCHECK(touch_event_.touchesLength < - WebKit::WebTouchEvent::touchesLengthCap); + blink::WebTouchEvent::touchesLengthCap); if (touch_event_.touchesLength >= - WebKit::WebTouchEvent::touchesLengthCap) + blink::WebTouchEvent::touchesLengthCap) return NULL; - WebKit::WebTouchPoint* point = + blink::WebTouchPoint* point = &touch_event_.touches[touch_event_.touchesLength++]; - point->state = WebKit::WebTouchPoint::StatePressed; + point->state = blink::WebTouchPoint::StatePressed; point->id = GetMappedTouch(touch_input->dwID); UpdateTouchPoint(point, touch_input); return point; } bool WebTouchState::UpdateTouchPoint( - WebKit::WebTouchPoint* touch_point, + blink::WebTouchPoint* touch_point, TOUCHINPUT* touch_input) { CPoint coordinates( TOUCH_COORD_TO_PIXEL(touch_input->x) / @@ -2188,7 +2188,7 @@ bool WebTouchState::UpdateTouchPoint( touch_point->screenPosition.y == coordinates.y && touch_point->radiusX == radius_x && touch_point->radiusY == radius_y) { - touch_point->state = WebKit::WebTouchPoint::StateStationary; + touch_point->state = blink::WebTouchPoint::StateStationary; return true; } @@ -2223,8 +2223,8 @@ LRESULT RenderWidgetHostViewWin::OnTouchEvent(UINT message, WPARAM wparam, // TODO(jschuh): Add support for an arbitrary number of touchpoints. size_t total = std::min(static_cast<int>(LOWORD(wparam)), - static_cast<int>(WebKit::WebTouchEvent::touchesLengthCap)); - TOUCHINPUT points[WebKit::WebTouchEvent::touchesLengthCap]; + static_cast<int>(blink::WebTouchEvent::touchesLengthCap)); + TOUCHINPUT points[blink::WebTouchEvent::touchesLengthCap]; if (!total || !ui::GetTouchInputInfoWrapper((HTOUCHINPUT)lparam, total, points, sizeof(TOUCHINPUT))) { @@ -2252,7 +2252,7 @@ LRESULT RenderWidgetHostViewWin::OnTouchEvent(UINT message, WPARAM wparam, render_widget_host_->ForwardTouchEventWithLatencyInfo( touch_state_->touch_event(), ui::LatencyInfo()); } else { - const WebKit::WebTouchEvent& touch_event = touch_state_->touch_event(); + const blink::WebTouchEvent& touch_event = touch_state_->touch_event(); base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds( touch_event.timeStampSeconds * 1000); for (size_t i = 0; i < touch_event.touchesLength; ++i) { @@ -2483,7 +2483,7 @@ void RenderWidgetHostViewWin::AcceleratedPaint(HDC dc) { accelerated_surface_->Present(dc); } -void RenderWidgetHostViewWin::GetScreenInfo(WebKit::WebScreenInfo* results) { +void RenderWidgetHostViewWin::GetScreenInfo(blink::WebScreenInfo* results) { GetScreenInfoForWindow(GetNativeViewId(), results); } @@ -2875,10 +2875,10 @@ bool RenderWidgetHostViewWin::ForwardGestureEventToRenderer( return true; } - WebKit::WebGestureEvent web_gesture = CreateWebGestureEvent(m_hWnd, *gesture); - if (web_gesture.type == WebKit::WebGestureEvent::Undefined) + blink::WebGestureEvent web_gesture = CreateWebGestureEvent(m_hWnd, *gesture); + if (web_gesture.type == blink::WebGestureEvent::Undefined) return false; - if (web_gesture.type == WebKit::WebGestureEvent::GestureTapDown) { + if (web_gesture.type == blink::WebGestureEvent::GestureTapDown) { render_widget_host_->ForwardGestureEvent( CreateFlingCancelEvent(gesture->time_stamp().InSecondsF())); } @@ -3204,7 +3204,7 @@ RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget( // static void RenderWidgetHostViewPort::GetDefaultScreenInfo( - WebKit::WebScreenInfo* results) { + blink::WebScreenInfo* results) { GetScreenInfoForWindow(0, results); } diff --git a/content/browser/renderer_host/render_widget_host_view_win.h b/content/browser/renderer_host/render_widget_host_view_win.h index fc48414..d6540b3 100644 --- a/content/browser/renderer_host/render_widget_host_view_win.h +++ b/content/browser/renderer_host/render_widget_host_view_win.h @@ -49,7 +49,7 @@ class IMM32Manager; class ViewProp; } -namespace WebKit { +namespace blink { struct WebScreenInfo; } @@ -221,7 +221,7 @@ class RenderWidgetHostViewWin bool has_horizontal_scrollbar) OVERRIDE; virtual void SetScrollOffsetPinning( bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE; - virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE; + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE; virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE; virtual void ResizeCompositingSurface(const gfx::Size&) OVERRIDE; diff --git a/content/browser/renderer_host/test_render_view_host.cc b/content/browser/renderer_host/test_render_view_host.cc index d89f353..3100326 100644 --- a/content/browser/renderer_host/test_render_view_host.cc +++ b/content/browser/renderer_host/test_render_view_host.cc @@ -370,7 +370,7 @@ void TestRenderViewHost::SimulateWasShown() { void TestRenderViewHost::TestOnStartDragging( const DropData& drop_data) { - WebKit::WebDragOperationsMask drag_operation = WebKit::WebDragOperationEvery; + blink::WebDragOperationsMask drag_operation = blink::WebDragOperationEvery; DragEventSourceInfo event_info; OnStartDragging(drop_data, drag_operation, SkBitmap(), gfx::Vector2d(), event_info); diff --git a/content/browser/renderer_host/test_render_view_host.h b/content/browser/renderer_host/test_render_view_host.h index 5abed25..71cb18d 100644 --- a/content/browser/renderer_host/test_render_view_host.h +++ b/content/browser/renderer_host/test_render_view_host.h @@ -153,7 +153,7 @@ class TestRenderWidgetHostView : public RenderWidgetHostViewBase { #elif defined(OS_WIN) && !defined(USE_AURA) virtual void WillWmDestroy() OVERRIDE; #endif - virtual void GetScreenInfo(WebKit::WebScreenInfo* results) OVERRIDE {} + virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE {} virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE; virtual void SetHasHorizontalScrollbar( bool has_horizontal_scrollbar) OVERRIDE { } diff --git a/content/browser/renderer_host/ui_events_helper.cc b/content/browser/renderer_host/ui_events_helper.cc index d1fbcfa..1dc312d 100644 --- a/content/browser/renderer_host/ui_events_helper.cc +++ b/content/browser/renderer_host/ui_events_helper.cc @@ -13,39 +13,39 @@ namespace { int WebModifiersToUIFlags(int modifiers) { int flags = ui::EF_NONE; - if (modifiers & WebKit::WebInputEvent::ShiftKey) + if (modifiers & blink::WebInputEvent::ShiftKey) flags |= ui::EF_SHIFT_DOWN; - if (modifiers & WebKit::WebInputEvent::ControlKey) + if (modifiers & blink::WebInputEvent::ControlKey) flags |= ui::EF_CONTROL_DOWN; - if (modifiers & WebKit::WebInputEvent::AltKey) + if (modifiers & blink::WebInputEvent::AltKey) flags |= ui::EF_ALT_DOWN; - if (modifiers & WebKit::WebInputEvent::LeftButtonDown) + if (modifiers & blink::WebInputEvent::LeftButtonDown) flags |= ui::EF_LEFT_MOUSE_BUTTON; - if (modifiers & WebKit::WebInputEvent::RightButtonDown) + if (modifiers & blink::WebInputEvent::RightButtonDown) flags |= ui::EF_RIGHT_MOUSE_BUTTON; - if (modifiers & WebKit::WebInputEvent::MiddleButtonDown) + if (modifiers & blink::WebInputEvent::MiddleButtonDown) flags |= ui::EF_MIDDLE_MOUSE_BUTTON; - if (modifiers & WebKit::WebInputEvent::CapsLockOn) + if (modifiers & blink::WebInputEvent::CapsLockOn) flags |= ui::EF_CAPS_LOCK_DOWN; return flags; } ui::EventType WebTouchPointStateToEventType( - WebKit::WebTouchPoint::State state) { + blink::WebTouchPoint::State state) { switch (state) { - case WebKit::WebTouchPoint::StateReleased: + case blink::WebTouchPoint::StateReleased: return ui::ET_TOUCH_RELEASED; - case WebKit::WebTouchPoint::StatePressed: + case blink::WebTouchPoint::StatePressed: return ui::ET_TOUCH_PRESSED; - case WebKit::WebTouchPoint::StateMoved: + case blink::WebTouchPoint::StateMoved: return ui::ET_TOUCH_MOVED; - case WebKit::WebTouchPoint::StateCancelled: + case blink::WebTouchPoint::StateCancelled: return ui::ET_TOUCH_CANCELLED; default: @@ -53,35 +53,35 @@ ui::EventType WebTouchPointStateToEventType( } } -WebKit::WebTouchPoint::State TouchPointStateFromEvent( +blink::WebTouchPoint::State TouchPointStateFromEvent( const ui::TouchEvent& event) { switch (event.type()) { case ui::ET_TOUCH_PRESSED: - return WebKit::WebTouchPoint::StatePressed; + return blink::WebTouchPoint::StatePressed; case ui::ET_TOUCH_RELEASED: - return WebKit::WebTouchPoint::StateReleased; + return blink::WebTouchPoint::StateReleased; case ui::ET_TOUCH_MOVED: - return WebKit::WebTouchPoint::StateMoved; + return blink::WebTouchPoint::StateMoved; case ui::ET_TOUCH_CANCELLED: - return WebKit::WebTouchPoint::StateCancelled; + return blink::WebTouchPoint::StateCancelled; default: - return WebKit::WebTouchPoint::StateUndefined; + return blink::WebTouchPoint::StateUndefined; } } -WebKit::WebInputEvent::Type TouchEventTypeFromEvent( +blink::WebInputEvent::Type TouchEventTypeFromEvent( const ui::TouchEvent& event) { switch (event.type()) { case ui::ET_TOUCH_PRESSED: - return WebKit::WebInputEvent::TouchStart; + return blink::WebInputEvent::TouchStart; case ui::ET_TOUCH_RELEASED: - return WebKit::WebInputEvent::TouchEnd; + return blink::WebInputEvent::TouchEnd; case ui::ET_TOUCH_MOVED: - return WebKit::WebInputEvent::TouchMove; + return blink::WebInputEvent::TouchMove; case ui::ET_TOUCH_CANCELLED: - return WebKit::WebInputEvent::TouchCancel; + return blink::WebInputEvent::TouchCancel; default: - return WebKit::WebInputEvent::Undefined; + return blink::WebInputEvent::Undefined; } } @@ -93,19 +93,19 @@ bool MakeUITouchEventsFromWebTouchEvents( const TouchEventWithLatencyInfo& touch_with_latency, ScopedVector<ui::TouchEvent>* list, TouchEventCoordinateSystem coordinate_system) { - const WebKit::WebTouchEvent& touch = touch_with_latency.event; + const blink::WebTouchEvent& touch = touch_with_latency.event; ui::EventType type = ui::ET_UNKNOWN; switch (touch.type) { - case WebKit::WebInputEvent::TouchStart: + case blink::WebInputEvent::TouchStart: type = ui::ET_TOUCH_PRESSED; break; - case WebKit::WebInputEvent::TouchEnd: + case blink::WebInputEvent::TouchEnd: type = ui::ET_TOUCH_RELEASED; break; - case WebKit::WebInputEvent::TouchMove: + case blink::WebInputEvent::TouchMove: type = ui::ET_TOUCH_MOVED; break; - case WebKit::WebInputEvent::TouchCancel: + case blink::WebInputEvent::TouchCancel: type = ui::ET_TOUCH_CANCELLED; break; default: @@ -117,7 +117,7 @@ bool MakeUITouchEventsFromWebTouchEvents( base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds( static_cast<int64>(touch.timeStampSeconds * 1000000)); for (unsigned i = 0; i < touch.touchesLength; ++i) { - const WebKit::WebTouchPoint& point = touch.touches[i]; + const blink::WebTouchPoint& point = touch.touches[i]; if (WebTouchPointStateToEventType(point.state) != type) continue; // In aura, the touch-event needs to be in the screen coordinate, since the @@ -148,79 +148,79 @@ bool MakeUITouchEventsFromWebTouchEvents( return true; } -WebKit::WebGestureEvent MakeWebGestureEventFromUIEvent( +blink::WebGestureEvent MakeWebGestureEventFromUIEvent( const ui::GestureEvent& event) { - WebKit::WebGestureEvent gesture_event; + blink::WebGestureEvent gesture_event; switch (event.type()) { case ui::ET_GESTURE_TAP: - gesture_event.type = WebKit::WebInputEvent::GestureTap; + gesture_event.type = blink::WebInputEvent::GestureTap; gesture_event.data.tap.tapCount = event.details().tap_count(); gesture_event.data.tap.width = event.details().bounding_box().width(); gesture_event.data.tap.height = event.details().bounding_box().height(); break; case ui::ET_GESTURE_TAP_DOWN: - gesture_event.type = WebKit::WebInputEvent::GestureTapDown; + gesture_event.type = blink::WebInputEvent::GestureTapDown; gesture_event.data.tapDown.width = event.details().bounding_box().width(); gesture_event.data.tapDown.height = event.details().bounding_box().height(); break; case ui::ET_GESTURE_SHOW_PRESS: - gesture_event.type = WebKit::WebInputEvent::GestureShowPress; + gesture_event.type = blink::WebInputEvent::GestureShowPress; gesture_event.data.showPress.width = event.details().bounding_box().width(); gesture_event.data.showPress.height = event.details().bounding_box().height(); break; case ui::ET_GESTURE_TAP_CANCEL: - gesture_event.type = WebKit::WebInputEvent::GestureTapCancel; + gesture_event.type = blink::WebInputEvent::GestureTapCancel; break; case ui::ET_GESTURE_SCROLL_BEGIN: - gesture_event.type = WebKit::WebInputEvent::GestureScrollBegin; + gesture_event.type = blink::WebInputEvent::GestureScrollBegin; break; case ui::ET_GESTURE_SCROLL_UPDATE: - gesture_event.type = WebKit::WebInputEvent::GestureScrollUpdate; + gesture_event.type = blink::WebInputEvent::GestureScrollUpdate; gesture_event.data.scrollUpdate.deltaX = event.details().scroll_x(); gesture_event.data.scrollUpdate.deltaY = event.details().scroll_y(); break; case ui::ET_GESTURE_SCROLL_END: - gesture_event.type = WebKit::WebInputEvent::GestureScrollEnd; + gesture_event.type = blink::WebInputEvent::GestureScrollEnd; break; case ui::ET_GESTURE_PINCH_BEGIN: - gesture_event.type = WebKit::WebInputEvent::GesturePinchBegin; + gesture_event.type = blink::WebInputEvent::GesturePinchBegin; break; case ui::ET_GESTURE_PINCH_UPDATE: - gesture_event.type = WebKit::WebInputEvent::GesturePinchUpdate; + gesture_event.type = blink::WebInputEvent::GesturePinchUpdate; gesture_event.data.pinchUpdate.scale = event.details().scale(); break; case ui::ET_GESTURE_PINCH_END: - gesture_event.type = WebKit::WebInputEvent::GesturePinchEnd; + gesture_event.type = blink::WebInputEvent::GesturePinchEnd; break; case ui::ET_SCROLL_FLING_START: - gesture_event.type = WebKit::WebInputEvent::GestureFlingStart; + gesture_event.type = blink::WebInputEvent::GestureFlingStart; gesture_event.data.flingStart.velocityX = event.details().velocity_x(); gesture_event.data.flingStart.velocityY = event.details().velocity_y(); break; case ui::ET_SCROLL_FLING_CANCEL: - gesture_event.type = WebKit::WebInputEvent::GestureFlingCancel; + gesture_event.type = blink::WebInputEvent::GestureFlingCancel; break; case ui::ET_GESTURE_LONG_PRESS: - gesture_event.type = WebKit::WebInputEvent::GestureLongPress; + gesture_event.type = blink::WebInputEvent::GestureLongPress; gesture_event.data.longPress.width = event.details().bounding_box().width(); gesture_event.data.longPress.height = event.details().bounding_box().height(); break; case ui::ET_GESTURE_LONG_TAP: - gesture_event.type = WebKit::WebInputEvent::GestureLongTap; + gesture_event.type = blink::WebInputEvent::GestureLongTap; gesture_event.data.longPress.width = event.details().bounding_box().width(); gesture_event.data.longPress.height = event.details().bounding_box().height(); break; case ui::ET_GESTURE_TWO_FINGER_TAP: - gesture_event.type = WebKit::WebInputEvent::GestureTwoFingerTap; + gesture_event.type = blink::WebInputEvent::GestureTwoFingerTap; gesture_event.data.twoFingerTap.firstFingerWidth = event.details().first_finger_width(); gesture_event.data.twoFingerTap.firstFingerHeight = @@ -229,13 +229,13 @@ WebKit::WebGestureEvent MakeWebGestureEventFromUIEvent( case ui::ET_GESTURE_BEGIN: case ui::ET_GESTURE_END: case ui::ET_GESTURE_MULTIFINGER_SWIPE: - gesture_event.type = WebKit::WebInputEvent::Undefined; + gesture_event.type = blink::WebInputEvent::Undefined; break; default: NOTREACHED() << "Unknown gesture type: " << event.type(); } - gesture_event.sourceDevice = WebKit::WebGestureEvent::Touchscreen; + gesture_event.sourceDevice = blink::WebGestureEvent::Touchscreen; gesture_event.modifiers = EventFlagsToWebEventModifiers(event.flags()); gesture_event.timeStampSeconds = event.time_stamp().InSecondsF(); @@ -246,31 +246,31 @@ int EventFlagsToWebEventModifiers(int flags) { int modifiers = 0; if (flags & ui::EF_SHIFT_DOWN) - modifiers |= WebKit::WebInputEvent::ShiftKey; + modifiers |= blink::WebInputEvent::ShiftKey; if (flags & ui::EF_CONTROL_DOWN) - modifiers |= WebKit::WebInputEvent::ControlKey; + modifiers |= blink::WebInputEvent::ControlKey; if (flags & ui::EF_ALT_DOWN) - modifiers |= WebKit::WebInputEvent::AltKey; + modifiers |= blink::WebInputEvent::AltKey; // TODO(beng): MetaKey/META_MASK if (flags & ui::EF_LEFT_MOUSE_BUTTON) - modifiers |= WebKit::WebInputEvent::LeftButtonDown; + modifiers |= blink::WebInputEvent::LeftButtonDown; if (flags & ui::EF_MIDDLE_MOUSE_BUTTON) - modifiers |= WebKit::WebInputEvent::MiddleButtonDown; + modifiers |= blink::WebInputEvent::MiddleButtonDown; if (flags & ui::EF_RIGHT_MOUSE_BUTTON) - modifiers |= WebKit::WebInputEvent::RightButtonDown; + modifiers |= blink::WebInputEvent::RightButtonDown; if (flags & ui::EF_CAPS_LOCK_DOWN) - modifiers |= WebKit::WebInputEvent::CapsLockOn; + modifiers |= blink::WebInputEvent::CapsLockOn; return modifiers; } -WebKit::WebTouchPoint* UpdateWebTouchEventFromUIEvent( +blink::WebTouchPoint* UpdateWebTouchEventFromUIEvent( const ui::TouchEvent& event, - WebKit::WebTouchEvent* web_event) { - WebKit::WebTouchPoint* point = NULL; + blink::WebTouchEvent* web_event) { + blink::WebTouchPoint* point = NULL; switch (event.type()) { case ui::ET_TOUCH_PRESSED: // Add a new touch point. - if (web_event->touchesLength < WebKit::WebTouchEvent::touchesLengthCap) { + if (web_event->touchesLength < blink::WebTouchEvent::touchesLengthCap) { point = &web_event->touches[web_event->touchesLength++]; point->id = event.touch_id(); } @@ -306,7 +306,7 @@ WebKit::WebTouchPoint* UpdateWebTouchEventFromUIEvent( // Update the location and state of the point. point->state = TouchPointStateFromEvent(event); - if (point->state == WebKit::WebTouchPoint::StateMoved) { + if (point->state == blink::WebTouchPoint::StateMoved) { // It is possible for badly written touch drivers to emit Move events even // when the touch location hasn't changed. In such cases, consume the event // and pretend nothing happened. @@ -322,9 +322,9 @@ WebKit::WebTouchPoint* UpdateWebTouchEventFromUIEvent( // Mark the rest of the points as stationary. for (unsigned i = 0; i < web_event->touchesLength; ++i) { - WebKit::WebTouchPoint* iter = web_event->touches + i; + blink::WebTouchPoint* iter = web_event->touches + i; if (iter != point) - iter->state = WebKit::WebTouchPoint::StateStationary; + iter->state = blink::WebTouchPoint::StateStationary; } // Update the type of the touch event. diff --git a/content/browser/renderer_host/ui_events_helper.h b/content/browser/renderer_host/ui_events_helper.h index 734a314..51fd46f 100644 --- a/content/browser/renderer_host/ui_events_helper.h +++ b/content/browser/renderer_host/ui_events_helper.h @@ -9,7 +9,7 @@ #include "content/common/content_export.h" #include "content/port/browser/event_with_latency_info.h" -namespace WebKit { +namespace blink { class WebGestureEvent; class WebTouchEvent; class WebTouchPoint; @@ -41,7 +41,7 @@ CONTENT_EXPORT bool MakeUITouchEventsFromWebTouchEvents( // Creates a WebGestureEvent from a ui::GestureEvent. Note that it does not // populate the event coordinates (i.e. |x|, |y|, |globalX|, and |globalY|). So // the caller must populate these fields. -WebKit::WebGestureEvent MakeWebGestureEventFromUIEvent( +blink::WebGestureEvent MakeWebGestureEventFromUIEvent( const ui::GestureEvent& event); int EventFlagsToWebEventModifiers(int flags); @@ -49,9 +49,9 @@ int EventFlagsToWebEventModifiers(int flags); // Updates the WebTouchEvent based on the TouchEvent. It returns the updated // WebTouchPoint contained in the WebTouchEvent, or NULL if no point was // updated. -WebKit::WebTouchPoint* UpdateWebTouchEventFromUIEvent( +blink::WebTouchPoint* UpdateWebTouchEventFromUIEvent( const ui::TouchEvent& event, - WebKit::WebTouchEvent* web_event); + blink::WebTouchEvent* web_event); } #endif // CONTENT_BROWSER_RENDERER_HOST_UI_EVENTS_HELPER_H_ diff --git a/content/browser/renderer_host/web_input_event_aura.cc b/content/browser/renderer_host/web_input_event_aura.cc index 6bb5e58..5127c07 100644 --- a/content/browser/renderer_host/web_input_event_aura.cc +++ b/content/browser/renderer_host/web_input_event_aura.cc @@ -13,7 +13,7 @@ namespace content { #if defined(USE_X11) || defined(USE_OZONE) // From third_party/WebKit/Source/web/gtk/WebInputEventFactory.cpp: -WebKit::WebUChar GetControlCharacter(int windows_key_code, bool shift) { +blink::WebUChar GetControlCharacter(int windows_key_code, bool shift) { if (windows_key_code >= ui::VKEY_A && windows_key_code <= ui::VKEY_Z) { // ctrl-A ~ ctrl-Z map to \x01 ~ \x1A @@ -58,40 +58,40 @@ WebKit::WebUChar GetControlCharacter(int windows_key_code, bool shift) { } #endif #if defined(OS_WIN) -WebKit::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent( +blink::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent( base::NativeEvent native_event); -WebKit::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent( +blink::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent( base::NativeEvent native_event); -WebKit::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent( +blink::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent( base::NativeEvent native_event); -WebKit::WebGestureEvent MakeWebGestureEventFromNativeEvent( +blink::WebGestureEvent MakeWebGestureEventFromNativeEvent( base::NativeEvent native_event); #elif defined(USE_X11) -WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( +blink::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( ui::KeyEvent* event); #elif defined(USE_OZONE) -WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( +blink::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( ui::KeyEvent* event) { base::NativeEvent native_event = event->native_event(); ui::EventType type = ui::EventTypeFromNative(native_event); - WebKit::WebKeyboardEvent webkit_event; + blink::WebKeyboardEvent webkit_event; webkit_event.timeStampSeconds = event->time_stamp().InSecondsF(); webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags()); switch (type) { case ui::ET_KEY_PRESSED: - webkit_event.type = event->is_char() ? WebKit::WebInputEvent::Char : - WebKit::WebInputEvent::RawKeyDown; + webkit_event.type = event->is_char() ? blink::WebInputEvent::Char : + blink::WebInputEvent::RawKeyDown; break; case ui::ET_KEY_RELEASED: - webkit_event.type = WebKit::WebInputEvent::KeyUp; + webkit_event.type = blink::WebInputEvent::KeyUp; break; default: NOTREACHED(); } - if (webkit_event.modifiers & WebKit::WebInputEvent::AltKey) + if (webkit_event.modifiers & blink::WebInputEvent::AltKey) webkit_event.isSystemKey = true; wchar_t character = ui::KeyboardCodeFromNative(native_event); @@ -103,11 +103,11 @@ WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( else webkit_event.unmodifiedText[0] = character; - if (webkit_event.modifiers & WebKit::WebInputEvent::ControlKey) { + if (webkit_event.modifiers & blink::WebInputEvent::ControlKey) { webkit_event.text[0] = GetControlCharacter( webkit_event.windowsKeyCode, - webkit_event.modifiers & WebKit::WebInputEvent::ShiftKey); + webkit_event.modifiers & blink::WebInputEvent::ShiftKey); } else { webkit_event.text[0] = webkit_event.unmodifiedText[0]; } @@ -118,12 +118,12 @@ WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( } #endif #if defined(USE_X11) || defined(USE_OZONE) -WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( +blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( ui::ScrollEvent* event) { - WebKit::WebMouseWheelEvent webkit_event; + blink::WebMouseWheelEvent webkit_event; - webkit_event.type = WebKit::WebInputEvent::MouseWheel; - webkit_event.button = WebKit::WebMouseEvent::ButtonNone; + webkit_event.type = blink::WebInputEvent::MouseWheel; + webkit_event.button = blink::WebMouseEvent::ButtonNone; webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags()); webkit_event.timeStampSeconds = event->time_stamp().InSecondsF(); webkit_event.hasPreciseScrollingDeltas = true; @@ -142,18 +142,18 @@ WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( return webkit_event; } -WebKit::WebGestureEvent MakeWebGestureEventFromAuraEvent( +blink::WebGestureEvent MakeWebGestureEventFromAuraEvent( ui::ScrollEvent* event) { - WebKit::WebGestureEvent webkit_event; + blink::WebGestureEvent webkit_event; switch (event->type()) { case ui::ET_SCROLL_FLING_START: - webkit_event.type = WebKit::WebInputEvent::GestureFlingStart; + webkit_event.type = blink::WebInputEvent::GestureFlingStart; webkit_event.data.flingStart.velocityX = event->x_offset(); webkit_event.data.flingStart.velocityY = event->y_offset(); break; case ui::ET_SCROLL_FLING_CANCEL: - webkit_event.type = WebKit::WebInputEvent::GestureFlingCancel; + webkit_event.type = blink::WebInputEvent::GestureFlingCancel; break; case ui::ET_SCROLL: NOTREACHED() << "Invalid gesture type: " << event->type(); @@ -162,7 +162,7 @@ WebKit::WebGestureEvent MakeWebGestureEventFromAuraEvent( NOTREACHED() << "Unknown gesture type: " << event->type(); } - webkit_event.sourceDevice = WebKit::WebGestureEvent::Touchpad; + webkit_event.sourceDevice = blink::WebGestureEvent::Touchpad; webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags()); webkit_event.timeStampSeconds = event->time_stamp().InSecondsF(); return webkit_event; @@ -170,9 +170,9 @@ WebKit::WebGestureEvent MakeWebGestureEventFromAuraEvent( #endif -WebKit::WebMouseEvent MakeWebMouseEventFromAuraEvent( +blink::WebMouseEvent MakeWebMouseEventFromAuraEvent( ui::MouseEvent* event); -WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( +blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( ui::MouseWheelEvent* event); // General approach: @@ -187,7 +187,7 @@ WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( // provide coordinates relative to the aura::Window that is hosting the // renderer, not the top level platform window. // -// The approach is to fully construct a WebKit::WebInputEvent from the +// The approach is to fully construct a blink::WebInputEvent from the // ui::Event's base::NativeEvent, and then replace the coordinate fields with // the translated values from the ui::Event. // @@ -198,9 +198,9 @@ WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( // ui::MouseEvent. This will not be necessary once only XInput2 is supported. // -WebKit::WebMouseEvent MakeWebMouseEvent(ui::MouseEvent* event) { +blink::WebMouseEvent MakeWebMouseEvent(ui::MouseEvent* event) { // Construct an untranslated event from the platform event data. - WebKit::WebMouseEvent webkit_event = + blink::WebMouseEvent webkit_event = #if defined(OS_WIN) // On Windows we have WM_ events comming from desktop and pure aura // events comming from metro mode. @@ -226,14 +226,14 @@ WebKit::WebMouseEvent MakeWebMouseEvent(ui::MouseEvent* event) { return webkit_event; } -WebKit::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::MouseWheelEvent* event) { +blink::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::MouseWheelEvent* event) { #if defined(OS_WIN) // Construct an untranslated event from the platform event data. - WebKit::WebMouseWheelEvent webkit_event = event->native_event().message ? + blink::WebMouseWheelEvent webkit_event = event->native_event().message ? MakeUntranslatedWebMouseWheelEventFromNativeEvent(event->native_event()) : MakeWebMouseWheelEventFromAuraEvent(event); #else - WebKit::WebMouseWheelEvent webkit_event = + blink::WebMouseWheelEvent webkit_event = MakeWebMouseWheelEventFromAuraEvent(event); #endif @@ -249,13 +249,13 @@ WebKit::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::MouseWheelEvent* event) { return webkit_event; } -WebKit::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::ScrollEvent* event) { +blink::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::ScrollEvent* event) { #if defined(OS_WIN) // Construct an untranslated event from the platform event data. - WebKit::WebMouseWheelEvent webkit_event = + blink::WebMouseWheelEvent webkit_event = MakeUntranslatedWebMouseWheelEventFromNativeEvent(event->native_event()); #else - WebKit::WebMouseWheelEvent webkit_event = + blink::WebMouseWheelEvent webkit_event = MakeWebMouseWheelEventFromAuraEvent(event); #endif @@ -271,7 +271,7 @@ WebKit::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::ScrollEvent* event) { return webkit_event; } -WebKit::WebKeyboardEvent MakeWebKeyboardEvent(ui::KeyEvent* event) { +blink::WebKeyboardEvent MakeWebKeyboardEvent(ui::KeyEvent* event) { // Windows can figure out whether or not to construct a RawKeyDown or a Char // WebInputEvent based on the type of message carried in // event->native_event(). X11 is not so fortunate, there is no separate @@ -286,8 +286,8 @@ WebKit::WebKeyboardEvent MakeWebKeyboardEvent(ui::KeyEvent* event) { #endif } -WebKit::WebGestureEvent MakeWebGestureEvent(ui::GestureEvent* event) { - WebKit::WebGestureEvent gesture_event; +blink::WebGestureEvent MakeWebGestureEvent(ui::GestureEvent* event) { + blink::WebGestureEvent gesture_event; #if defined(OS_WIN) if (event->HasNativeEvent()) gesture_event = MakeWebGestureEventFromNativeEvent(event->native_event()); @@ -307,8 +307,8 @@ WebKit::WebGestureEvent MakeWebGestureEvent(ui::GestureEvent* event) { return gesture_event; } -WebKit::WebGestureEvent MakeWebGestureEvent(ui::ScrollEvent* event) { - WebKit::WebGestureEvent gesture_event; +blink::WebGestureEvent MakeWebGestureEvent(ui::ScrollEvent* event) { + blink::WebGestureEvent gesture_event; #if defined(OS_WIN) gesture_event = MakeWebGestureEventFromNativeEvent(event->native_event()); @@ -326,43 +326,43 @@ WebKit::WebGestureEvent MakeWebGestureEvent(ui::ScrollEvent* event) { return gesture_event; } -WebKit::WebGestureEvent MakeWebGestureEventFlingCancel() { - WebKit::WebGestureEvent gesture_event; +blink::WebGestureEvent MakeWebGestureEventFlingCancel() { + blink::WebGestureEvent gesture_event; // All other fields are ignored on a GestureFlingCancel event. - gesture_event.type = WebKit::WebInputEvent::GestureFlingCancel; - gesture_event.sourceDevice = WebKit::WebGestureEvent::Touchpad; + gesture_event.type = blink::WebInputEvent::GestureFlingCancel; + gesture_event.sourceDevice = blink::WebGestureEvent::Touchpad; return gesture_event; } -WebKit::WebMouseEvent MakeWebMouseEventFromAuraEvent(ui::MouseEvent* event) { - WebKit::WebMouseEvent webkit_event; +blink::WebMouseEvent MakeWebMouseEventFromAuraEvent(ui::MouseEvent* event) { + blink::WebMouseEvent webkit_event; webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags()); webkit_event.timeStampSeconds = event->time_stamp().InSecondsF(); - webkit_event.button = WebKit::WebMouseEvent::ButtonNone; + webkit_event.button = blink::WebMouseEvent::ButtonNone; if (event->flags() & ui::EF_LEFT_MOUSE_BUTTON) - webkit_event.button = WebKit::WebMouseEvent::ButtonLeft; + webkit_event.button = blink::WebMouseEvent::ButtonLeft; if (event->flags() & ui::EF_MIDDLE_MOUSE_BUTTON) - webkit_event.button = WebKit::WebMouseEvent::ButtonMiddle; + webkit_event.button = blink::WebMouseEvent::ButtonMiddle; if (event->flags() & ui::EF_RIGHT_MOUSE_BUTTON) - webkit_event.button = WebKit::WebMouseEvent::ButtonRight; + webkit_event.button = blink::WebMouseEvent::ButtonRight; switch (event->type()) { case ui::ET_MOUSE_PRESSED: - webkit_event.type = WebKit::WebInputEvent::MouseDown; + webkit_event.type = blink::WebInputEvent::MouseDown; webkit_event.clickCount = event->GetClickCount(); break; case ui::ET_MOUSE_RELEASED: - webkit_event.type = WebKit::WebInputEvent::MouseUp; + webkit_event.type = blink::WebInputEvent::MouseUp; webkit_event.clickCount = event->GetClickCount(); break; case ui::ET_MOUSE_ENTERED: case ui::ET_MOUSE_EXITED: case ui::ET_MOUSE_MOVED: case ui::ET_MOUSE_DRAGGED: - webkit_event.type = WebKit::WebInputEvent::MouseMove; + webkit_event.type = blink::WebInputEvent::MouseMove; break; default: NOTIMPLEMENTED() << "Received unexpected event: " << event->type(); @@ -372,12 +372,12 @@ WebKit::WebMouseEvent MakeWebMouseEventFromAuraEvent(ui::MouseEvent* event) { return webkit_event; } -WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( +blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent( ui::MouseWheelEvent* event) { - WebKit::WebMouseWheelEvent webkit_event; + blink::WebMouseWheelEvent webkit_event; - webkit_event.type = WebKit::WebInputEvent::MouseWheel; - webkit_event.button = WebKit::WebMouseEvent::ButtonNone; + webkit_event.type = blink::WebInputEvent::MouseWheel; + webkit_event.button = blink::WebMouseEvent::ButtonNone; webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags()); webkit_event.timeStampSeconds = event->time_stamp().InSecondsF(); webkit_event.deltaX = event->x_offset(); diff --git a/content/browser/renderer_host/web_input_event_aura.h b/content/browser/renderer_host/web_input_event_aura.h index 3c4c894..eeff886 100644 --- a/content/browser/renderer_host/web_input_event_aura.h +++ b/content/browser/renderer_host/web_input_event_aura.h @@ -23,22 +23,22 @@ namespace content { const int kPixelsPerTick = 53; #if defined(USE_X11) || defined(USE_OZONE) -CONTENT_EXPORT WebKit::WebUChar GetControlCharacter( +CONTENT_EXPORT blink::WebUChar GetControlCharacter( int windows_key_code, bool shift); #endif -CONTENT_EXPORT WebKit::WebMouseEvent MakeWebMouseEvent( +CONTENT_EXPORT blink::WebMouseEvent MakeWebMouseEvent( ui::MouseEvent* event); -CONTENT_EXPORT WebKit::WebMouseWheelEvent MakeWebMouseWheelEvent( +CONTENT_EXPORT blink::WebMouseWheelEvent MakeWebMouseWheelEvent( ui::MouseWheelEvent* event); -CONTENT_EXPORT WebKit::WebMouseWheelEvent MakeWebMouseWheelEvent( +CONTENT_EXPORT blink::WebMouseWheelEvent MakeWebMouseWheelEvent( ui::ScrollEvent* event); -CONTENT_EXPORT WebKit::WebKeyboardEvent MakeWebKeyboardEvent( +CONTENT_EXPORT blink::WebKeyboardEvent MakeWebKeyboardEvent( ui::KeyEvent* event); -CONTENT_EXPORT WebKit::WebGestureEvent MakeWebGestureEvent( +CONTENT_EXPORT blink::WebGestureEvent MakeWebGestureEvent( ui::GestureEvent* event); -CONTENT_EXPORT WebKit::WebGestureEvent MakeWebGestureEvent( +CONTENT_EXPORT blink::WebGestureEvent MakeWebGestureEvent( ui::ScrollEvent* event); -CONTENT_EXPORT WebKit::WebGestureEvent MakeWebGestureEventFlingCancel(); +CONTENT_EXPORT blink::WebGestureEvent MakeWebGestureEventFlingCancel(); } // namespace content diff --git a/content/browser/renderer_host/web_input_event_aura_unittest.cc b/content/browser/renderer_host/web_input_event_aura_unittest.cc index 059ebb2..dd82378 100644 --- a/content/browser/renderer_host/web_input_event_aura_unittest.cc +++ b/content/browser/renderer_host/web_input_event_aura_unittest.cc @@ -29,9 +29,9 @@ TEST(WebInputEventAuraTest, TestMakeWebKeyboardEvent) { 0, // X does not set ControlMask for KeyPress. &xev); ui::KeyEvent event(&xev, false /* is_char */); - WebKit::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); + blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); // However, modifier bit for Control in |webkit_event| should be set. - EXPECT_EQ(webkit_event.modifiers, WebKit::WebInputEvent::ControlKey); + EXPECT_EQ(webkit_event.modifiers, blink::WebInputEvent::ControlKey); } { // Release Ctrl. @@ -40,7 +40,7 @@ TEST(WebInputEventAuraTest, TestMakeWebKeyboardEvent) { ControlMask, // X sets the mask for KeyRelease. &xev); ui::KeyEvent event(&xev, false /* is_char */); - WebKit::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); + blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); // However, modifier bit for Control in |webkit_event| shouldn't be set. EXPECT_EQ(webkit_event.modifiers, 0); } @@ -59,7 +59,7 @@ TEST(WebInputEventAuraTest, TestMakeWebKeyboardEventWindowsKeyCode) { &xev); xev.xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L); ui::KeyEvent event(&xev, false /* is_char */); - WebKit::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); + blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); // ui::VKEY_LCONTROL, instead of ui::VKEY_CONTROL, should be filled. EXPECT_EQ(ui::VKEY_LCONTROL, webkit_event.windowsKeyCode); } @@ -71,7 +71,7 @@ TEST(WebInputEventAuraTest, TestMakeWebKeyboardEventWindowsKeyCode) { &xev); xev.xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_R); ui::KeyEvent event(&xev, false /* is_char */); - WebKit::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); + blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(&event); // ui::VKEY_RCONTROL, instead of ui::VKEY_CONTROL, should be filled. EXPECT_EQ(ui::VKEY_RCONTROL, webkit_event.windowsKeyCode); } diff --git a/content/browser/renderer_host/web_input_event_aurawin.cc b/content/browser/renderer_host/web_input_event_aurawin.cc index 771b792..06e2dbf 100644 --- a/content/browser/renderer_host/web_input_event_aurawin.cc +++ b/content/browser/renderer_host/web_input_event_aurawin.cc @@ -13,7 +13,7 @@ namespace content { // On Windows, we can just use the builtin WebKit factory methods to fully // construct our pre-translated events. -WebKit::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent( +blink::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent( base::NativeEvent native_event) { return WebMouseEventBuilder::Build(native_event.hwnd, native_event.message, @@ -21,7 +21,7 @@ WebKit::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent( native_event.lParam); } -WebKit::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent( +blink::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent( base::NativeEvent native_event) { return WebMouseWheelEventBuilder::Build(native_event.hwnd, native_event.message, @@ -29,7 +29,7 @@ WebKit::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent( native_event.lParam); } -WebKit::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent( +blink::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent( base::NativeEvent native_event) { return WebKeyboardEventBuilder::Build(native_event.hwnd, native_event.message, @@ -37,11 +37,11 @@ WebKit::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent( native_event.lParam); } -WebKit::WebGestureEvent MakeWebGestureEventFromNativeEvent( +blink::WebGestureEvent MakeWebGestureEventFromNativeEvent( base::NativeEvent native_event) { // TODO: Create gestures from native event. NOTIMPLEMENTED(); - return WebKit::WebGestureEvent(); + return blink::WebGestureEvent(); } } // namespace content diff --git a/content/browser/renderer_host/web_input_event_aurax11.cc b/content/browser/renderer_host/web_input_event_aurax11.cc index 76ae55f..6bec493 100644 --- a/content/browser/renderer_host/web_input_event_aurax11.cc +++ b/content/browser/renderer_host/web_input_event_aurax11.cc @@ -89,10 +89,10 @@ int XKeyEventToWindowsKeyCode(XKeyEvent* event) { } // namespace -WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( +blink::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( ui::KeyEvent* event) { base::NativeEvent native_event = event->native_event(); - WebKit::WebKeyboardEvent webkit_event; + blink::WebKeyboardEvent webkit_event; XKeyEvent* native_key_event = &native_event->xkey; webkit_event.timeStampSeconds = event->time_stamp().InSecondsF(); @@ -100,17 +100,17 @@ WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( switch (native_event->type) { case KeyPress: - webkit_event.type = event->is_char() ? WebKit::WebInputEvent::Char : - WebKit::WebInputEvent::RawKeyDown; + webkit_event.type = event->is_char() ? blink::WebInputEvent::Char : + blink::WebInputEvent::RawKeyDown; break; case KeyRelease: - webkit_event.type = WebKit::WebInputEvent::KeyUp; + webkit_event.type = blink::WebInputEvent::KeyUp; break; default: NOTREACHED(); } - if (webkit_event.modifiers & WebKit::WebInputEvent::AltKey) + if (webkit_event.modifiers & blink::WebInputEvent::AltKey) webkit_event.isSystemKey = true; webkit_event.windowsKeyCode = XKeyEventToWindowsKeyCode(native_key_event); @@ -121,11 +121,11 @@ WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent( else webkit_event.unmodifiedText[0] = ui::GetCharacterFromXEvent(native_event); - if (webkit_event.modifiers & WebKit::WebInputEvent::ControlKey) { + if (webkit_event.modifiers & blink::WebInputEvent::ControlKey) { webkit_event.text[0] = GetControlCharacter( webkit_event.windowsKeyCode, - webkit_event.modifiers & WebKit::WebInputEvent::ShiftKey); + webkit_event.modifiers & blink::WebInputEvent::ShiftKey); } else { webkit_event.text[0] = webkit_event.unmodifiedText[0]; } |