Bulk fixes to get Mac Test Shell more compile-happy.

webkit/tools/test_shell/webwidget_host.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/platform_canvas.h"
 #include "base/gfx/platform_canvas_win.h"
 #include "base/gfx/rect.h"
 #include "base/logging.h"
 #include "base/win_util.h"
 #include "webkit/glue/webinputevent.h"
 #include "webkit/glue/webwidget.h"
 
 static const wchar_t kWindowClassName[] = L"WebWidgetHost";
 
 /*static*/
-WebWidgetHost* WebWidgetHost::Create(HWND parent_window, WebWidgetDelegate* delegate) {
+WebWidgetHost* WebWidgetHost::Create(gfx::WindowHandle parent_window,
+                                     WebWidgetDelegate* delegate) {
   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->hwnd_ = CreateWindowEx(WS_EX_TOOLWINDOW,
+  host->view_ = CreateWindowEx(WS_EX_TOOLWINDOW,
                                kWindowClassName, kWindowClassName, WS_POPUP,
                                0, 0, 0, 0,
                                parent_window, NULL, GetModuleHandle(NULL), NULL);
 
-  win_util::SetWindowUserData(host->hwnd_, host);
+  win_util::SetWindowUserData(host->view_, host);
 
   host->webwidget_ = WebWidget::Create(delegate);
 
   return host;
 }
 
 /*static*/
-WebWidgetHost* WebWidgetHost::FromWindow(HWND hwnd) {
+WebWidgetHost* WebWidgetHost::FromWindow(gfx::WindowHandle hwnd) {
   return reinterpret_cast<WebWidgetHost*>(win_util::GetWindowUserData(hwnd));
 }
 
 /*static*/
 LRESULT CALLBACK WebWidgetHost::WndProc(HWND hwnd, UINT message, WPARAM wparam,
                                         LPARAM lparam) {
   WebWidgetHost* host = FromWindow(hwnd);
   if (host && !host->WndProc(message, wparam, lparam)) {
     switch (message) {
       case WM_DESTROY:
@@ skipping 65 matching lines @@
 
   // If this invalidate overlaps with a pending scroll, then we have to
   // downgrade to invalidating the scroll rect.
   if (damaged_rect.Intersects(scroll_rect_)) {
     paint_rect_ = paint_rect_.Union(scroll_rect_);
     ResetScrollRect();
   }
   paint_rect_ = paint_rect_.Union(damaged_rect);
 
   RECT r = damaged_rect.ToRECT();
-  InvalidateRect(hwnd_, &r, FALSE);
+  InvalidateRect(view_, &r, FALSE);
 }
 
 void WebWidgetHost::DidScrollRect(int dx, int dy, const gfx::Rect& clip_rect) {
   DCHECK(dx || dy);
 
   // If we already have a pending scroll operation or if this scroll operation
   // intersects the existing paint region, then just failover to invalidating.
   if (!scroll_rect_.IsEmpty() || paint_rect_.Intersects(clip_rect)) {
     paint_rect_ = paint_rect_.Union(scroll_rect_);
     ResetScrollRect();
     paint_rect_ = paint_rect_.Union(clip_rect);
   }
 
   // We will perform scrolling lazily, when requested to actually paint.
   scroll_rect_ = clip_rect;
   scroll_dx_ = dx;
   scroll_dy_ = dy;
 
   RECT r = clip_rect.ToRECT();
-  InvalidateRect(hwnd_, &r, FALSE);
+  InvalidateRect(view_, &r, FALSE);
 }
 
 void WebWidgetHost::SetCursor(HCURSOR cursor) {
-  SetClassLong(hwnd_, GCL_HCURSOR,
+  SetClassLong(view_, GCL_HCURSOR,
       static_cast<LONG>(reinterpret_cast<LONG_PTR>(cursor)));
   ::SetCursor(cursor);
 }
 
 void WebWidgetHost::DiscardBackingStore() {
   canvas_.reset();
 }
 
 WebWidgetHost::WebWidgetHost()
-    : hwnd_(NULL),
+    : view_(NULL),
       webwidget_(NULL),
       track_mouse_leave_(false),
       scroll_dx_(0),
       scroll_dy_(0) {
   set_painting(false);
 }
 
 WebWidgetHost::~WebWidgetHost() {
-  win_util::SetWindowUserData(hwnd_, 0);
+  win_util::SetWindowUserData(view_, 0);
 
   TrackMouseLeave(false);
 
   webwidget_->Close();
   webwidget_->Release();
 }
 
 bool WebWidgetHost::WndProc(UINT message, WPARAM wparam, LPARAM lparam) {
   switch (message) {
   case WM_ACTIVATE:
     if (wparam == WA_INACTIVE) {
-      PostMessage(hwnd_, WM_CLOSE, 0, 0);
+      PostMessage(view_, WM_CLOSE, 0, 0);
       return true;
     }
     break;
   }
 
   return false;
 }
 
 void WebWidgetHost::Paint() {
   RECT r;
-  GetClientRect(hwnd_, &r);
+  GetClientRect(view_, &r);
   gfx::Rect client_rect(r);
   
   // Allocate a canvas if necessary
   if (!canvas_.get()) {
     ResetScrollRect();
     paint_rect_ = client_rect;
-    canvas_.reset(new gfx::PlatformCanvasWin(
+    canvas_.reset(new gfx::PlatformCanvas(
         paint_rect_.width(), paint_rect_.height(), true));
   }
 
   // This may result in more invalidation
   webwidget_->Layout();
 
   // Scroll the canvas if necessary
   scroll_rect_ = client_rect.Intersect(scroll_rect_);
   if (!scroll_rect_.IsEmpty()) {
     HDC hdc = canvas_->getTopPlatformDevice().getBitmapDC();
@@ skipping 15 matching lines @@
       paint_rect_ = gfx::Rect();
 
       DLOG_IF(WARNING, i == 1) << "painting caused additional invalidations";
       PaintRect(rect);
     }
   }
   DCHECK(paint_rect_.IsEmpty());
 
   // Paint to the screen
   PAINTSTRUCT ps;
-  BeginPaint(hwnd_, &ps);
+  BeginPaint(view_, &ps);
   canvas_->getTopPlatformDevice().drawToHDC(ps.hdc,
                                             ps.rcPaint.left,
                                             ps.rcPaint.top,
                                             &ps.rcPaint);
-  EndPaint(hwnd_, &ps);
+  EndPaint(view_, &ps);
 
   // Draw children
-  UpdateWindow(hwnd_);
+  UpdateWindow(view_);
 }
 
 void WebWidgetHost::Resize(LPARAM lparam) {
   // Force an entire re-paint.  TODO(darin): Maybe reuse this memory buffer.
   DiscardBackingStore();
 
   webwidget_->Resize(gfx::Size(LOWORD(lparam), HIWORD(lparam)));
 }
 
 void WebWidgetHost::MouseEvent(UINT message, WPARAM wparam, LPARAM lparam) {
-  WebMouseEvent event(hwnd_, message, wparam, lparam);
+  WebMouseEvent event(view_, message, wparam, lparam);
   switch (event.type) {
     case WebInputEvent::MOUSE_MOVE:
       TrackMouseLeave(true);
       break;
     case WebInputEvent::MOUSE_LEAVE:
       TrackMouseLeave(false);
       break;
     case WebInputEvent::MOUSE_DOWN:
-      SetCapture(hwnd_);
+      SetCapture(view_);
       break;
     case WebInputEvent::MOUSE_UP:
-      if (GetCapture() == hwnd_)
+      if (GetCapture() == view_)
         ReleaseCapture();
       break;
   }
   webwidget_->HandleInputEvent(&event);
 }
 
 void WebWidgetHost::WheelEvent(WPARAM wparam, LPARAM lparam) {
-  WebMouseWheelEvent event(hwnd_, WM_MOUSEWHEEL, wparam, lparam);
+  WebMouseWheelEvent event(view_, WM_MOUSEWHEEL, wparam, lparam);
   webwidget_->HandleInputEvent(&event);
 }
 
 void WebWidgetHost::KeyEvent(UINT message, WPARAM wparam, LPARAM lparam) {
-  WebKeyboardEvent event(hwnd_, message, wparam, lparam);
+  WebKeyboardEvent event(view_, message, wparam, lparam);
   webwidget_->HandleInputEvent(&event);
 }
 
 void WebWidgetHost::CaptureLostEvent() {
   webwidget_->MouseCaptureLost();
 }
 
 void WebWidgetHost::SetFocus(bool enable) {
   webwidget_->SetFocus(enable);
 }
 
 void WebWidgetHost::TrackMouseLeave(bool track) {
   if (track == track_mouse_leave_)
     return;
   track_mouse_leave_ = track;
 
-  DCHECK(hwnd_);
+  DCHECK(view_);
 
   TRACKMOUSEEVENT tme;
   tme.cbSize = sizeof(TRACKMOUSEEVENT);
   tme.dwFlags = TME_LEAVE;
   if (!track_mouse_leave_)
     tme.dwFlags |= TME_CANCEL;
-  tme.hwndTrack = hwnd_;
+  tme.hwndTrack = view_;
 
   TrackMouseEvent(&tme);
 }
 
 void WebWidgetHost::ResetScrollRect() {
   scroll_rect_ = gfx::Rect();
   scroll_dx_ = 0;
   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);
   set_painting(false);
 }
-