Use WebWidget from the WebKit API. This change also makes...

chrome/renderer/render_widget.h

 // Copyright (c) 2009 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 CHROME_RENDERER_RENDER_WIDGET_H_
 #define CHROME_RENDERER_RENDER_WIDGET_H_
 
 #include <vector>
 #include "base/basictypes.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/gfx/point.h"
 #include "base/gfx/rect.h"
 #include "base/gfx/size.h"
 #include "base/ref_counted.h"
 #include "base/shared_memory.h"
 #include "chrome/common/ipc_channel.h"
 #include "chrome/renderer/render_process.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
-
+#include "webkit/api/public/WebCompositionCommand.h"
 #include "webkit/api/public/WebRect.h"
-#include "webkit/glue/webwidget_delegate.h"
+#include "webkit/api/public/WebTextDirection.h"
+#include "webkit/api/public/WebWidgetClient.h"
 #include "webkit/glue/webcursor.h"
 
 class RenderThreadBase;
 struct ViewHostMsg_ShowPopup_Params;
 struct WebPluginGeometry;
 
 namespace WebKit {
 struct WebPopupMenuInfo;
 }
 
 // RenderWidget provides a communication bridge between a WebWidget and
 // a RenderWidgetHost, the latter of which lives in a different process.
 class RenderWidget : public IPC::Channel::Listener,
                      public IPC::Message::Sender,
-                     virtual public WebWidgetDelegate,
+                     virtual public WebKit::WebWidgetClient,
                      public base::RefCounted<RenderWidget> {
  public:
   // Creates a new RenderWidget.  The opener_id is the routing ID of the
   // RenderView that this widget lives inside. The render_thread is any
   // RenderThreadBase implementation, mostly commonly RenderThread::current().
   static RenderWidget* Create(int32 opener_id,
                               RenderThreadBase* render_thread,
                               bool activatable);
 
   // Called after Create to configure a RenderWidget to be rendered by the host
   // as a popup menu with the given data.
   void ConfigureAsExternalPopupMenu(const WebKit::WebPopupMenuInfo& info);
 
   // 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_;
   }
 
   // May return NULL when the window is closing.
-  WebWidget* webwidget() const {
+  WebKit::WebWidget* webwidget() const {
     return webwidget_;
   }
 
   // IPC::Channel::Listener
   virtual void OnMessageReceived(const IPC::Message& msg);
 
   // IPC::Message::Sender
   virtual bool Send(IPC::Message* msg);
 
-  // WebWidgetDelegate
-  virtual void DidInvalidateRect(WebWidget* webwidget,
-                                 const WebKit::WebRect& rect);
-  virtual void DidScrollRect(WebWidget* webwidget, int dx, int dy,
-                             const WebKit::WebRect& clip_rect);
-  virtual void Show(WebWidget* webwidget, WindowOpenDisposition disposition);
-  virtual void CloseWidgetSoon(WebWidget* webwidget);
-  virtual void Focus(WebWidget* webwidget);
-  virtual void Blur(WebWidget* webwidget);
-  virtual void SetCursor(WebWidget* webwidget,
-                         const WebKit::WebCursorInfo& cursor);
-  virtual void GetWindowRect(WebWidget* webwidget, WebKit::WebRect* rect);
-  virtual void SetWindowRect(WebWidget* webwidget,
-                             const WebKit::WebRect& rect);
-  virtual void GetRootWindowRect(WebWidget* webwidget, WebKit::WebRect* rect);
-  virtual void GetRootWindowResizerRect(WebWidget* webwidget,
-                                        WebKit::WebRect* rect);
-  virtual void DidMove(WebWidget* webwidget, const WebPluginGeometry& move);
-  virtual void RunModal(WebWidget* webwidget) {}
-  virtual bool IsHidden(WebWidget* webwidget) { return is_hidden_; }
-  virtual WebKit::WebScreenInfo GetScreenInfo(WebWidget* webwidget);
+  // WebKit::WebWidgetClient
+  virtual void didInvalidateRect(const WebKit::WebRect&);
+  virtual void didScrollRect(int dx, int dy, const WebKit::WebRect& clipRect);
+  virtual void didFocus();
+  virtual void didBlur();
+  virtual void didChangeCursor(const WebKit::WebCursorInfo&);
+  virtual void closeWidgetSoon();
+  virtual void show(WebKit::WebNavigationPolicy);
+  virtual void runModal() {}
+  virtual WebKit::WebRect windowRect();
+  virtual void setWindowRect(const WebKit::WebRect&);
+  virtual WebKit::WebRect windowResizerRect();
+  virtual WebKit::WebRect rootWindowRect();
+  virtual WebKit::WebScreenInfo screenInfo();
+
+  // 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);
 
   // Invalidates entire widget rect to generate a full repaint.
   void GenerateFullRepaint();
 
   // Close the underlying WebWidget.
   void Close();
 
  protected:
   // Friend RefCounted so that the dtor can be non-public. Using this class
   // without ref-counting is an error.
@@ skipping 31 matching lines @@
                         const gfx::Rect& resizer_rect);
   void OnWasHidden();
   void OnWasRestored(bool needs_repainting);
   void OnPaintRectAck();
   void OnScrollRectAck();
   void OnRequestMoveAck();
   void OnHandleInputEvent(const IPC::Message& message);
   void OnMouseCaptureLost();
   void OnSetFocus(bool enable);
   void OnImeSetInputMode(bool is_active);
-  void OnImeSetComposition(int string_type, int cursor_position,
+  void OnImeSetComposition(WebKit::WebCompositionCommand command,
+                           int cursor_position,
                            int target_start, int target_end,
-                           const std::wstring& ime_string);
+                           const string16& ime_string);
   void OnMsgRepaint(const gfx::Size& size_to_paint);
-  void OnSetTextDirection(int direction);
+  void OnSetTextDirection(WebKit::WebTextDirection direction);
 
   // Override point to notify that a paint has happened. This fires after the
   // browser side has updated the screen for a newly painted region.
   virtual void DidPaint() {}
 
   // True if a PaintRect_ACK message is pending.
   bool paint_reply_pending() const {
     return paint_reply_pending_;
   }
 
@@ skipping 25 matching lines @@
   // 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);
 
   // 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_;
 
   // We are responsible for destroying this object via its Close method.
-  WebWidget* webwidget_;
+  WebKit::WebWidget* webwidget_;
 
   // 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
   // view is.
   int32 opener_id_;
 
@@ skipping 91 matching lines @@
   // we track the pending size temporarily.
   int pending_window_rect_count_;
   WebKit::WebRect pending_window_rect_;
 
   scoped_ptr<ViewHostMsg_ShowPopup_Params> popup_params_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidget);
 };
 
 #endif  // CHROME_RENDERER_RENDER_WIDGET_H_