Change PluginInstallImpl to use base::WindowImpl instead of CWindowImpl to re...

views/widget/widget_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 "views/widget/widget_win.h"
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util_win.h"
 #include "app/win_util.h"
 #include "base/gfx/native_theme.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "views/accessibility/view_accessibility.h"
 #include "views/controls/native_control_win.h"
 #include "views/focus/focus_util_win.h"
 #include "views/views_delegate.h"
 #include "views/widget/aero_tooltip_manager.h"
 #include "views/widget/default_theme_provider.h"
 #include "views/widget/drop_target_win.h"
 #include "views/widget/root_view.h"
 #include "views/window/window_win.h"
 
 namespace views {
 
 // Property used to link the HWND to its RootView.
 static const wchar_t* const kRootViewWindowProperty = L"__ROOT_VIEW__";
 
 bool SetRootViewForHWND(HWND hwnd, RootView* root_view) {
-  return ::SetProp(hwnd, kRootViewWindowProperty, root_view) ? true : false;
+  return SetProp(hwnd, kRootViewWindowProperty, root_view) ? true : false;
 }
 
 RootView* GetRootViewForHWND(HWND hwnd) {
   return reinterpret_cast<RootView*>(::GetProp(hwnd, kRootViewWindowProperty));
 }
 
 NativeControlWin* GetNativeControlWinForHWND(HWND hwnd) {
   return reinterpret_cast<NativeControlWin*>(
-      ::GetProp(hwnd, NativeControlWin::kNativeControlWinKey));
+      GetProp(hwnd, NativeControlWin::kNativeControlWinKey));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public
 
 WidgetWin::WidgetWin()
     : close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       has_capture_(false),
       use_layered_buffer_(true),
@@ skipping 20 matching lines @@
   // Create the window.
   WindowImpl::Init(parent, bounds);
 
   // See if the style has been overridden.
   opaque_ = !(window_ex_style() & WS_EX_TRANSPARENT);
   use_layered_buffer_ = (use_layered_buffer_ &&
                          !!(window_ex_style() & WS_EX_LAYERED));
 
   default_theme_provider_.reset(new DefaultThemeProvider());
 
-  SetWindowSupportsRerouteMouseWheel(GetNativeView());
+  SetWindowSupportsRerouteMouseWheel(hwnd());
 
   drop_target_ = new DropTargetWin(root_view_.get());
 
   if ((window_style() & WS_CHILD) == 0) {
     // Top-level widgets get a FocusManager.
     focus_manager_.reset(new FocusManager(this));
   }
 
   // Sets the RootView as a property, so the automation can introspect windows.
-  SetRootViewForHWND(GetNativeView(), root_view_.get());
+  SetRootViewForHWND(hwnd(), root_view_.get());
 
   MessageLoopForUI::current()->AddObserver(this);
 
   // Windows special DWM window frame requires a special tooltip manager so
   // that window controls in Chrome windows don't flicker when you move your
   // mouse over them. See comment in aero_tooltip_manager.h.
   if (GetThemeProvider()->ShouldUseNativeFrame()) {
     tooltip_manager_.reset(new AeroTooltipManager(this));
   } else {
     tooltip_manager_.reset(new TooltipManagerWin(this));
   }
 
   // This message initializes the window so that focus border are shown for
   // windows.
-  ::SendMessage(GetNativeView(),
-                WM_CHANGEUISTATE,
-                MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS),
-                0);
+  SendMessage(hwnd(),
+              WM_CHANGEUISTATE,
+              MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS),
+              0);
 
   // Bug 964884: detach the IME attached to this window.
   // We should attach IMEs only when we need to input CJK strings.
