Remove some uses of ATL in UI code

ui/views/win/hwnd_message_handler.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 "ui/views/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
+#include <oleacc.h>
 #include <shellapi.h>
 #include <wtsapi32.h>
 #pragma comment(lib, "wtsapi32.lib")
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "ui/base/touch/touch_enabled.h"
 #include "ui/base/win/lock_state.h"
@@ skipping 1133 matching lines @@
     if (force)
       SetWindowRgn(hwnd(), NULL, redraw);
     return;
   }
 
   // Changing the window region is going to force a paint. Only change the
   // window region if the region really differs.
   HRGN current_rgn = CreateRectRgn(0, 0, 0, 0);
   int current_rgn_result = GetWindowRgn(hwnd(), current_rgn);
 
-  CRect window_rect;
+  RECT window_rect;
   GetWindowRect(hwnd(), &window_rect);
   HRGN new_region;
   if (custom_window_region_) {
     new_region = ::CreateRectRgn(0, 0, 0, 0);
     ::CombineRgn(new_region, custom_window_region_.Get(), NULL, RGN_COPY);
   } else if (IsMaximized()) {
     HMONITOR monitor = MonitorFromWindow(hwnd(), MONITOR_DEFAULTTONEAREST);
     MONITORINFO mi;
     mi.cbSize = sizeof mi;
     GetMonitorInfo(monitor, &mi);
-    CRect work_rect = mi.rcWork;
-    work_rect.OffsetRect(-window_rect.left, -window_rect.top);
+    RECT work_rect = mi.rcWork;
+    OffsetRect(&work_rect, -window_rect.left, -window_rect.top);
     new_region = CreateRectRgnIndirect(&work_rect);
   } else {
     gfx::Path window_mask;
-    delegate_->GetWindowMask(
-        gfx::Size(window_rect.Width(), window_rect.Height()), &window_mask);
+    delegate_->GetWindowMask(gfx::Size(window_rect.right - window_rect.left,
+                                       window_rect.bottom - window_rect.top),
+                             &window_mask);
     new_region = gfx::CreateHRGNFromSkPath(window_mask);
   }
 
   if (current_rgn_result == ERROR || !EqualRgn(current_rgn, new_region)) {
     // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
     SetWindowRgn(hwnd(), new_region, redraw);
   } else {
     DeleteObject(new_region);
   }
 
