Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/render_widget_host_impl.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_
 
 #include <deque>
 #include <list>
 #include <map>
@@ skipping 44 matching lines @@
 }
 
 namespace gfx {
 class Range;
 }
 
 namespace ui {
 class KeyEvent;
 }
 
-namespace WebKit {
+namespace blink {
 class WebInputEvent;
 class WebMouseEvent;
 struct WebCompositionUnderline;
 struct WebScreenInfo;
 }
 
 #if defined(OS_ANDROID)
-namespace WebKit {
+namespace blink {
 class WebLayer;
 }
 #endif
 
 namespace content {
 class BackingStore;
 class InputRouter;
 class MockRenderWidgetHost;
 class OverscrollController;
 class RenderWidgetHostDelegate;
@@ skipping 39 matching lines @@
   virtual void Undo() OVERRIDE;
   virtual void Redo() OVERRIDE;
   virtual void Cut() OVERRIDE;
   virtual void Copy() OVERRIDE;
   virtual void CopyToFindPboard() OVERRIDE;
   virtual void Paste() OVERRIDE;
   virtual void PasteAndMatchStyle() OVERRIDE;
   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;
   virtual void SetActive(bool active) OVERRIDE;
   virtual void CopyFromBackingStore(
       const gfx::Rect& src_rect,
       const gfx::Size& accelerated_dst_size,
       const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE;
 #if defined(TOOLKIT_GTK)
   virtual bool CopyFromBackingStoreToGtkWindow(const gfx::Rect& dest_rect,
                                                GdkWindow* target) OVERRIDE;
 #elif defined(OS_MACOSX)
   virtual gfx::Size GetBackingStoreSize() OVERRIDE;
   virtual bool CopyFromBackingStoreToCGContext(const CGRect& dest_rect,
                                                CGContextRef target) OVERRIDE;
 #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;
   virtual RenderProcessHost* GetProcess() const OVERRIDE;
   virtual int GetRoutingID() const OVERRIDE;
   virtual RenderWidgetHostView* GetView() const OVERRIDE;
   virtual bool IsLoading() const OVERRIDE;
   virtual bool IsRenderView() const OVERRIDE;
   virtual void PaintAtSize(TransportDIB::Handle dib_handle,
                            int tag,
                            const gfx::Size& page_size,
                            const gfx::Size& desired_size) OVERRIDE;
   virtual void Replace(const string16& word) OVERRIDE;
   virtual void ReplaceMisspelling(const string16& word) OVERRIDE;
   virtual void ResizeRectChanged(const gfx::Rect& new_rect) OVERRIDE;
   virtual void RestartHangMonitorTimeout() OVERRIDE;
   virtual void SetIgnoreInputEvents(bool ignore_input_events) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual void WasResized() OVERRIDE;
   virtual void AddKeyPressEventCallback(
       const KeyPressEventCallback& callback) OVERRIDE;
   virtual void RemoveKeyPressEventCallback(
       const KeyPressEventCallback& callback) OVERRIDE;
   virtual void AddMouseEventCallback(
       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;
 
   const NativeWebKeyboardEvent* GetLastKeyboardEvent() const;
 
   // Notification that the screen info has changed.
   void NotifyScreenInfoChanged();
 
   // Invalidates the cached screen info so that next resize request
@@ skipping 87 matching lines @@
   // the new one will only fire if it has a shorter delay than the time
   // left on the existing timeouts.
   void StartHangMonitorTimeout(base::TimeDelta delay);
 
   // Stops all existing hang monitor timeouts and assumes the renderer is
   // responsive.
   void StopHangMonitorTimeout();
 
   // 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);
   void ForwardWheelEventWithLatencyInfo(
       const MouseWheelEventWithLatencyInfo& wheel_event);
 
   void CancelUpdateTextDirection();
 
   // Called when a mouse click/gesture tap activates the renderer.
   virtual void OnPointerEventActivate();
@@ skipping 16 matching lines @@
   // Sets the text of the composition node.
   // This function can also update the cursor position and mark the specified
   // range in the composition node.
   // A browser should call this function:
   // * when it receives a WM_IME_COMPOSITION message with a GCS_COMPSTR flag
   //   (on Windows);
   // * when it receives a "preedit_changed" signal of GtkIMContext (on Linux);
   // * 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);
 
   // Finishes an ongoing composition with the specified text.
   // A browser should call this function:
   // * when it receives a WM_IME_COMPOSITION message with a GCS_RESULTSTR flag
   //   (on Windows);
   // * when it receives a "commit" signal of GtkIMContext (on Linux);
   // * when insertText of NSTextInput is called (on Mac).
   void ImeConfirmComposition(const string16& text,
@@ skipping 217 matching lines @@
 
   // Retrieves an id for the surface that the renderer can draw to
   // when accelerated compositing is enabled.
   gfx::GLSurfaceHandle GetCompositingSurface();
 
   // ---------------------------------------------------------------------------
   // The following methods are overridden by RenderViewHost to send upwards to
   // 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
   // event and 2) enter or space key presses.
   virtual void OnUserGesture() {}
 
   // Callbacks for notification when the renderer becomes unresponsive to user
   // input events, and subsequently responsive again.
   virtual void NotifyRendererUnresponsive() {}
   virtual void NotifyRendererResponsive() {}
@@ skipping 58 matching lines @@
   // NotifyRendererResponsive.
   void RendererIsResponsive();
 
   // IPC message handlers
   void OnRenderViewReady();
   void OnRenderProcessGone(int status, int error_code);
   void OnClose();
   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(
       const ViewHostMsg_CompositorSurfaceBuffersSwapped_Params& params);
 #endif
   bool OnSwapCompositorFrame(const IPC::Message& message);
   void OnOverscrolled(gfx::Vector2dF accumulated_overscroll,
                       gfx::Vector2dF current_fling_velocity);
   void OnUpdateRect(const ViewHostMsg_UpdateRect_Params& params);
   void OnUpdateIsDelayed();
@@ skipping 52 matching lines @@
   void ScrollBackingStoreRect(const gfx::Vector2d& delta,
                               const gfx::Rect& clip_rect,
                               const gfx::Size& view_size);
 
   // Give key press listeners a chance to handle this key press. This allow
   // widgets that don't have focus to still handle key presses.
   bool KeyPressListenersHandleEvent(const NativeWebKeyboardEvent& event);
 
   // 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;
   virtual void OnHasTouchEventHandlers(bool has_handlers) OVERRIDE;
   virtual OverscrollController* GetOverscrollController() const OVERRIDE;
   virtual void SetNeedsFlush() OVERRIDE;
   virtual void DidFlush() OVERRIDE;
 
   // InputAckHandler
   virtual void OnKeyboardEventAck(const NativeWebKeyboardEvent& event,
@@ skipping 43 matching lines @@
   bool is_threaded_compositing_enabled_;
 
   // Set if we are waiting for a repaint ack for the view.
   bool repaint_ack_pending_;
 
   // True when waiting for RESIZE_ACK.
   bool resize_ack_pending_;
 
   // 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.
   bool screen_info_out_of_date_;
 
   // The current size of the RenderWidget.
   gfx::Size current_size_;
 
   // The size of the view's backing surface in non-DPI-adjusted pixels.
   gfx::Size physical_backing_size_;
@@ skipping 62 matching lines @@
   base::TimeTicks repaint_start_time_;
 
   // Set to true if we shouldn't send input events from the render widget.
   bool ignore_input_events_;
 
   // Indicates whether IME is active.
   bool input_method_active_;
 
   // 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
   // NotifyTextDirection().
   bool text_direction_canceled_;
 
   // Indicates if the next sequence of Char events should be suppressed or not.
   // System may translate a RawKeyDown event into zero or more Char events,
   // usually we send them to the renderer directly in sequence. However, If a
   // RawKeyDown event was not handled by the renderer but was handled by
@@ skipping 38 matching lines @@
   int64 last_input_number_;
 
   BrowserRenderingStats rendering_stats_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_IMPL_H_