Makes casts in DockInfoWin consistant.

chrome/browser/ui/tabs/dock_info_win.cc

 // Copyright (c) 2011 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/ui/tabs/dock_info.h"
 
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 10 matching lines @@
 //
 // 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.
   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) {
+    // Cast must match that in as_lparam().
     BaseWindowFinder* finder = reinterpret_cast<BaseWindowFinder*>(lParam);
     if (finder->ignore_.find(hwnd) != finder->ignore_.end())
       return TRUE;
 
     return finder->ShouldStopIterating(hwnd) ? FALSE : TRUE;
   }
 
+  LPARAM as_lparam() {
+    // Cast must match that in WindowCallbackProc().
+    return reinterpret_cast<LPARAM>(static_cast<BaseWindowFinder*>(this));
+  }
+
+  // Returns true if iteration should stop, false if iteration should continue.
+  virtual bool ShouldStopIterating(HWND window) = 0;
+
  private:
   const std::set<HWND>& ignore_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseWindowFinder);
 };
 
 // TopMostFinder --------------------------------------------------------------
 
 // Helper class to determine if a particular point of a window is not obscured
 // by another window.
@@ skipping 59 matching lines @@
 
  private:
   TopMostFinder(HWND window,
                 const gfx::Point& screen_loc,
                 const std::set<HWND>& ignore)
       : BaseWindowFinder(ignore),
         target_(window),
         screen_loc_(screen_loc),
         is_top_most_(false),
         tmp_region_(CreateRectRgn(0, 0, 0, 0)) {
-    EnumWindows(WindowCallbackProc, reinterpret_cast<LPARAM>(this));
+    EnumWindows(WindowCallbackProc, as_lparam());
   }
 
   // The window we're looking for.
   HWND target_;
 
   // Location of window to find.
   gfx::Point screen_loc_;
 
   // Is target_ the top most window? This is initially false but set to true
   // in ShouldStopIterating if target_ is passed in.
@@ skipping 38 matching lines @@
     }
     return false;
   }
 
  private:
   LocalProcessWindowFinder(const gfx::Point& screen_loc,
                            const std::set<HWND>& ignore)
       : BaseWindowFinder(ignore),
         screen_loc_(screen_loc),
         result_(NULL) {
-    EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc,
-                      reinterpret_cast<LPARAM>(this));
+    EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, as_lparam());
   }
 
   // Position of the mouse.
   gfx::Point screen_loc_;
 
   // The resulting window. This is initially null but set to true in
   // ShouldStopIterating if an appropriate window is found.
   HWND result_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalProcessWindowFinder);
@@ skipping 42 matching lines @@
 
  private:
   DockToWindowFinder(const gfx::Point& screen_loc,
                      const std::set<HWND>& ignore)
       : BaseWindowFinder(ignore),
         screen_loc_(screen_loc) {
     gfx::Rect work_area = gfx::Screen::GetMonitorWorkAreaNearestPoint(
         screen_loc);
     if (!work_area.IsEmpty()) {
       result_.set_monitor_bounds(work_area);
-      EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc,
-                        reinterpret_cast<LPARAM>(this));
+      EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, as_lparam());
     }
   }
 
   bool CheckPoint(HWND hwnd, int x, int y, DockInfo::Type type) {
     bool in_enable_area;
     if (DockInfo::IsCloseToPoint(screen_loc_, x, y, &in_enable_area)) {
       result_.set_in_enable_area(in_enable_area);
       result_.set_window(hwnd);
       result_.set_type(type);
       result_.set_hot_spot(gfx::Point(x, y));
@@ skipping 65 matching lines @@
 
 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);
 }