@@ skipping 216 matching lines @@
   // TODO(beng): move more of NWW::OnCreate here.
   return 0;
 }
 
 void HWNDMessageHandler::OnDestroy() {
   WTSUnRegisterSessionNotification(hwnd());
   delegate_->HandleDestroying();
 }
 
 void HWNDMessageHandler::OnDisplayChange(UINT bits_per_pixel,
-                                         const CSize& screen_size) {
+                                         const gfx::Size& screen_size) {
   delegate_->HandleDisplayChange();
 }
 
 LRESULT HWNDMessageHandler::OnDwmCompositionChanged(UINT msg,
                                                     WPARAM w_param,
                                                     LPARAM l_param) {
   if (!delegate_->IsWidgetWindow()) {
     SetMsgHandled(FALSE);
     return 0;
   }
@@ skipping 43 matching lines @@
 }
 
 void HWNDMessageHandler::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
   gfx::Size min_window_size;
   gfx::Size max_window_size;
   delegate_->GetMinMaxSize(&min_window_size, &max_window_size);
 
   // Add the native frame border size to the minimum and maximum size if the
   // view reports its size as the client size.
   if (delegate_->WidgetSizeIsClientSize()) {
-    CRect client_rect, window_rect;
+    RECT client_rect, window_rect;
     GetClientRect(hwnd(), &client_rect);
     GetWindowRect(hwnd(), &window_rect);
-    window_rect -= client_rect;
-    min_window_size.Enlarge(window_rect.Width(), window_rect.Height());
-    if (!max_window_size.IsEmpty())
-      max_window_size.Enlarge(window_rect.Width(), window_rect.Height());
+    CR_DEFLATE_RECT(&window_rect, &client_rect);
+    min_window_size.Enlarge(window_rect.right - window_rect.left,
+                            window_rect.bottom - window_rect.top);
+    if (!max_window_size.IsEmpty()) {
+      max_window_size.Enlarge(window_rect.right - window_rect.left,
+                              window_rect.bottom - window_rect.top);
+    }
   }
   minmax_info->ptMinTrackSize.x = min_window_size.width();
   minmax_info->ptMinTrackSize.y = min_window_size.height();
   if (max_window_size.width() || max_window_size.height()) {
     if (!max_window_size.width())
       max_window_size.set_width(GetSystemMetrics(SM_CXMAXTRACK));
     if (!max_window_size.height())
       max_window_size.set_height(GetSystemMetrics(SM_CYMAXTRACK));
     minmax_info->ptMaxTrackSize.x = max_window_size.width();
     minmax_info->ptMaxTrackSize.y = max_window_size.height();
@@ skipping 112 matching lines @@
   // We handle touch events on Windows Aura. Windows generates synthesized
   // mouse messages in response to touch which we should ignore. However touch
   // messages are only received for the client area. We need to ignore the
   // synthesized mouse messages for all points in the client area and places
   // which return HTNOWHERE.
   if (ui::IsMouseEventFromTouch(message)) {
     LPARAM l_param_ht = l_param;
     // For mouse events (except wheel events), location is in window coordinates
     // and should be converted to screen coordinates for WM_NCHITTEST.
     if (message != WM_MOUSEWHEEL && message != WM_MOUSEHWHEEL) {
-      CPoint screen_point(l_param_ht);
+      POINT screen_point = CR_POINT_INITIALIZER_FROM_LPARAM(l_param_ht);
       MapWindowPoints(hwnd(), HWND_DESKTOP, &screen_point, 1);
       l_param_ht = MAKELPARAM(screen_point.x, screen_point.y);
     }
     LRESULT hittest = SendMessage(hwnd(), WM_NCHITTEST, 0, l_param_ht);
     if (hittest == HTCLIENT || hittest == HTNOWHERE)
       return 0;
   }
 #endif
   if (message == WM_RBUTTONUP && is_right_mouse_pressed_on_caption_) {
     is_right_mouse_pressed_on_caption_ = false;
     ReleaseCapture();
     // |point| is in window coordinates, but WM_NCHITTEST and TrackPopupMenu()
     // expect screen coordinates.
-    CPoint screen_point(l_param);
+    POINT screen_point = CR_POINT_INITIALIZER_FROM_LPARAM(l_param);
     MapWindowPoints(hwnd(), HWND_DESKTOP, &screen_point, 1);
     w_param = SendMessage(hwnd(), WM_NCHITTEST, 0,
                           MAKELPARAM(screen_point.x, screen_point.y));
     if (w_param == HTCAPTION || w_param == HTSYSMENU) {
       gfx::ShowSystemMenuAtPoint(hwnd(), gfx::Point(screen_point));
       return 0;
     }
   } else if (message == WM_NCLBUTTONDOWN && delegate_->IsUsingCustomFrame()) {
     switch (w_param) {
       case HTCLOSE:
@@ skipping 19 matching lines @@
   } else if (message == WM_NCRBUTTONDOWN &&
       (w_param == HTCAPTION || w_param == HTSYSMENU)) {
     is_right_mouse_pressed_on_caption_ = true;
     // We SetCapture() to ensure we only show the menu when the button
     // down and up are both on the caption. Note: this causes the button up to
     // be WM_RBUTTONUP instead of WM_NCRBUTTONUP.
     SetCapture();
   }
 
   MSG msg = { hwnd(), message, w_param, l_param, GetMessageTime(),
-              { GET_X_LPARAM(l_param), GET_Y_LPARAM(l_param) } };
+              { CR_GET_X_LPARAM(l_param), CR_GET_Y_LPARAM(l_param) } };
   ui::MouseEvent event(msg);
   if (!touch_ids_.empty() || ui::IsMouseEventFromTouch(message))
     event.set_flags(event.flags() | ui::EF_FROM_TOUCH);
 
   if (!(event.flags() & ui::EF_IS_NON_CLIENT))
     delegate_->HandleTooltipMouseMove(message, w_param, l_param);
 
   if (event.type() == ui::ET_MOUSE_MOVED && !HasCapture()) {
     // Windows only fires WM_MOUSELEAVE events if the application begins
     // "tracking" mouse events for a given HWND during WM_MOUSEMOVE events.
@@ skipping 25 matching lines @@
     // side-effects (ex/ stifling non-client mouse releases).
     DefWindowProcWithRedrawLock(message, w_param, l_param);
     handled = true;
   }
 
   if (ref.get())
     SetMsgHandled(handled);
   return 0;
 }
 
