Handle resize corner layout entirely in the platform BrowserWindow*/BrowserView* code...

chrome/browser/renderer_host/render_widget_host_view_win.cc

 // Copyright (c) 2010 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 "chrome/browser/renderer_host/render_widget_host_view_win.h"
 
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
 #include "app/resource_bundle.h"
 #include "app/win/scoped_prop.h"
@@ skipping 560 matching lines @@
   GetWindowRect(&window_rect);
   return gfx::Rect(window_rect);
 }
 
 void RenderWidgetHostViewWin::UpdateCursor(const WebCursor& cursor) {
   current_cursor_ = cursor;
   UpdateCursorIfOverSelf();
 }
 
 void RenderWidgetHostViewWin::UpdateCursorIfOverSelf() {
-  static HCURSOR kCursorResizeRight = LoadCursor(NULL, IDC_SIZENWSE);
-  static HCURSOR kCursorResizeLeft = LoadCursor(NULL, IDC_SIZENESW);
   static HCURSOR kCursorArrow = LoadCursor(NULL, IDC_ARROW);
   static HCURSOR kCursorAppStarting = LoadCursor(NULL, IDC_APPSTARTING);
   static HINSTANCE module_handle =
       GetModuleHandle(chrome::kBrowserResourcesDll);
 
   // If the mouse is over our HWND, then update the cursor state immediately.
   CPoint pt;
   GetCursorPos(&pt);
   if (WindowFromPoint(pt) == m_hWnd) {
     BOOL result = ::ScreenToClient(m_hWnd, &pt);
     DCHECK(result);
-    if (render_widget_host_->GetRootWindowResizerRect().Contains(pt.x, pt.y)) {
-      if (base::i18n::IsRTL())
-        SetCursor(kCursorResizeLeft);
-      else
-        SetCursor(kCursorResizeRight);
-    } else {
-      // We cannot pass in NULL as the module handle as this would only work for
-      // standard win32 cursors. We can also receive cursor types which are
-      // defined as webkit resources. We need to specify the module handle of
-      // chrome.dll while loading these cursors.
-      HCURSOR display_cursor = current_cursor_.GetCursor(module_handle);
+    // We cannot pass in NULL as the module handle as this would only work for
+    // standard win32 cursors. We can also receive cursor types which are
+    // defined as webkit resources. We need to specify the module handle of
+    // chrome.dll while loading these cursors.
+    HCURSOR display_cursor = current_cursor_.GetCursor(module_handle);
 
-      // If a page is in the loading state, we want to show the Arrow+Hourglass
-      // cursor only when the current cursor is the ARROW cursor. In all other
-      // cases we should continue to display the current cursor.
-      if (is_loading_ && display_cursor == kCursorArrow)
-        display_cursor = kCursorAppStarting;
+    // If a page is in the loading state, we want to show the Arrow+Hourglass
+    // cursor only when the current cursor is the ARROW cursor. In all other
+    // cases we should continue to display the current cursor.
+    if (is_loading_ && display_cursor == kCursorArrow)
+      display_cursor = kCursorAppStarting;
 
-      SetCursor(display_cursor);
-    }
+    SetCursor(display_cursor);
   }
 }
 
 void RenderWidgetHostViewWin::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
   UpdateCursorIfOverSelf();
 }
 
 void RenderWidgetHostViewWin::ImeUpdateTextInputState(
     WebKit::WebTextInputType type,
@@ skipping 53 matching lines @@
 
   // Send the invalid rect in screen coordinates.
   gfx::Rect screen_rect = GetViewBounds();
   gfx::Rect invalid_screen_rect(damage_bounds);
   invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
 
   LPARAM lparam = reinterpret_cast<LPARAM>(&invalid_screen_rect);
   EnumChildWindows(m_hWnd, EnumChildProc, lparam);
 }
 
