Make NativeControl inherit from base::WindowImpl instead of CWindowImpl to re...

views/controls/native_control.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/controls/native_control.h"
 
-#include <atlbase.h>
-#include <atlapp.h>
-#include <atlcrack.h>
-#include <atlframe.h>
-#include <atlmisc.h>
+#include <algorithm>
 
 #include "app/l10n_util_win.h"
 #include "base/logging.h"
 #include "base/win_util.h"
+#include "base/window_impl.h"
 #include "views/background.h"
 #include "views/border.h"
 #include "views/controls/native/native_view_host.h"
 #include "views/focus/focus_manager.h"
 #include "views/widget/widget.h"
 #include "base/gfx/native_theme.h"
 
 namespace views {
 
 // Maps to the original WNDPROC for the controller window before we subclassed
 // it.
 static const wchar_t* const kHandlerKey =
     L"__CONTROL_ORIGINAL_MESSAGE_HANDLER__";
 
 // Maps to the NativeControl.
 static const wchar_t* const kNativeControlKey = L"__NATIVE_CONTROL__";
 
-class NativeControlContainer : public CWindowImpl<NativeControlContainer,
-                               CWindow,
-                               CWinTraits<WS_CHILD | WS_CLIPSIBLINGS |
-                                          WS_CLIPCHILDREN>> {
+class NativeControlContainer : public base::WindowImpl {
  public:
-
   explicit NativeControlContainer(NativeControl* parent) : parent_(parent),
                                                            control_(NULL) {
-    Create(parent->GetWidget()->GetNativeView());
-    ::ShowWindow(m_hWnd, SW_SHOW);
+    set_window_style(WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
+    Init(parent->GetWidget()->GetNativeView(), gfx::Rect());
+    ShowWindow(hwnd(), SW_SHOW);
   }
 
   virtual ~NativeControlContainer() {
   }
 
   // NOTE: If you add a new message, be sure and verify parent_ is valid before
   // calling into parent_.
-  DECLARE_FRAME_WND_CLASS(L"ChromeViewsNativeControlContainer", NULL);
-  BEGIN_MSG_MAP(NativeControlContainer);
+  BEGIN_MSG_MAP_EX(NativeControlContainer);
     MSG_WM_CREATE(OnCreate);
     MSG_WM_ERASEBKGND(OnEraseBkgnd);
     MSG_WM_PAINT(OnPaint);
     MSG_WM_SIZE(OnSize);
     MSG_WM_NOTIFY(OnNotify);
     MSG_WM_COMMAND(OnCommand);
     MSG_WM_DESTROY(OnDestroy);
     MSG_WM_CONTEXTMENU(OnContextMenu);
     MSG_WM_CTLCOLORBTN(OnCtlColorBtn);
     MSG_WM_CTLCOLORSTATIC(OnCtlColorStatic)
@@ skipping 10 matching lines @@
   }
 
   void OnFinalMessage(HWND hwnd) {
     if (parent_)
       parent_->NativeControlDestroyed();
     delete this;
   }
  private:
 
   LRESULT OnCreate(LPCREATESTRUCT create_struct) {
-    control_ = parent_->CreateNativeControl(m_hWnd);
+    control_ = parent_->CreateNativeControl(hwnd());
 
     // We subclass the control hwnd so we get the WM_KEYDOWN messages.
     WNDPROC original_handler =
         win_util::SetWindowProc(control_,
                                 &NativeControl::NativeControlWndProc);
     SetProp(control_, kHandlerKey, original_handler);
     SetProp(control_, kNativeControlKey , parent_);
 
-    ::ShowWindow(control_, SW_SHOW);
+    ShowWindow(control_, SW_SHOW);
     return 1;
   }
 
   LRESULT OnEraseBkgnd(HDC dc) {
     return 1;
   }
 
   void OnPaint(HDC ignore) {
     PAINTSTRUCT ps;
-    HDC dc = ::BeginPaint(*this, &ps);
-    ::EndPaint(*this, &ps);
+    HDC dc = BeginPaint(hwnd(), &ps);
+    EndPaint(hwnd(), &ps);
   }
 
   void OnSize(int type, const CSize& sz) {
-    ::MoveWindow(control_, 0, 0, sz.cx, sz.cy, TRUE);
+    MoveWindow(control_, 0, 0, sz.cx, sz.cy, TRUE);
   }
 
   LRESULT OnCommand(UINT code, int id, HWND source) {
     return parent_ ? parent_->OnCommand(code, id, source) : 0;
   }
 
   LRESULT OnNotify(int w_param, LPNMHDR l_param) {
     if (parent_)
       return parent_->OnNotify(w_param, l_param);
     else
@@ skipping 50 matching lines @@
                                  horizontal_alignment_(CENTER),
                                  fixed_height_(-1),
                                  vertical_alignment_(CENTER) {
   enabled_ = true;
   focusable_ = true;
 }
 
 NativeControl::~NativeControl() {
   if (container_) {
     container_->ResetParent();
-    ::DestroyWindow(*container_);
+    DestroyWindow(container_->hwnd());
   }
 }
 
 void NativeControl::ValidateNativeControl() {
   if (hwnd_view_ == NULL) {
     hwnd_view_ = new NativeViewHost;
     AddChildView(hwnd_view_);
   }
 
   if (!container_ && IsVisible()) {
     container_ = new NativeControlContainer(this);
-    hwnd_view_->Attach(*container_);
+    hwnd_view_->Attach(container_->hwnd());
     if (!enabled_)
       EnableWindow(GetNativeControlHWND(), enabled_);
 
     // This message ensures that the focus border is shown.
-    ::SendMessage(container_->GetControl(),
-                  WM_CHANGEUISTATE,
-                  MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS),
-                  0);
+    SendMessage(container_->GetControl(),
+                WM_CHANGEUISTATE,
+                MAKELPARAM(UIS_CLEAR, UISF_HIDEFOCUS),
+                0);
   }
 }
 
 void NativeControl::ViewHierarchyChanged(bool is_add, View *parent,
                                          View *child) {
   if (is_add && child == this && GetWidget()) {
     ValidateNativeControl();
     Layout();
   }
 }
@@ skipping 59 matching lines @@
     x = point.x();
     y = point.y();
     is_mouse = false;
   }
   ShowContextMenu(x, y, is_mouse);
 }
 
 void NativeControl::Focus() {
   if (container_) {
     DCHECK(container_->GetControl());
-    ::SetFocus(container_->GetControl());
+    SetFocus(container_->GetControl());
   }
 }
 
 HWND NativeControl::GetNativeControlHWND() {
   if (container_)
     return container_->GetControl();
   else
     return NULL;
 }
 
 void NativeControl::NativeControlDestroyed() {
   if (hwnd_view_)
     hwnd_view_->Detach();
   container_ = NULL;
 }
 
 void NativeControl::SetVisible(bool f) {
   if (f != IsVisible()) {
     View::SetVisible(f);
     if (!f && container_) {
-      ::DestroyWindow(*container_);
+      DestroyWindow(container_->hwnd());
     } else if (f && !container_) {
       ValidateNativeControl();
     }
   }
 }
 
 void NativeControl::SetEnabled(bool enabled) {
   if (enabled_ != enabled) {
     View::SetEnabled(enabled);
     if (GetNativeControlHWND()) {
       EnableWindow(GetNativeControlHWND(), enabled_);
     }
   }
 }
 
 void NativeControl::Paint(gfx::Canvas* canvas) {
 }
 
 void NativeControl::VisibilityChanged(View* starting_from, bool is_visible) {
   SetVisible(is_visible);
 }
 
 void NativeControl::SetFixedWidth(int width, Alignment alignment) {
-  DCHECK(width > 0);
+  DCHECK_GT(width, 0);
   fixed_width_ = width;
   horizontal_alignment_ = alignment;
 }
 
 void NativeControl::SetFixedHeight(int height, Alignment alignment) {
-  DCHECK(height > 0);
+  DCHECK_GT(height, 0);
   fixed_height_ = height;
   vertical_alignment_ = alignment;
 }
 
 DWORD NativeControl::GetAdditionalExStyle() const {
   // If the UI for the view is mirrored, we should make sure we add the
   // extended window style for a right-to-left layout so the subclass creates
   // a mirrored HWND for the underlying control.
   DWORD ex_style = 0;
   if (UILayoutIsRightToLeft())
@@ skipping 39 matching lines @@
                             reinterpret_cast<WNDPROC>(original_handler));
     RemoveProp(window, kHandlerKey);
     RemoveProp(window, kNativeControlKey);
   }
 
   return CallWindowProc(reinterpret_cast<WNDPROC>(original_handler), window,
                         message, w_param, l_param);
 }
 
 }  // namespace views