-  ::ImmAssociateContextEx(GetNativeView(), NULL, 0);
+  ImmAssociateContextEx(hwnd(), NULL, 0);
 }
 
 void WidgetWin::SetContentsView(View* view) {
   root_view_->SetContentsView(view);
 }
 
 void WidgetWin::GetBounds(gfx::Rect* out, bool including_frame) const {
   CRect crect;
   if (including_frame) {
     GetWindowRect(&crect);
     *out = gfx::Rect(crect);
     return;
   }
 
   GetClientRect(&crect);
   POINT p = {0, 0};
-  ::ClientToScreen(GetNativeView(), &p);
+  ClientToScreen(hwnd(), &p);
   out->SetRect(crect.left + p.x, crect.top + p.y,
                crect.Width(), crect.Height());
 }
 
 void WidgetWin::SetBounds(const gfx::Rect& bounds) {
   SetWindowPos(NULL, bounds.x(), bounds.y(), bounds.width(), bounds.height(),
                SWP_NOACTIVATE | SWP_NOZORDER);
 }
 
 void WidgetWin::SetShape(const gfx::Path& shape) {
@@ skipping 17 matching lines @@
             &WidgetWin::CloseNow));
   }
 }
 
 void WidgetWin::CloseNow() {
   // We may already have been destroyed if the selection resulted in a tab
   // switch which will have reactivated the browser window and closed us, so
   // we need to check to see if we're still a window before trying to destroy
   // ourself.
   if (IsWindow())
-    DestroyWindow();
+    DestroyWindow(hwnd());
 }
 
 void WidgetWin::Show() {
   if (IsWindow())
     ShowWindow(SW_SHOWNOACTIVATE);
 }
 
 void WidgetWin::Hide() {
   if (IsWindow()) {
     // NOTE: Be careful not to activate any windows here (for example, calling
     // ShowWindow(SW_HIDE) will automatically activate another window).  This
     // code can be called while a window is being deactivated, and activating
     // another window will screw up the activation that is already in progress.
     SetWindowPos(NULL, 0, 0, 0, 0,
                  SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOMOVE |
                  SWP_NOREPOSITION | SWP_NOSIZE | SWP_NOZORDER);
   }
 }
 
 gfx::NativeView WidgetWin::GetNativeView() const {
-  return WindowImpl::GetNativeView();
+  return WindowImpl::hwnd();
 }
 
 static BOOL CALLBACK EnumChildProcForRedraw(HWND hwnd, LPARAM lparam) {
   DWORD process_id;
   GetWindowThreadProcessId(hwnd, &process_id);
   gfx::Rect invalid_rect = *reinterpret_cast<gfx::Rect*>(lparam);
 
   RECT window_rect;
   GetWindowRect(hwnd, &window_rect);
   invalid_rect.Offset(-window_rect.left, -window_rect.top);
 
   int flags = RDW_INVALIDATE | RDW_NOCHILDREN | RDW_FRAME;
   if (process_id == GetCurrentProcessId())
     flags |= RDW_UPDATENOW;
   RedrawWindow(hwnd, &invalid_rect.ToRECT(), NULL, flags);
   return TRUE;
 }
 
 void WidgetWin::PaintNow(const gfx::Rect& update_rect) {
   if (use_layered_buffer_) {
     PaintLayeredWindow();
   } else if (root_view_->NeedsPainting(false) && IsWindow()) {
     if (!opaque_ && GetParent()) {
       // We're transparent. Need to force painting to occur from our parent.
       CRect parent_update_rect = update_rect.ToRECT();
       POINT location_in_parent = { 0, 0 };
-      ClientToScreen(GetNativeView(), &location_in_parent);
-      ::ScreenToClient(GetParent(), &location_in_parent);
+      ClientToScreen(hwnd(), &location_in_parent);
+      ScreenToClient(GetParent(), &location_in_parent);
       parent_update_rect.OffsetRect(location_in_parent);
-      ::RedrawWindow(GetParent(), parent_update_rect, NULL,
+      RedrawWindow(GetParent(), parent_update_rect, NULL,
                      RDW_UPDATENOW | RDW_INVALIDATE | RDW_ALLCHILDREN);
     } else {
       // Paint child windows that are in a different process asynchronously.
       // This prevents a hang in other processes from blocking this process.
 
       // Calculate the invalid rect in screen coordinates before  the first
       // RedrawWindow call to the parent HWND, since that will empty update_rect
       // (which comes from a member variable) in the OnPaint call.
       CRect screen_rect_temp;
       GetWindowRect(&screen_rect_temp);
       gfx::Rect screen_rect(screen_rect_temp);
       gfx::Rect invalid_screen_rect = update_rect;
       invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
 
-      ::RedrawWindow(GetNativeView(), &update_rect.ToRECT(), NULL,
-                     RDW_INVALIDATE | RDW_UPDATENOW | RDW_NOCHILDREN);
+      RedrawWindow(hwnd(), &update_rect.ToRECT(), NULL,
+                   RDW_INVALIDATE | RDW_UPDATENOW | RDW_NOCHILDREN);
 
       LPARAM lparam = reinterpret_cast<LPARAM>(&invalid_screen_rect);
-      EnumChildWindows(GetNativeView(), EnumChildProcForRedraw, lparam);
+      EnumChildWindows(hwnd(), EnumChildProcForRedraw, lparam);
     }
     // As we were created with a style of WS_CLIPCHILDREN redraw requests may
     // result in an empty paint rect in WM_PAINT (this'll happen if a
     // child HWND completely contains the update _rect). In such a scenario
     // RootView would never get a ProcessPaint and always think it needs to
     // be painted (leading to a steady stream of RedrawWindow requests on every
     // event). For this reason we tell RootView it doesn't need to paint
     // here.
     root_view_->ClearPaintRect();
   }
 }
 
 void WidgetWin::SetOpacity(unsigned char opacity) {
   layered_alpha_ = static_cast<BYTE>(opacity);
 }
 
 RootView* WidgetWin::GetRootView() {
   if (!root_view_.get()) {
     // First time the root view is being asked for, create it now.
     root_view_.reset(CreateRootView());
   }
   return root_view_.get();
 }
 
 Widget* WidgetWin::GetRootWidget() const {
   return reinterpret_cast<WidgetWin*>(
-      win_util::GetWindowUserData(GetAncestor(GetNativeView(), GA_ROOT)));
+      win_util::GetWindowUserData(GetAncestor(hwnd(), GA_ROOT)));
 }
 
 bool WidgetWin::IsVisible() const {
-  return !!::IsWindowVisible(GetNativeView());
+  return !!::IsWindowVisible(hwnd());
 }
 
 bool WidgetWin::IsActive() const {
-  return win_util::IsWindowActive(GetNativeView());
+  return win_util::IsWindowActive(hwnd());
 }
 
 void WidgetWin::GenerateMousePressedForView(View* view,
                                             const gfx::Point& point) {
   gfx::Point point_in_widget(point);
   View::ConvertPointToWidget(view, &point_in_widget);
   root_view_->SetMouseHandler(view);
   ProcessMousePressed(point_in_widget.ToPOINT(), MK_LBUTTON, false, false);
 }
 
