Change grow box computation back to a method on BrowserWindow

content/browser/renderer_host/render_widget_host_view_win.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_win.h"
 
 #include <algorithm>
 #include <peninputpanel_i.c>
 
 #include "base/bind.h"
@@ skipping 664 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(
       content::GetContentClient()->browser()->GetResourceDllName());
 
   // If the mouse is over our HWND, then update the cursor state immediately.
   CPoint pt;
   GetCursorPos(&pt);
   if (WindowFromPoint(pt) == m_hWnd) {
-    // 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);
+    BOOL result = ::ScreenToClient(m_hWnd, &pt);
+    DCHECK(result);
+    if (render_widget_host_->GetRootWindowResizerRect().Contains(pt.x, pt.y)) {
+      SetCursor(base::i18n::IsRTL() ? kCursorResizeLeft : 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);
 
-    // 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::TextInputStateChanged(
     ui::TextInputType type,
@@ skipping 70 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 218 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());
         BitBlt(paint_dc.m_hDC,
                paint_rect.x(),
                paint_rect.y(),
                paint_rect.width(),
                paint_rect.height(),
                backing_store->hdc(),
                paint_rect.x(),
                paint_rect.y(),
                SRCCOPY);
       }
@@ skipping 373 matching lines @@
   // 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.
 
   // Don't forward if the container is a popup or fullscreen widget.
   if (!is_fullscreen_ && !close_on_deactivate_) {
+    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 1131 matching lines @@
 void RenderWidgetHostViewWin::ResetPointerDownContext() {
   // If the default focus on the page is on an edit field and we did not
   // receive a focus change in the context of a pointer down message, it means
   // that the pointer down message occurred on the edit field and we should
   // display the on screen keyboard
   if (!received_focus_change_after_pointer_down_ && virtual_keyboard_)
     DisplayOnScreenKeyboardIfNeeded();
   received_focus_change_after_pointer_down_ = false;
   pointer_down_context_ = false;
 }