-void RenderWidgetHostViewWin::DrawResizeCorner(const gfx::Rect& paint_rect,
-                                               HDC dc) {
-  gfx::Rect resize_corner_rect =
-      render_widget_host_->GetRootWindowResizerRect();
-  if (!paint_rect.Intersect(resize_corner_rect).IsEmpty()) {
-    SkBitmap* bitmap = ResourceBundle::GetSharedInstance().
-        GetBitmapNamed(IDR_TEXTAREA_RESIZER);
-    gfx::CanvasSkia canvas(bitmap->width(), bitmap->height(), false);
-    canvas.getDevice()->accessBitmap(true).eraseARGB(0, 0, 0, 0);
-    int x = resize_corner_rect.x() + resize_corner_rect.width() -
-        bitmap->width();
-    canvas.save();
-    if (base::i18n::IsRTL()) {
-      canvas.TranslateInt(bitmap->width(), 0);
-      canvas.ScaleInt(-1, 1);
-      x = 0;
-    }
-    canvas.DrawBitmapInt(*bitmap, 0, 0);
-    canvas.getTopPlatformDevice().drawToHDC(dc, x,
-        resize_corner_rect.y() + resize_corner_rect.height() -
-        bitmap->height(), NULL);
-    canvas.restore();
-  }
-}
-
 void RenderWidgetHostViewWin::DidUpdateBackingStore(
     const gfx::Rect& scroll_rect, int scroll_dx, int scroll_dy,
     const std::vector<gfx::Rect>& copy_rects) {
   if (is_hidden_)
     return;
 
   // Schedule invalidations first so that the ScrollWindowEx call is closer to
   // Redraw.  That minimizes chances of "flicker" resulting if the screen
   // refreshes before we have a chance to paint the exposed area.  Somewhat
   // surprisingly, this ordering matters.
@@ skipping 196 matching lines @@
     // Blit only the damaged regions from the backing store.
     DWORD data_size = GetRegionData(damage_region, 0, NULL);
     scoped_array<char> region_data_buf(new char[data_size]);
     RGNDATA* region_data = reinterpret_cast<RGNDATA*>(region_data_buf.get());
     GetRegionData(damage_region, data_size, region_data);
 
     RECT* region_rects = reinterpret_cast<RECT*>(region_data->Buffer);
     for (DWORD i = 0; i < region_data->rdh.nCount; ++i) {
       gfx::Rect paint_rect = bitmap_rect.Intersect(gfx::Rect(region_rects[i]));
       if (!paint_rect.IsEmpty()) {
-        DrawResizeCorner(paint_rect, backing_store->hdc());
         if (visually_deemphasized_) {
           DrawDeemphasized(paint_rect, backing_store->hdc(), paint_dc.m_hDC);
         } else {
           BitBlt(paint_dc.m_hDC,
                  paint_rect.x(),
                  paint_rect.y(),
                  paint_rect.width(),
                  paint_rect.height(),
                  backing_store->hdc(),
                  paint_rect.x(),
@@ skipping 307 matching lines @@
   // TabContents first in the case of popups.  If we do, we would need to
   // convert the click from the popup window coordinates to the TabContents'
   // window coordinates. For now we don't forward the message in that case to
   // address bug #907474.
   // Note: GetParent() on popup windows returns the top window and not the
   // parent the window was created with (the parent and the owner of the popup
   // is the first non-child view of the view that was specified to the create
   // call).  So the TabContents window would have to be specified to the
   // RenderViewHostHWND as there is no way to retrieve it from the HWND.
   if (!close_on_deactivate_) {  // Don't forward if the container is a popup.
-    if (message == WM_LBUTTONDOWN) {
-      // If we get clicked on, where the resize corner is drawn, we delegate the
-      // message to the root window, with the proper HTBOTTOMXXX wparam so that
-      // Windows can take care of the resizing for us.
-      if (render_widget_host_ &&
-          render_widget_host_->GetRootWindowResizerRect().
-              Contains(GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam))) {
-        WPARAM wparam = HTBOTTOMRIGHT;
-        if (base::i18n::IsRTL())
-          wparam = HTBOTTOMLEFT;
-        HWND root_hwnd = ::GetAncestor(m_hWnd, GA_ROOT);
-        if (SendMessage(root_hwnd, WM_NCLBUTTONDOWN, wparam, lparam) == 0)
-          return 0;
-      }
-    }
     switch (message) {
       case WM_LBUTTONDOWN:
       case WM_MBUTTONDOWN:
       case WM_RBUTTONDOWN:
         // Finish the ongoing composition whenever a mouse click happens.
         // It matches IE's behavior.
         ime_input_.CleanupComposition(m_hWnd);
         // Fall through.
       case WM_MOUSEMOVE:
       case WM_MOUSELEAVE: {
@@ skipping 405 matching lines @@
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView native_view) {
   if (::IsWindow(native_view)) {
     HANDLE raw_render_host_view = ::GetProp(native_view,
                                             kRenderWidgetHostViewKey);
     if (raw_render_host_view)
       return reinterpret_cast<RenderWidgetHostView*>(raw_render_host_view);
   }
   return NULL;
 }