@@ skipping 11 matching lines @@
       return provider;
 
     provider = widget->GetDefaultThemeProvider();
     if (provider)
       return provider;
   }
   return default_theme_provider_.get();
 }
 
 Window* WidgetWin::GetWindow() {
-  return GetWindowImpl(GetNativeView());
+  return GetWindowImpl(hwnd());
 }
 
 const Window* WidgetWin::GetWindow() const {
-  return GetWindowImpl(GetNativeView());
+  return GetWindowImpl(hwnd());
 }
 
 FocusManager* WidgetWin::GetFocusManager() {
   if (focus_manager_.get())
     return focus_manager_.get();
 
   WidgetWin* widget = static_cast<WidgetWin*>(GetRootWidget());
   if (widget && widget != this) {
     // WidgetWin subclasses may override GetFocusManager(), for example for
     // dealing with cases where the widget has been unparented.
     return widget->GetFocusManager();
   }
   return NULL;
 }
 
 void WidgetWin::ViewHierarchyChanged(bool is_add, View *parent,
                                      View *child) {
   if (drop_target_.get())
     drop_target_->ResetTargetViewIfEquals(child);
 }
 
 void WidgetWin::SetUseLayeredBuffer(bool use_layered_buffer) {
   if (use_layered_buffer_ == use_layered_buffer)
     return;
 
   use_layered_buffer_ = use_layered_buffer;
-  if (!GetNativeView())
+  if (!hwnd())
     return;
 
   if (use_layered_buffer_) {
     // Force creation of the buffer at the right size.
     RECT wr;
     GetWindowRect(&wr);
     ChangeSize(0, CSize(wr.right - wr.left, wr.bottom - wr.top));
   } else {
     contents_.reset(NULL);
   }
@@ skipping 87 matching lines @@
     has_capture_ = false;
   }
 }
 
 void WidgetWin::OnClose() {
   Close();
 }
 
 void WidgetWin::OnDestroy() {
   if (drop_target_.get()) {
-    RevokeDragDrop(GetNativeView());
+    RevokeDragDrop(hwnd());
     drop_target_ = NULL;
   }
 
-  RemoveProp(GetNativeView(), kRootViewWindowProperty);
+  RemoveProp(hwnd(), kRootViewWindowProperty);
 }
 
 LRESULT WidgetWin::OnEraseBkgnd(HDC dc) {
   // This is needed for magical win32 flicker ju-ju
   return 1;
 }
 
 LRESULT WidgetWin::OnGetObject(UINT uMsg, WPARAM w_param, LPARAM l_param) {
   LRESULT reference_result = static_cast<LRESULT>(0L);
 
@@ skipping 83 matching lines @@
 LRESULT WidgetWin::OnMouseLeave(UINT message, WPARAM w_param, LPARAM l_param) {
   tooltip_manager_->OnMouseLeave();
   ProcessMouseExited();
   return 0;
 }
 
 LRESULT WidgetWin::OnMouseWheel(UINT message, WPARAM w_param, LPARAM l_param) {
   // Reroute the mouse-wheel to the window under the mouse pointer if
   // applicable.
   if (message == WM_MOUSEWHEEL &&
-      views::RerouteMouseWheel(GetNativeView(), w_param, l_param)) {
+      views::RerouteMouseWheel(hwnd(), w_param, l_param)) {
     return 0;
   }
 
   int flags = GET_KEYSTATE_WPARAM(w_param);
   short distance = GET_WHEEL_DELTA_WPARAM(w_param);
   int x = GET_X_LPARAM(l_param);
   int y = GET_Y_LPARAM(l_param);
   MouseWheelEvent e(distance, x, y, Event::ConvertWindowsFlags(flags));
   return root_view_->ProcessMouseWheelEvent(e) ? 0 : 1;
 }
@@ skipping 29 matching lines @@
 }
 
 LRESULT WidgetWin::OnNCMouseLeave(UINT uMsg, WPARAM w_param, LPARAM l_param) {
   ProcessMouseExited();
   return 0;
 }
 
 LRESULT WidgetWin::OnNCMouseMove(UINT flags, const CPoint& point) {
   // NC points are in screen coordinates.
   CPoint temp = point;
-  MapWindowPoints(HWND_DESKTOP, GetNativeView(), &temp, 1);
+  MapWindowPoints(HWND_DESKTOP, hwnd(), &temp, 1);
   ProcessMouseMoved(temp, 0, true);
 
   // We need to process this message to stop Windows from drawing the window
   // controls as the mouse moves over the title bar area when the window is
   // maximized.
   return 0;
 }
 
 void WidgetWin::OnNCRButtonDblClk(UINT flags, const CPoint& point) {
   SetMsgHandled(ProcessMousePressed(point, flags | MK_RBUTTON, true, true));
@@ skipping 15 matching lines @@
     bool handled;
     LRESULT result = tooltip_manager_->OnNotify(w_param, l_param, &handled);
     SetMsgHandled(handled);
     return result;
   }
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void WidgetWin::OnPaint(HDC dc) {
-  root_view_->OnPaint(GetNativeView());
+  root_view_->OnPaint(hwnd());
 }
 
 void WidgetWin::OnRButtonDown(UINT flags, const CPoint& point) {
   ProcessMousePressed(point, flags | MK_RBUTTON, false, false);
 }
 
 void WidgetWin::OnRButtonUp(UINT flags, const CPoint& point) {
   ProcessMouseReleased(point, flags | MK_RBUTTON);
 }
 
