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

webkit/tools/test_shell/webwidget_host_gtk.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/tools/test_shell/webwidget_host.h"
 
 #include <cairo/cairo.h>
 #include <gtk/gtk.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/platform_device.h"
 #include "webkit/api/public/gtk/WebInputEventFactory.h"
 #include "webkit/api/public/x11/WebScreenInfoFactory.h"
 #include "webkit/api/public/WebInputEvent.h"
+#include "webkit/api/public/WebPopupMenu.h"
 #include "webkit/api/public/WebScreenInfo.h"
 #include "webkit/api/public/WebSize.h"
-#include "webkit/glue/webwidget.h"
 #include "webkit/tools/test_shell/test_shell.h"
 #include "webkit/tools/test_shell/test_shell_x11.h"
 
 using WebKit::WebInputEventFactory;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
+using WebKit::WebPopupMenu;
 using WebKit::WebScreenInfo;
 using WebKit::WebScreenInfoFactory;
 using WebKit::WebSize;
+using WebKit::WebWidgetClient;
 
 namespace {
 
 // In response to an invalidation, we call into WebKit to do layout. On
 // Windows, WM_PAINT is a virtual message so any extra invalidates that come up
 // while it's doing layout are implicitly swallowed as soon as we actually do
 // drawing via BeginPaint.
 //
 // Though GTK does know how to collapse multiple paint requests, it won't erase
 // paint requests from the future when we start drawing.  To avoid an infinite
@@ skipping 111 matching lines @@
   // The GdkWindow was destroyed.
   static gboolean HandleDestroy(GtkWidget* widget, WebWidgetHost* host) {
     host->WindowDestroyed();
     return FALSE;
   }
 
   // Keyboard key pressed.
   static gboolean HandleKeyPress(GtkWidget* widget,
                                  GdkEventKey* event,
                                  WebWidgetHost* host) {
-    const WebKeyboardEvent& wke = WebInputEventFactory::keyboardEvent(event);
-    host->webwidget()->HandleInputEvent(&wke);
-
+    host->webwidget()->handleInputEvent(
+        WebInputEventFactory::keyboardEvent(event));
     return FALSE;
   }
 
   // Keyboard key released.
   static gboolean HandleKeyRelease(GtkWidget* widget,
                                    GdkEventKey* event,
                                    WebWidgetHost* host) {
     return HandleKeyPress(widget, event, host);
   }
 
   // This signal is called when arrow keys or tab is pressed.  If we return
   // true, we prevent focus from being moved to another widget.  If we want to
   // allow focus to be moved outside of web contents, we need to implement
   // WebViewDelegate::TakeFocus in the test webview delegate.
   static gboolean HandleFocus(GtkWidget* widget,
                               GdkEventFocus* focus,
                               WebWidgetHost* host) {
     return TRUE;
   }
 
   // Keyboard focus entered.
   static gboolean HandleFocusIn(GtkWidget* widget,
                                 GdkEventFocus* focus,
                                 WebWidgetHost* host) {
     // Ignore focus calls in layout test mode so that tests don't mess with each
     // other's focus when running in parallel.
     if (!TestShell::layout_test_mode())
-      host->webwidget()->SetFocus(true);
+      host->webwidget()->setFocus(true);
     return FALSE;
   }
 
   // Keyboard focus left.
   static gboolean HandleFocusOut(GtkWidget* widget,
                                  GdkEventFocus* focus,
                                  WebWidgetHost* host) {
     // Ignore focus calls in layout test mode so that tests don't mess with each
     // other's focus when running in parallel.
     if (!TestShell::layout_test_mode())
-      host->webwidget()->SetFocus(false);
+      host->webwidget()->setFocus(false);
     return FALSE;
   }
 
   // Mouse button down.
   static gboolean HandleButtonPress(GtkWidget* widget,
                                     GdkEventButton* event,
                                     WebWidgetHost* host) {
-    const WebMouseEvent& wme = WebInputEventFactory::mouseEvent(event);
-    host->webwidget()->HandleInputEvent(&wme);
+    host->webwidget()->handleInputEvent(
+        WebInputEventFactory::mouseEvent(event));
     return FALSE;
   }
 
   // Mouse button up.
   static gboolean HandleButtonRelease(GtkWidget* widget,
                                       GdkEventButton* event,
                                       WebWidgetHost* host) {
     return HandleButtonPress(widget, event, host);
   }
 
   // Mouse pointer movements.
   static gboolean HandleMotionNotify(GtkWidget* widget,
                                      GdkEventMotion* event,
                                      WebWidgetHost* host) {
-    const WebMouseEvent& wme = WebInputEventFactory::mouseEvent(event);
-    host->webwidget()->HandleInputEvent(&wme);
+    host->webwidget()->handleInputEvent(
+        WebInputEventFactory::mouseEvent(event));
     return FALSE;
   }
 
   // Mouse scroll wheel.
   static gboolean HandleScroll(GtkWidget* widget,
                                GdkEventScroll* event,
                                WebWidgetHost* host) {
-    const WebMouseWheelEvent& wmwe =
-        WebInputEventFactory::mouseWheelEvent(event);
-    host->webwidget()->HandleInputEvent(&wmwe);
+    host->webwidget()->handleInputEvent(
+        WebInputEventFactory::mouseWheelEvent(event));
     return FALSE;
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebWidgetHostGtkWidget);
 };
 
 }  // namespace
 
 // This is provided so that the webview can reuse the custom GTK window code.
 // static
 gfx::NativeView WebWidgetHost::CreateWidget(
     gfx::NativeView parent_view, WebWidgetHost* host) {
   return WebWidgetHostGtkWidget::CreateNewWidget(parent_view, host);
 }
 
 // static
 WebWidgetHost* WebWidgetHost::Create(GtkWidget* parent_view,
-                                     WebWidgetDelegate* delegate) {
+                                     WebWidgetClient* client) {
   WebWidgetHost* host = new WebWidgetHost();
   host->view_ = CreateWidget(parent_view, host);
-  host->webwidget_ = WebWidget::Create(delegate);
+  host->webwidget_ = WebPopupMenu::create(client);
   // We manage our own double buffering because we need to be able to update
   // the expose area in an ExposeEvent within the lifetime of the event handler.
   gtk_widget_set_double_buffered(GTK_WIDGET(host->view_), false);
 
   return host;
 }
 
 void WebWidgetHost::UpdatePaintRect(const gfx::Rect& rect) {
   paint_rect_ = paint_rect_.Union(rect);
 }
