Use RECT instead of CRect to reduce dependencies on ATL.

chrome/browser/dock_info_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 "chrome/browser/dock_info.h"
 
-#include <atlbase.h>
-#include <atlapp.h>
-#include <atlmisc.h>
-
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/tabs/tab.h"
 
 namespace {
 
 // BaseWindowFinder -----------------------------------------------------------
 
 // Base class used to locate a window. This is intended to be used with the
 // various win32 functions that iterate over windows.
 //
 // A subclass need only override ShouldStopIterating to determine when
 // iteration should stop.
 class BaseWindowFinder {
  public:
   // Creates a BaseWindowFinder with the specified set of HWNDs to ignore.
-  BaseWindowFinder(const std::set<HWND>& ignore) : ignore_(ignore) {}
+  explicit BaseWindowFinder(const std::set<HWND>& ignore) : ignore_(ignore) {}
   virtual ~BaseWindowFinder() {}
 
  protected:
   // Returns true if iteration should stop, false if iteration should continue.
   virtual bool ShouldStopIterating(HWND window) = 0;
 
   static BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
     BaseWindowFinder* finder = reinterpret_cast<BaseWindowFinder*>(lParam);
     if (finder->ignore_.find(hwnd) != finder->ignore_.end())
       return TRUE;
@@ skipping 22 matching lines @@
     return finder.is_top_most_;
   }
 
   virtual bool ShouldStopIterating(HWND hwnd) {
     if (hwnd == target_) {
       // Window is topmost, stop iterating.
       is_top_most_ = true;
       return true;
     }
 
-    if (!::IsWindowVisible(hwnd)) {
+    if (!IsWindowVisible(hwnd)) {
       // The window isn't visible, keep iterating.
       return false;
     }
 
-    CRect r;
-    if (!::GetWindowRect(hwnd, &r) || !r.PtInRect(screen_loc_.ToPOINT())) {
+    RECT r;
+    if (!GetWindowRect(hwnd, &r) || !PtInRect(&r, screen_loc_.ToPOINT())) {
       // The window doesn't contain the point, keep iterating.
       return false;
     }
 
     // hwnd is at the point. Make sure the point is within the windows region.
     if (GetWindowRgn(hwnd, tmp_region_.Get()) == ERROR) {
       // There's no region on the window and the window contains the point. Stop
       // iterating.
       return true;
     }
@@ skipping 47 matching lines @@
     if (finder.result_ &&
         TopMostFinder::IsTopMostWindowAtPoint(finder.result_, screen_loc,
                                               ignore)) {
       return finder.result_;
     }
     return NULL;
   }
 
  protected:
   virtual bool ShouldStopIterating(HWND hwnd) {
-    CRect r;
-    if (::IsWindowVisible(hwnd) && ::GetWindowRect(hwnd, &r) &&
-        r.PtInRect(screen_loc_.ToPOINT())) {
+    RECT r;
+    if (IsWindowVisible(hwnd) && GetWindowRect(hwnd, &r) &&
+        PtInRect(&r, screen_loc_.ToPOINT())) {
       result_ = hwnd;
       return true;
     }
     return false;
   }
 
  private:
   LocalProcessWindowFinder(const gfx::Point& screen_loc,
                            const std::set<HWND>& ignore)
       : BaseWindowFinder(ignore),
@@ skipping 28 matching lines @@
                                                finder.result_.hot_spot(),
                                                ignore)) {
       finder.result_.set_type(DockInfo::NONE);
     }
     return finder.result_;
   }
 
  protected:
   virtual bool ShouldStopIterating(HWND hwnd) {
     BrowserView* window = BrowserView::GetBrowserViewForNativeWindow(hwnd);
-    CRect bounds;
-    if (!window || !::IsWindowVisible(hwnd) ||
-        !::GetWindowRect(hwnd, &bounds)) {
+    RECT bounds;
+    if (!window || !IsWindowVisible(hwnd) ||
+        !GetWindowRect(hwnd, &bounds)) {
       return false;
     }
 
     // Check the three corners we allow docking to. We don't currently allow
     // docking to top of window as it conflicts with docking to the tab strip.
     if (CheckPoint(hwnd, bounds.left, (bounds.top + bounds.bottom) / 2,
                    DockInfo::LEFT_OF_WINDOW) ||
         CheckPoint(hwnd, bounds.right - 1, (bounds.top + bounds.bottom) / 2,
                    DockInfo::RIGHT_OF_WINDOW) ||
         CheckPoint(hwnd, (bounds.left + bounds.right) / 2, bounds.bottom - 1,
@@ skipping 91 matching lines @@
   *bounds = gfx::Rect(window_rect);
   return true;
 }
 
 void DockInfo::SizeOtherWindowTo(const gfx::Rect& bounds) const {
   if (IsZoomed(window())) {
     // We're docking relative to another window, we need to make sure the
     // window we're docking to isn't maximized.
     ShowWindow(window(), SW_RESTORE | SW_SHOWNA);
   }
-  ::SetWindowPos(window(), HWND_TOP, bounds.x(), bounds.y(), bounds.width(),
-                 bounds.height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER);
+  SetWindowPos(window(), HWND_TOP, bounds.x(), bounds.y(), bounds.width(),
+               bounds.height(), SWP_NOACTIVATE | SWP_NOOWNERZORDER);
 }