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

webkit/tools/test_shell/webwidget_host_win.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 "base/gfx/rect.h"
 #include "base/logging.h"
 #include "base/win_util.h"
 #include "skia/ext/platform_canvas.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/api/public/win/WebInputEventFactory.h"
 #include "webkit/api/public/win/WebScreenInfoFactory.h"
-#include "webkit/glue/webwidget.h"
 #include "webkit/tools/test_shell/test_shell.h"
 
 using WebKit::WebInputEvent;
 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::WebWidget;
+using WebKit::WebWidgetClient;
 
 static const wchar_t kWindowClassName[] = L"WebWidgetHost";
 
 /*static*/
 WebWidgetHost* WebWidgetHost::Create(HWND parent_view,
-                                     WebWidgetDelegate* delegate) {
+                                     WebWidgetClient* client) {
   WebWidgetHost* host = new WebWidgetHost();
 
   static bool registered_class = false;
   if (!registered_class) {
     WNDCLASSEX wcex = {0};
     wcex.cbSize        = sizeof(wcex);
     wcex.style         = CS_DBLCLKS;
     wcex.lpfnWndProc   = WebWidgetHost::WndProc;
     wcex.hInstance     = GetModuleHandle(NULL);
     wcex.hCursor       = LoadCursor(NULL, IDC_ARROW);
     wcex.lpszClassName = kWindowClassName;
     RegisterClassEx(&wcex);
     registered_class = true;
   }
 
   host->view_ = CreateWindowEx(WS_EX_TOOLWINDOW,
                                kWindowClassName, kWindowClassName, WS_POPUP,
                                0, 0, 0, 0,
                                parent_view, NULL, GetModuleHandle(NULL), NULL);
   win_util::SetWindowUserData(host->view_, host);
 
-  host->webwidget_ = WebWidget::Create(delegate);
+  host->webwidget_ = WebPopupMenu::create(client);
 
   return host;
 }
 
 static WebWidgetHost* FromWindow(HWND view) {
   return reinterpret_cast<WebWidgetHost*>(win_util::GetWindowUserData(view));
 }
 
 /*static*/
 LRESULT CALLBACK WebWidgetHost::WndProc(HWND hwnd, UINT message, WPARAM wparam,
@@ skipping 126 matching lines @@
       scroll_dx_(0),
       scroll_dy_(0) {
   set_painting(false);
 }
 
 WebWidgetHost::~WebWidgetHost() {
   win_util::SetWindowUserData(view_, 0);
 
   TrackMouseLeave(false);
 
-  webwidget_->Close();
+  webwidget_->close();
 }
 
 bool WebWidgetHost::WndProc(UINT message, WPARAM wparam, LPARAM lparam) {
   switch (message) {
   case WM_ACTIVATE:
     if (wparam == WA_INACTIVE) {
       PostMessage(view_, WM_CLOSE, 0, 0);
       return true;
     }
     break;
@@ skipping 13 matching lines @@
 
   // Allocate a canvas if necessary
   if (!canvas_.get()) {
     ResetScrollRect();
     paint_rect_ = client_rect;
     canvas_.reset(new skia::PlatformCanvas(
         paint_rect_.width(), paint_rect_.height(), true));
   }
 
   // This may result in more invalidation
-  webwidget_->Layout();
+  webwidget_->layout();
 
   // Scroll the canvas if necessary
   scroll_rect_ = client_rect.Intersect(scroll_rect_);
   if (!scroll_rect_.IsEmpty()) {
     HDC hdc = canvas_->getTopPlatformDevice().getBitmapDC();
 
     RECT damaged_rect, r = scroll_rect_.ToRECT();
     ScrollDC(hdc, scroll_dx_, scroll_dy_, NULL, &r, NULL, &damaged_rect);
 
     PaintRect(gfx::Rect(damaged_rect));
@@ skipping 29 matching lines @@
 }
 
 WebScreenInfo WebWidgetHost::GetScreenInfo() {
   return WebScreenInfoFactory::screenInfo(view_);
 }
 
 void WebWidgetHost::Resize(LPARAM lparam) {
   // Force an entire re-paint.  TODO(darin): Maybe reuse this memory buffer.
   DiscardBackingStore();
 
-  webwidget_->Resize(WebSize(LOWORD(lparam), HIWORD(lparam)));
+  webwidget_->resize(WebSize(LOWORD(lparam), HIWORD(lparam)));
 }
 
 void WebWidgetHost::MouseEvent(UINT message, WPARAM wparam, LPARAM lparam) {
   const WebMouseEvent& event = WebInputEventFactory::mouseEvent(
       view_, message, wparam, lparam);
   switch (event.type) {
     case WebInputEvent::MouseMove:
       TrackMouseLeave(true);
       break;
     case WebInputEvent::MouseLeave:
       TrackMouseLeave(false);
       break;
     case WebInputEvent::MouseDown:
       SetCapture(view_);
       // This mimics a temporary workaround in RenderWidgetHostViewWin for bug
       // 765011 to get focus when the mouse is clicked. This happens after the
       // mouse down event is sent to the renderer because normally Windows does
       // a WM_SETFOCUS after WM_LBUTTONDOWN.
       ::SetFocus(view_);
       break;
     case WebInputEvent::MouseUp:
       if (GetCapture() == view_)
         ReleaseCapture();
       break;
   }
-  webwidget_->HandleInputEvent(&event);
+  webwidget_->handleInputEvent(event);
 }
 
 void WebWidgetHost::WheelEvent(WPARAM wparam, LPARAM lparam) {
   const WebMouseWheelEvent& event = WebInputEventFactory::mouseWheelEvent(
       view_, WM_MOUSEWHEEL, wparam, lparam);
-  webwidget_->HandleInputEvent(&event);
+  webwidget_->handleInputEvent(event);
 }
 
 void WebWidgetHost::KeyEvent(UINT message, WPARAM wparam, LPARAM lparam) {
   const WebKeyboardEvent& event = WebInputEventFactory::keyboardEvent(
       view_, message, wparam, lparam);
-  webwidget_->HandleInputEvent(&event);
+  webwidget_->handleInputEvent(event);
 }
 
 void WebWidgetHost::CaptureLostEvent() {
-  webwidget_->MouseCaptureLost();
+  webwidget_->mouseCaptureLost();
 }
 
 void WebWidgetHost::SetFocus(bool enable) {
   // 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())
-    webwidget_->SetFocus(enable);
+    webwidget_->setFocus(enable);
 }
 
 void WebWidgetHost::TrackMouseLeave(bool track) {
   if (track == track_mouse_leave_)
     return;
   track_mouse_leave_ = track;
 
   DCHECK(view_);
 
   TRACKMOUSEEVENT tme;
@@ skipping 12 matching lines @@
   scroll_dy_ = 0;
 }
 
 void WebWidgetHost::PaintRect(const gfx::Rect& rect) {
 #ifndef NDEBUG
   DCHECK(!painting_);
 #endif
   DCHECK(canvas_.get());
 
   set_painting(true);
-  webwidget_->Paint(canvas_.get(), rect);
+  webwidget_->paint(canvas_.get(), rect);
   set_painting(false);
 }