@@ skipping 26 matching lines @@
       // We're about to cancel active mouse tracking, so empty out the stored
       // state.
       active_mouse_tracking_flags_ = 0;
     } else {
       active_mouse_tracking_flags_ = mouse_tracking_flags;
     }
 
     TRACKMOUSEEVENT tme;
     tme.cbSize = sizeof(tme);
     tme.dwFlags = mouse_tracking_flags;
-    tme.hwndTrack = GetNativeView();
+    tme.hwndTrack = hwnd();
     tme.dwHoverTime = 0;
     TrackMouseEvent(&tme);
   } else if (mouse_tracking_flags != active_mouse_tracking_flags_) {
     TrackMouseEvents(active_mouse_tracking_flags_ | TME_CANCEL);
     TrackMouseEvents(mouse_tracking_flags);
   }
 }
 
 bool WidgetWin::ProcessMousePressed(const CPoint& point,
                                     UINT flags,
@@ skipping 146 matching lines @@
 void WidgetWin::UpdateWindowFromContents(HDC dib_dc) {
   DCHECK(use_layered_buffer_);
   if (can_update_layered_window_) {
     CRect wr;
     GetWindowRect(&wr);
     CSize size(wr.right - wr.left, wr.bottom - wr.top);
     CPoint zero_origin(0, 0);
     CPoint window_position = wr.TopLeft();
 
     BLENDFUNCTION blend = {AC_SRC_OVER, 0, layered_alpha_, AC_SRC_ALPHA};
-    ::UpdateLayeredWindow(
-        GetNativeView(), NULL, &window_position, &size, dib_dc, &zero_origin,
+    UpdateLayeredWindow(
+        hwnd(), NULL, &window_position, &size, dib_dc, &zero_origin,
         RGB(0xFF, 0xFF, 0xFF), &blend, ULW_ALPHA);
   }
 }
 
 // Get the source HWND of the specified message. Depending on the message, the
 // source HWND is encoded in either the WPARAM or the LPARAM value.
 HWND GetControlHWNDForMessage(UINT message, WPARAM w_param, LPARAM l_param) {
   // Each of the following messages can be sent by a child HWND and must be
   // forwarded to its associated NativeControlWin for handling.
   switch (message) {
@@ skipping 34 matching lines @@
   if (IsWindow(control_hwnd)) {
     NativeControlWin* wrapper = GetNativeControlWinForHWND(control_hwnd);
     if (wrapper)
       return wrapper->ProcessMessage(message, w_param, l_param, l_result);
   }
 
   return false;
 }
 
 LRESULT WidgetWin::OnWndProc(UINT message, WPARAM w_param, LPARAM l_param) {
-  HWND window = GetNativeView();
+  HWND window = hwnd();
   LRESULT result = 0;
 
   // First allow messages sent by child controls to be processed directly by
   // their associated views. If such a view is present, it will handle the
   // message *instead of* this WidgetWin.
   if (ProcessNativeControlMessage(message, w_param, l_param, &result))
     return result;
 
   // Otherwise we handle everything else.
   if (!ProcessWindowMessage(window, message, w_param, l_param, result))
@@ skipping 29 matching lines @@
   WidgetWin* popup = new WidgetWin;
   popup->set_window_style(WS_POPUP);
   popup->set_window_ex_style(WS_EX_LAYERED | WS_EX_TOOLWINDOW |
                              WS_EX_TRANSPARENT |
                              l10n_util::GetExtendedTooltipStyles());
   popup->set_delete_on_destroy(delete_on_destroy);
   return popup;
 }
 
 }  // namespace views