Rename WebKit namespace to blink (part 3)

content/renderer/render_widget.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_RENDERER_RENDER_WIDGET_H_
 #define CONTENT_RENDERER_RENDER_WIDGET_H_
 
 #include <deque>
 #include <map>
 
@@ skipping 30 matching lines @@
 #include "webkit/common/cursors/webcursor.h"
 
 struct ViewHostMsg_UpdateRect_Params;
 struct ViewMsg_Resize_Params;
 class ViewHostMsg_UpdateRect;
 
 namespace IPC {
 class SyncMessage;
 }
 
-namespace WebKit {
+namespace blink {
 class WebGestureEvent;
 class WebInputEvent;
 class WebKeyboardEvent;
 class WebMouseEvent;
 class WebTouchEvent;
 struct WebRenderingStatsImpl;
 }
 
 namespace cc { class OutputSurface; }
 
 namespace gfx {
 class Range;
 }
 
 namespace content {
 class ExternalPopupMenu;
 class PepperPluginInstanceImpl;
 class RenderWidgetCompositor;
 class RenderWidgetTest;
 class ResizingModeSelector;
 struct ContextMenuParams;
 struct GpuRenderingStats;
 struct WebPluginGeometry;
 
 // RenderWidget provides a communication bridge between a WebWidget and
 // a RenderWidgetHost, the latter of which lives in a different process.
 class CONTENT_EXPORT RenderWidget
     : public IPC::Listener,
       public IPC::Sender,
-      NON_EXPORTED_BASE(virtual public WebKit::WebWidgetClient),
+      NON_EXPORTED_BASE(virtual public blink::WebWidgetClient),
       NON_EXPORTED_BASE(public WebGraphicsContext3DSwapBuffersClient),
       public base::RefCounted<RenderWidget> {
  public:
   // Creates a new RenderWidget.  The opener_id is the routing ID of the
   // RenderView that this widget lives inside.
   static RenderWidget* Create(int32 opener_id,
-                              WebKit::WebPopupType popup_type,
-                              const WebKit::WebScreenInfo& screen_info);
+                              blink::WebPopupType popup_type,
+                              const blink::WebScreenInfo& screen_info);
 
   // Creates a WebWidget based on the popup type.
-  static WebKit::WebWidget* CreateWebWidget(RenderWidget* render_widget);
+  static blink::WebWidget* CreateWebWidget(RenderWidget* render_widget);
 
   // The compositing surface assigned by the RenderWidgetHost
   // (or RenderViewHost). Will be gfx::kNullPluginWindow if not assigned yet,
   // in which case we should not create any GPU command buffers with it.
   // The routing ID assigned by the RenderProcess. Will be MSG_ROUTING_NONE if
   // not yet assigned a view ID, in which case, the process MUST NOT send
   // messages with this ID to the parent.
   int32 routing_id() const {
     return routing_id_;
   }
 
   int32 surface_id() const {
     return surface_id_;
   }
 
   // May return NULL when the window is closing.
-  WebKit::WebWidget* webwidget() const { return webwidget_; }
+  blink::WebWidget* webwidget() const { return webwidget_; }
 
   gfx::Size size() const { return size_; }
   bool has_focus() const { return has_focus_; }
   bool is_fullscreen() const { return is_fullscreen_; }
   bool is_hidden() const { return is_hidden_; }
 
   // IPC::Listener
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 
   // IPC::Sender
   virtual bool Send(IPC::Message* msg) OVERRIDE;
 
-  // WebKit::WebWidgetClient
+  // blink::WebWidgetClient
   virtual void suppressCompositorScheduling(bool enable);
   virtual void willBeginCompositorFrame();
-  virtual void didInvalidateRect(const WebKit::WebRect&);
+  virtual void didInvalidateRect(const blink::WebRect&);
   virtual void didScrollRect(int dx, int dy,
-                             const WebKit::WebRect& clipRect);
-  virtual void didAutoResize(const WebKit::WebSize& new_size);
+                             const blink::WebRect& clipRect);
+  virtual void didAutoResize(const blink::WebSize& new_size);
   virtual void didActivateCompositor(int input_handler_identifier);
   virtual void didDeactivateCompositor();
   virtual void initializeLayerTreeView();
-  virtual WebKit::WebLayerTreeView* layerTreeView();
+  virtual blink::WebLayerTreeView* layerTreeView();
   virtual void didBecomeReadyForAdditionalInput();
   virtual void didCommitAndDrawCompositorFrame();
   virtual void didCompleteSwapBuffers();
   virtual void scheduleComposite();
   virtual void scheduleAnimation();
   virtual void didFocus();
   virtual void didBlur();
-  virtual void didChangeCursor(const WebKit::WebCursorInfo&);
+  virtual void didChangeCursor(const blink::WebCursorInfo&);
   virtual void closeWidgetSoon();
-  virtual void show(WebKit::WebNavigationPolicy);
+  virtual void show(blink::WebNavigationPolicy);
   virtual void runModal() {}
-  virtual WebKit::WebRect windowRect();
-  virtual void setToolTipText(const WebKit::WebString& text,
-                              WebKit::WebTextDirection hint);
-  virtual void setWindowRect(const WebKit::WebRect&);
-  virtual WebKit::WebRect windowResizerRect();
-  virtual WebKit::WebRect rootWindowRect();
-  virtual WebKit::WebScreenInfo screenInfo();
+  virtual blink::WebRect windowRect();
+  virtual void setToolTipText(const blink::WebString& text,
+                              blink::WebTextDirection hint);
+  virtual void setWindowRect(const blink::WebRect&);
+  virtual blink::WebRect windowResizerRect();
+  virtual blink::WebRect rootWindowRect();
+  virtual blink::WebScreenInfo screenInfo();
   virtual float deviceScaleFactor();
   virtual void resetInputMethod();
-  virtual void didHandleGestureEvent(const WebKit::WebGestureEvent& event,
+  virtual void didHandleGestureEvent(const blink::WebGestureEvent& event,
                                      bool event_cancelled);
 
   // Called when a plugin is moved.  These events are queued up and sent with
   // the next paint or scroll message to the host.
   void SchedulePluginMove(const WebPluginGeometry& move);
 
   // Called when a plugin window has been destroyed, to make sure the currently
   // pending moves don't try to reference it.
   void CleanupWindowInPluginMoves(gfx::PluginWindowHandle window);
 
   // Fills in a WebRenderingStatsImpl struct containing information about
   // rendering, e.g. count of frames rendered, time spent painting.
-  void GetRenderingStats(WebKit::WebRenderingStatsImpl&) const;
+  void GetRenderingStats(blink::WebRenderingStatsImpl&) const;
 
   // Fills in a GpuRenderingStats struct containing information about
   // GPU rendering, e.g. count of texture uploads performed, time spent
   // uploading.
   // This call is relatively expensive as it blocks on the GPU process
   bool GetGpuRenderingStats(GpuRenderingStats*) const;
 
   void GetBrowserRenderingStats(BrowserRenderingStats* stats);
 
   RenderWidgetCompositor* compositor() const;
@@ skipping 70 matching lines @@
   // without ref-counting is an error.
   friend class base::RefCounted<RenderWidget>;
   // For unit tests.
   friend class RenderWidgetTest;
 
   enum ResizeAck {
     SEND_RESIZE_ACK,
     NO_RESIZE_ACK,
   };
 
-  RenderWidget(WebKit::WebPopupType popup_type,
-               const WebKit::WebScreenInfo& screen_info,
+  RenderWidget(blink::WebPopupType popup_type,
+               const blink::WebScreenInfo& screen_info,
                bool swapped_out,
                bool hidden);
 
   virtual ~RenderWidget();
 
   // Initializes this view with the given opener.  CompleteInit must be called
   // later.
   bool Init(int32 opener_id);
 
   // Called by Init and subclasses to perform initialization.
   bool DoInit(int32 opener_id,
-              WebKit::WebWidget* web_widget,
+              blink::WebWidget* web_widget,
               IPC::SyncMessage* create_widget_message);
 
   // Finishes creation of a pending view started with Init.
   void CompleteInit();
 
   // Sets whether this RenderWidget has been swapped out to be displayed by
   // a RenderWidget in a different process.  If so, no new IPC messages will be
   // sent (only ACKs) and the process is free to exit when there are no other
   // active RenderWidgets.
   void SetSwappedOut(bool is_swapped_out);
 
   // Paints the given rectangular region of the WebWidget into canvas (a
   // shared memory segment returned by AllocPaintBuf on Windows). The caller
   // must ensure that the given rect fits within the bounds of the WebWidget.
   void PaintRect(const gfx::Rect& rect, const gfx::Point& canvas_origin,
                  SkCanvas* canvas);
 
   // Paints a border at the given rect for debugging purposes.
   void PaintDebugBorder(const gfx::Rect& rect, SkCanvas* canvas);
 
   bool IsRenderingVSynced();
   void AnimationCallback();
   void AnimateIfNeeded();
   void InvalidationCallback();
   void FlushPendingInputEventAck();
   void DoDeferredUpdateAndSendInputAck();
   void DoDeferredUpdate();
   void DoDeferredClose();
-  void DoDeferredSetWindowRect(const WebKit::WebRect& pos);
+  void DoDeferredSetWindowRect(const blink::WebRect& pos);
   virtual void Composite(base::TimeTicks frame_begin_time);
 
   // Set the background of the render widget to a bitmap. The bitmap will be
   // tiled in both directions if it isn't big enough to fill the area. This is
   // mainly intended to be used in conjuction with WebView::SetIsTransparent().
   virtual void SetBackground(const SkBitmap& bitmap);
 
   // Resizes the render widget.
   void Resize(const gfx::Size& new_size,
               const gfx::Size& physical_backing_size,
               float overdraw_bottom_height,
               const gfx::Rect& resizer_rect,
               bool is_fullscreen,
               ResizeAck resize_ack);
   // Used to force the size of a window when running layout tests.
   void ResizeSynchronously(const gfx::Rect& new_position);
   virtual void SetScreenMetricsEmulationParameters(
       float device_scale_factor, float root_layer_scale);
   void SetExternalPopupOriginAdjustmentsForEmulation(
       ExternalPopupMenu* popup, ScreenMetricsEmulator* emulator);
   virtual void OnShowHostContextMenu(ContextMenuParams* params);
 
   // RenderWidget IPC message handlers
-  void OnHandleInputEvent(const WebKit::WebInputEvent* event,
+  void OnHandleInputEvent(const blink::WebInputEvent* event,
                           const ui::LatencyInfo& latency_info,
                           bool keyboard_shortcut);
   void OnCursorVisibilityChange(bool is_visible);
   void OnMouseCaptureLost();
   virtual void OnSetFocus(bool enable);
   void OnClose();
   void OnCreatingNewAck();
   virtual void OnResize(const ViewMsg_Resize_Params& params);
   void OnChangeResizeRect(const gfx::Rect& resizer_rect);
   virtual void OnWasHidden();
   virtual void OnWasShown(bool needs_repainting);
   virtual void OnWasSwappedOut();
   void OnUpdateRectAck();
   void OnCreateVideoAck(int32 video_id);
   void OnUpdateVideoAck(int32 video_id);
   void OnRequestMoveAck();
   void OnSetInputMethodActive(bool is_active);
   virtual void OnImeSetComposition(
       const string16& text,
-      const std::vector<WebKit::WebCompositionUnderline>& underlines,
+      const std::vector<blink::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end);
   virtual void OnImeConfirmComposition(const string16& text,
                                        const gfx::Range& replacement_range,
                                        bool keep_selection);
   void OnPaintAtSize(const TransportDIB::Handle& dib_id,
                      int tag,
                      const gfx::Size& page_size,
                      const gfx::Size& desired_size);
   void OnRepaint(gfx::Size size_to_paint);
   void OnSyntheticGestureCompleted();
-  void OnSetTextDirection(WebKit::WebTextDirection direction);
+  void OnSetTextDirection(blink::WebTextDirection direction);
   void OnGetFPS();
   void OnUpdateScreenRects(const gfx::Rect& view_screen_rect,
                            const gfx::Rect& window_screen_rect);
 #if defined(OS_ANDROID)
   void OnShowImeIfNeeded();
 
   // Whenever an IME event that needs an acknowledgement is sent to the browser,
   // the number of outstanding IME events that needs acknowledgement should be
   // incremented. All IME events will be dropped until we receive an ack from
   // the browser.
@@ skipping 93 matching lines @@
 
   // Checks if the selection bounds have been changed. If they are changed,
   // the new value will be sent to the browser process.
   virtual void UpdateSelectionBounds();
 
   // Override point to obtain that the current input method state and caret
   // position.
   virtual ui::TextInputType GetTextInputType();
   virtual void GetSelectionBounds(gfx::Rect* start, gfx::Rect* end);
   virtual ui::TextInputType WebKitToUiTextInputType(
-      WebKit::WebTextInputType type);
+      blink::WebTextInputType type);
 
 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
   // Checks if the composition range or composition character bounds have been
   // changed. If they are changed, the new value will be sent to the browser
   // process.
   void UpdateCompositionInfo(bool should_update_range);
 
   // Override point to obtain that the current composition character bounds.
   // In the case of surrogate pairs, the character is treated as two characters:
   // the bounds for first character is actual one, and the bounds for second
@@ skipping 19 matching lines @@
   // Tells the renderer it does not have focus. Used to prevent us from getting
   // the focus on our own when the browser did not focus us.
   void ClearFocus();
 
   // Set the pending window rect.
   // Because the real render_widget is hosted in another process, there is
   // a time period where we may have set a new window rect which has not yet
   // been processed by the browser.  So we maintain a pending window rect
   // size.  If JS code sets the WindowRect, and then immediately calls
   // GetWindowRect() we'll use this pending window rect as the size.
-  void SetPendingWindowRect(const WebKit::WebRect& r);
+  void SetPendingWindowRect(const blink::WebRect& r);
 
   // Called by OnHandleInputEvent() to notify subclasses that a key event was
   // just handled.
   virtual void DidHandleKeyEvent() {}
 
   // Called by OnHandleInputEvent() to notify subclasses that a mouse event is
   // about to be handled.
   // Returns true if no further handling is needed. In that case, the event
   // won't be sent to WebKit or trigger DidHandleMouseEvent().
-  virtual bool WillHandleMouseEvent(const WebKit::WebMouseEvent& event);
+  virtual bool WillHandleMouseEvent(const blink::WebMouseEvent& event);
 
   // Called by OnHandleInputEvent() to notify subclasses that a key event is
   // about to be handled.
   // Returns true if no further handling is needed. In that case, the event
   // won't be sent to WebKit or trigger DidHandleKeyEvent().
-  virtual bool WillHandleKeyEvent(const WebKit::WebKeyboardEvent& event);
+  virtual bool WillHandleKeyEvent(const blink::WebKeyboardEvent& event);
 
   // Called by OnHandleInputEvent() to notify subclasses that a gesture event is
   // about to be handled.
   // Returns true if no further handling is needed. In that case, the event
   // won't be sent to WebKit.
-  virtual bool WillHandleGestureEvent(const WebKit::WebGestureEvent& event);
+  virtual bool WillHandleGestureEvent(const blink::WebGestureEvent& event);
 
   // Called by OnHandleInputEvent() to notify subclasses that a mouse event was
   // just handled.
-  virtual void DidHandleMouseEvent(const WebKit::WebMouseEvent& event) {}
+  virtual void DidHandleMouseEvent(const blink::WebMouseEvent& event) {}
 
   // Called by OnHandleInputEvent() to notify subclasses that a touch event was
   // just handled.
-  virtual void DidHandleTouchEvent(const WebKit::WebTouchEvent& event) {}
+  virtual void DidHandleTouchEvent(const blink::WebTouchEvent& event) {}
 
   // Check whether the WebWidget has any touch event handlers registered
   // at the given point.
   virtual bool HasTouchEventHandlersAt(const gfx::Point& point) const;
 
   // Check whether the WebWidget has any touch event handlers registered.
   virtual void hasTouchEventHandlers(bool has_handlers);
 
   // Creates a 3D context associated with this view.
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateGraphicsContext3D(
-      const WebKit::WebGraphicsContext3D::Attributes& attributes);
+      const blink::WebGraphicsContext3D::Attributes& attributes);
 
   bool OnSnapshotHelper(const gfx::Rect& src_subrect, SkBitmap* bitmap);
 
   void ScheduleCompositeImpl(bool force_redraw);
 
   // Routing ID that allows us to communicate to the parent browser process
   // RenderWidgetHost. When MSG_ROUTING_NONE, no messages may be sent.
   int32 routing_id_;
 
   int32 surface_id_;
 
   // We are responsible for destroying this object via its Close method.
-  WebKit::WebWidget* webwidget_;
+  blink::WebWidget* webwidget_;
 
   // This is lazily constructed and must not outlive webwidget_.
   scoped_ptr<RenderWidgetCompositor> compositor_;
 
   // Set to the ID of the view that initiated creating this view, if any. When
   // the view was initiated by the browser (the common case), this will be
   // MSG_ROUTING_NONE. This is used in determining ownership when opening
   // child tabs. See RenderWidget::createWebViewWithRequest.
   //
   // This ID may refer to an invalid view if that view is closed before this
@@ skipping 91 matching lines @@
 
   // Whether this RenderWidget is currently swapped out, such that the view is
   // being rendered by another process.  If all RenderWidgets in a process are
   // swapped out, the process can exit.
   bool is_swapped_out_;
 
   // Indicates if an input method is active in the browser process.
   bool input_method_is_active_;
 
   // Stores information about the current text input.
-  WebKit::WebTextInputInfo text_input_info_;
+  blink::WebTextInputInfo text_input_info_;
 
   // Stores the current text input type of |webwidget_|.
   ui::TextInputType text_input_type_;
 
   // Stores the current text input mode of |webwidget_|.
   ui::TextInputMode text_input_mode_;
 
   // Stores the current type of composition text rendering of |webwidget_|.
   bool can_compose_inline_;
 
   // Stores the current selection bounds.
   gfx::Rect selection_focus_rect_;
   gfx::Rect selection_anchor_rect_;
 
   // Stores the current composition character bounds.
   std::vector<gfx::Rect> composition_character_bounds_;
 
   // Stores the current composition range.
   gfx::Range composition_range_;
 
   // The kind of popup this widget represents, NONE if not a popup.
-  WebKit::WebPopupType popup_type_;
+  blink::WebPopupType popup_type_;
 
   // Holds all the needed plugin window moves for a scroll.
   typedef std::vector<WebPluginGeometry> WebPluginGeometryVector;
   WebPluginGeometryVector plugin_window_moves_;
 
   // A custom background for the widget.
   SkBitmap background_;
 
   // While we are waiting for the browser to update window sizes, we track the
   // pending size temporarily.
   int pending_window_rect_count_;
-  WebKit::WebRect pending_window_rect_;
+  blink::WebRect pending_window_rect_;
 
   // The screen rects of the view and the window that contains it.
   gfx::Rect view_screen_rect_;
   gfx::Rect window_screen_rect_;
 
   scoped_ptr<IPC::Message> pending_input_event_ack_;
 
   // The time spent in input handlers this frame. Used to throttle input acks.
   base::TimeDelta total_input_handling_time_this_frame_;
 
@@ skipping 25 matching lines @@
   scoped_ptr<ViewHostMsg_UpdateRect_Params> pending_update_params_;
 
   // Queue of UpdateRect messages corresponding to a SwapBuffers. We want to
   // delay sending of UpdateRect until the corresponding SwapBuffers has been
   // executed. Since we can have several in flight, we need to keep them in a
   // queue. Note: some SwapBuffers may not correspond to an update, in which
   // case NULL is added to the queue.
   std::deque<ViewHostMsg_UpdateRect*> updates_pending_swap_;
 
   // Properties of the screen hosting this RenderWidget instance.
-  WebKit::WebScreenInfo screen_info_;
+  blink::WebScreenInfo screen_info_;
 
   // The device scale factor. This value is computed from the DPI entries in
   // |screen_info_| on some platforms, and defaults to 1 on other platforms.
   float device_scale_factor_;
 
   // State associated with the synthetic gestures function
   // (e.g. BeginSmoothScroll).
   SyntheticGestureCompletionCallback pending_synthetic_gesture_;
 
   // Specified whether the compositor will run in its own thread.
@@ skipping 27 matching lines @@
   scoped_ptr<ResizingModeSelector> resizing_mode_selector_;
 
   base::WeakPtrFactory<RenderWidget> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidget);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_WIDGET_H_