-void HWNDMessageHandler::OnMove(const CPoint& point) {
+void HWNDMessageHandler::OnMove(const gfx::Point& point) {
   delegate_->HandleMove();
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnMoving(UINT param, const RECT* new_bounds) {
   delegate_->HandleMove();
 }
 
 LRESULT HWNDMessageHandler::OnNCActivate(UINT message,
                                          WPARAM w_param,
@@ skipping 140 matching lines @@
   // pixels in the (now wrong) location, and thus makes actions like resizing a
   // window from the left edge look slightly less broken.
   // We special case when left or top insets are 0, since these conditions
   // actually require another repaint to correct the layout after glass gets
   // turned on and off.
   if (insets.left() == 0 || insets.top() == 0)
     return 0;
   return mode ? WVR_REDRAW : 0;
 }
 
-LRESULT HWNDMessageHandler::OnNCHitTest(const CPoint& point) {
+LRESULT HWNDMessageHandler::OnNCHitTest(const gfx::Point& point) {
   if (!delegate_->IsWidgetWindow()) {
     SetMsgHandled(FALSE);
     return 0;
   }
 
   // If the DWM is rendering the window controls, we need to give the DWM's
   // default window procedure first chance to handle hit testing.
   if (!remove_standard_frame_ && !delegate_->IsUsingCustomFrame()) {
     LRESULT result;
     if (DwmDefWindowProc(hwnd(), WM_NCHITTEST, 0,
-                         MAKELPARAM(point.x, point.y), &result)) {
+                         MAKELPARAM(point.x(), point.y()), &result)) {
       return result;
     }
   }
 
   // First, give the NonClientView a chance to test the point to see if it
   // provides any of the non-client area.
-  POINT temp = point;
+  POINT temp = { point.x(), point.y() };
   MapWindowPoints(HWND_DESKTOP, hwnd(), &temp, 1);
   int component = delegate_->GetNonClientComponent(gfx::Point(temp));
   if (component != HTNOWHERE)
     return component;
 
   // Otherwise, we let Windows do all the native frame non-client handling for
   // us.
 #if defined(USE_AURA)
   LRESULT hit_test_code = DefWindowProc(hwnd(), WM_NCHITTEST, 0,
-                                        MAKELPARAM(point.x, point.y));
+                                        MAKELPARAM(point.x(), point.y()));
   if (needs_scroll_styles_) {
     switch (hit_test_code) {
       // If we faked the WS_VSCROLL and WS_HSCROLL styles for this window, then
       // Windows returns the HTVSCROLL or HTHSCROLL hit test codes if we hover
       // or click on the non client portions of the window where the OS
       // scrollbars would be drawn. These hittest codes are returned even when
       // the scrollbars are hidden, which is the case in Aura. We fake the
       // hittest code as HTCLIENT in this case to ensure that we receive client
       // mouse messages as opposed to non client mouse messages.
       case HTVSCROLL:
@@ skipping 12 matching lines @@
         int border_height = ::GetSystemMetrics(SM_CYSIZEFRAME);
         int scroll_width = ::GetSystemMetrics(SM_CXVSCROLL);
         int scroll_height = ::GetSystemMetrics(SM_CYVSCROLL);
         RECT window_rect;
         ::GetWindowRect(hwnd(), &window_rect);
         window_rect.bottom -= border_height;
         window_rect.right -= border_width;
         window_rect.left = window_rect.right - scroll_width;
         window_rect.top = window_rect.bottom - scroll_height;
         POINT pt;
-        pt.x = point.x;
-        pt.y = point.y;
+        pt.x = point.x();
+        pt.y = point.y();
         if (::PtInRect(&window_rect, pt))
           hit_test_code = HTCLIENT;
         break;
       }
 
       default:
         break;
     }
   }
   return hit_test_code;
 #else
   SetMsgHandled(FALSE);
 #endif
 }
 
 void HWNDMessageHandler::OnNCPaint(HRGN rgn) {
   // We only do non-client painting if we're not using the native frame.
   // It's required to avoid some native painting artifacts from appearing when
   // the window is resized.
   if (!delegate_->IsWidgetWindow() || !delegate_->IsUsingCustomFrame()) {
     SetMsgHandled(FALSE);
     return;
   }
 
   // We have an NC region and need to paint it. We expand the NC region to
   // include the dirty region of the root view. This is done to minimize
   // paints.
-  CRect window_rect;
+  RECT window_rect;
   GetWindowRect(hwnd(), &window_rect);
 
   gfx::Size root_view_size = delegate_->GetRootViewSize();
-  if (gfx::Size(window_rect.Width(), window_rect.Height()) != root_view_size) {
+  if (gfx::Size(window_rect.right - window_rect.left,
+                window_rect.bottom - window_rect.top) != root_view_size) {
     // If the size of the window differs from the size of the root view it
     // means we're being asked to paint before we've gotten a WM_SIZE. This can
     // happen when the user is interactively resizing the window. To avoid
     // mass flickering we don't do anything here. Once we get the WM_SIZE we'll
     // reset the region of the window which triggers another WM_NCPAINT and
     // all is well.
     return;
   }
 
-  CRect dirty_region;
+  RECT dirty_region;
   // A value of 1 indicates paint all.
   if (!rgn || rgn == reinterpret_cast<HRGN>(1)) {
-    dirty_region = CRect(0, 0, window_rect.Width(), window_rect.Height());
+    dirty_region.left = 0;
+    dirty_region.top = 0;
+    dirty_region.right = window_rect.right - window_rect.left;
+    dirty_region.bottom = window_rect.bottom - window_rect.top;
   } else {
     RECT rgn_bounding_box;
     GetRgnBox(rgn, &rgn_bounding_box);
     if (!IntersectRect(&dirty_region, &rgn_bounding_box, &window_rect))
       return;  // Dirty region doesn't intersect window bounds, bale.
 
     // rgn_bounding_box is in screen coordinates. Map it to window coordinates.
     OffsetRect(&dirty_region, -window_rect.left, -window_rect.top);
   }
 
   // In theory GetDCEx should do what we want, but I couldn't get it to work.
   // In particular the docs mentiond DCX_CLIPCHILDREN, but as far as I can tell
   // it doesn't work at all. So, instead we get the DC for the window then
   // manually clip out the children.
   HDC dc = GetWindowDC(hwnd());
   ClipState clip_state;
   clip_state.x = window_rect.left;
   clip_state.y = window_rect.top;
   clip_state.parent = hwnd();
   clip_state.dc = dc;
   EnumChildWindows(hwnd(), &ClipDCToChild,
                    reinterpret_cast<LPARAM>(&clip_state));
 
   gfx::Rect old_paint_region = invalid_rect_;
   if (!old_paint_region.IsEmpty()) {
     // The root view has a region that needs to be painted. Include it in the
     // region we're going to paint.
 
-    CRect old_paint_region_crect = old_paint_region.ToRECT();
-    CRect tmp = dirty_region;
+    RECT old_paint_region_crect = old_paint_region.ToRECT();
+    RECT tmp = dirty_region;
     UnionRect(&dirty_region, &tmp, &old_paint_region_crect);
   }
 
   SchedulePaintInRect(gfx::Rect(dirty_region));
 
   // gfx::CanvasSkiaPaint's destructor does the actual painting. As such, wrap
   // the following in a block to force paint to occur so that we can release
   // the dc.
   if (!delegate_->HandlePaintAccelerated(gfx::Rect(dirty_region))) {
-    gfx::CanvasSkiaPaint canvas(dc, true, dirty_region.left,
-                                dirty_region.top, dirty_region.Width(),
-                                dirty_region.Height());
+    gfx::CanvasSkiaPaint canvas(dc,
+                                true,
+                                dirty_region.left,
+                                dirty_region.top,
+                                dirty_region.right - dirty_region.left,
+                                dirty_region.bottom - dirty_region.top);
     delegate_->HandlePaint(&canvas);
   }
 
   ReleaseDC(hwnd(), dc);
   // When using a custom frame, we want to avoid calling DefWindowProc() since
   // that may render artifacts.
   SetMsgHandled(delegate_->IsUsingCustomFrame());
 }
 
 LRESULT HWNDMessageHandler::OnNCUAHDrawCaption(UINT message,
@@ skipping 135 matching lines @@
     ::SetWindowPos(hwnd(), 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
         SWP_NOZORDER | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
     SetMsgHandled(TRUE);
   } else {
     if (flags == SPI_SETWORKAREA)
       delegate_->HandleWorkAreaChanged();
     SetMsgHandled(FALSE);
   }
 }
 
-void HWNDMessageHandler::OnSize(UINT param, const CSize& size) {
+void HWNDMessageHandler::OnSize(UINT param, const gfx::Size& size) {
   RedrawWindow(hwnd(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
   // ResetWindowRegion is going to trigger WM_NCPAINT. By doing it after we've
   // invoked OnSize we ensure the RootView has been laid out.
   ResetWindowRegion(false, true);
 
 #if defined(USE_AURA)
   // We add the WS_VSCROLL and WS_HSCROLL styles to top level windows to ensure
   // that legacy trackpad/trackpoint drivers generate the WM_VSCROLL and
   // WM_HSCROLL messages and scrolling works.
   // We want the scroll styles to be present on the window. However we don't
   // want Windows to draw the scrollbars. To achieve this we hide the scroll
   // bars and readd them to the window style in a posted task to ensure that we
   // don't get nested WM_SIZE messages.
   if (needs_scroll_styles_ && !in_size_loop_) {
     ShowScrollBar(hwnd(), SB_BOTH, FALSE);
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&AddScrollStylesToWindow, hwnd()));
   }
 #endif
 }
 
 void HWNDMessageHandler::OnSysCommand(UINT notification_code,
-                                      const CPoint& point) {
+                                      const gfx::Point& point) {
   if (!delegate_->ShouldHandleSystemCommands())
     return;
 
   // Windows uses the 4 lower order bits of |notification_code| for type-
   // specific information so we must exclude this when comparing.
   static const int sc_mask = 0xFFF0;
   // Ignore size/move/maximize in fullscreen mode.
   if (fullscreen_handler_->fullscreen() &&
       (((notification_code & sc_mask) == SC_SIZE) ||
        ((notification_code & sc_mask) == SC_MOVE) ||
@@ skipping 10 matching lines @@
         // Circumvent ScopedRedrawLocks and force visibility before entering a
         // resize or move modal loop to get continuous sizing/moving feedback.
         SetWindowLong(hwnd(), GWL_STYLE,
                       GetWindowLong(hwnd(), GWL_STYLE) | WS_VISIBLE);
       }
     }
   }
 
   // Handle SC_KEYMENU, which means that the user has pressed the ALT
   // key and released it, so we should focus the menu bar.
-  if ((notification_code & sc_mask) == SC_KEYMENU && point.x == 0) {
+  if ((notification_code & sc_mask) == SC_KEYMENU && point.x() == 0) {
     int modifiers = ui::EF_NONE;
     if (base::win::IsShiftPressed())
       modifiers |= ui::EF_SHIFT_DOWN;
     if (base::win::IsCtrlPressed())
       modifiers |= ui::EF_CONTROL_DOWN;
     // Retrieve the status of shift and control keys to prevent consuming
     // shift+alt keys, which are used by Windows to change input languages.
     ui::Accelerator accelerator(ui::KeyboardCodeForWindowsKeyCode(VK_MENU),
                                 modifiers);
     delegate_->HandleAccelerator(accelerator);
     return;
   }
 
   // If the delegate can't handle it, the system implementation will be called.
   if (!delegate_->HandleCommand(notification_code)) {
     // If the window is being resized by dragging the borders of the window
     // with the mouse/touch/keyboard, we flag as being in a size loop.
     if ((notification_code & sc_mask) == SC_SIZE)
       in_size_loop_ = true;
     DefWindowProc(hwnd(), WM_SYSCOMMAND, notification_code,
-                  MAKELPARAM(point.x, point.y));
+                  MAKELPARAM(point.x(), point.y()));
     in_size_loop_ = false;
   }
 }
 
 void HWNDMessageHandler::OnThemeChanged() {
   ui::NativeThemeWin::instance()->CloseHandles();
 }
 
 LRESULT HWNDMessageHandler::OnTouchEvent(UINT message,
                                          WPARAM w_param,
@@ skipping 60 matching lines @@
     // If somebody's trying to toggle our visibility, change the nonclient area,
     // change our Z-order, or activate us, we should probably let it go through.
     if (!(window_pos->flags & ((IsVisible() ? SWP_HIDEWINDOW : SWP_SHOWWINDOW) |
         SWP_FRAMECHANGED)) &&
         (window_pos->flags & (SWP_NOZORDER | SWP_NOACTIVATE))) {
       // Just sizing/moving the window; ignore.
       window_pos->flags |= SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW;
       window_pos->flags &= ~(SWP_SHOWWINDOW | SWP_HIDEWINDOW);
     }
   } else if (!GetParent(hwnd())) {
-    CRect window_rect;
+    RECT window_rect;
     HMONITOR monitor;
     gfx::Rect monitor_rect, work_area;
     if (GetWindowRect(hwnd(), &window_rect) &&
         GetMonitorAndRects(window_rect, &monitor, &monitor_rect, &work_area)) {
       bool work_area_changed = (monitor_rect == last_monitor_rect_) &&
                                (work_area != last_work_area_);
       if (monitor && (monitor == last_monitor_) &&
           ((fullscreen_handler_->fullscreen() &&
             !fullscreen_handler_->metro_snap()) ||
             work_area_changed)) {
@@ skipping 70 matching lines @@
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::HandleTouchEvents(const TouchEvents& touch_events) {
   base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
   for (size_t i = 0; i < touch_events.size() && ref; ++i)
     delegate_->HandleTouchEvent(touch_events[i]);
 }
 
 }  // namespace views