@@ skipping 18 matching lines @@
 WebWidgetHost::WebWidgetHost()
     : view_(NULL),
       webwidget_(NULL),
       scroll_dx_(0),
       scroll_dy_(0),
       track_mouse_leave_(false) {
   set_painting(false);
 }
 
 WebWidgetHost::~WebWidgetHost() {
-  webwidget_->Close();
+  webwidget_->close();
 }
 
 void WebWidgetHost::Resize(const gfx::Size &newsize) {
   // The pixel buffer backing us is now the wrong size
   canvas_.reset();
 
-  webwidget_->Resize(gfx::Size(newsize.width(), newsize.height()));
+  webwidget_->resize(newsize);
 }
 
 void WebWidgetHost::Paint() {
   int width = view_->allocation.width;
   int height = view_->allocation.height;
   gfx::Rect client_rect(width, height);
 
   // Allocate a canvas if necessary
   if (!canvas_.get()) {
     ResetScrollRect();
     paint_rect_ = client_rect;
     canvas_.reset(new skia::PlatformCanvas(width, height, true));
     if (!canvas_.get()) {
       // memory allocation failed, we can't paint.
       LOG(ERROR) << "Failed to allocate memory for " << width << "x" << height;
       return;
     }
   }
 
   // This may result in more invalidation
-  webwidget_->Layout();
+  webwidget_->layout();
 
   // Paint the canvas if necessary.  Allow painting to generate extra rects the
   // first time we call it.  This is necessary because some WebCore rendering
   // objects update their layout only when painted.
   // Store the total area painted in total_paint. Then tell the gdk window
   // to update that area after we're done painting it.
   gfx::Rect total_paint;
   for (int i = 0; i < 2; ++i) {
     paint_rect_ = client_rect.Intersect(paint_rect_);
     if (!paint_rect_.IsEmpty()) {
@@ skipping 37 matching lines @@
   return WebScreenInfoFactory::screenInfo(display, screen_num);
 }
 
 void WebWidgetHost::ResetScrollRect() {
   // This method is only needed for optimized scroll painting, which we don't
   // care about in the test shell, yet.
 }
 
 void WebWidgetHost::PaintRect(const gfx::Rect& rect) {
   set_painting(true);
-  webwidget_->Paint(canvas_.get(), rect);
+  webwidget_->paint(canvas_.get(), rect);
   set_painting(false);
 }
 
 void WebWidgetHost::WindowDestroyed() {
   delete this;
 }