Factor out window creation into base::WindowImpl. This class will be used in...

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/root_view.h"
 #include "views/window/window_win.h"
 
 namespace views {
 
-static const DWORD kWindowDefaultChildStyle =
-    WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
-static const DWORD kWindowDefaultStyle = WS_OVERLAPPEDWINDOW;
-static const DWORD kWindowDefaultExStyle = 0;
-
 // 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;
 }
 
 RootView* GetRootViewForHWND(HWND hwnd) {
   return reinterpret_cast<RootView*>(::GetProp(hwnd, kRootViewWindowProperty));
 }
 
 NativeControlWin* GetNativeControlWinForHWND(HWND hwnd) {
   return reinterpret_cast<NativeControlWin*>(
       ::GetProp(hwnd, NativeControlWin::kNativeControlWinKey));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// Window class tracking.
-
-// static
-const wchar_t* const WidgetWin::kBaseClassName =
-    L"Chrome_WidgetWin_";
-
-// Window class information used for registering unique windows.
-struct ClassInfo {
-  UINT style;
-  HBRUSH background;
-
-  explicit ClassInfo(int style)
-      : style(style),
-        background(NULL) {}
-
-  // Compares two ClassInfos. Returns true if all members match.
-  bool Equals(const ClassInfo& other) const {
-    return (other.style == style && other.background == background);
-  }
-};
-
-class ClassRegistrar {
- public:
-  ~ClassRegistrar() {
-    for (RegisteredClasses::iterator i = registered_classes_.begin();
-         i != registered_classes_.end(); ++i) {
-      UnregisterClass(i->name.c_str(), NULL);
-    }
-  }
-
-  // Puts the name for the class matching |class_info| in |class_name|, creating
-  // a new name if the class is not yet known.
-  // Returns true if this class was already known, false otherwise.
-  bool RetrieveClassName(const ClassInfo& class_info, std::wstring* name) {
-    for (RegisteredClasses::const_iterator i = registered_classes_.begin();
-         i != registered_classes_.end(); ++i) {
-      if (class_info.Equals(i->info)) {
-        name->assign(i->name);
-        return true;
-      }
-    }
-
-    name->assign(std::wstring(WidgetWin::kBaseClassName) +
-        IntToWString(registered_count_++));
-    return false;
-  }
-
-  void RegisterClass(const ClassInfo& class_info,
-                     const std::wstring& name,
-                     ATOM atom) {
-    registered_classes_.push_back(RegisteredClass(class_info, name, atom));
-  }
-
- private:
-  // Represents a registered window class.
-  struct RegisteredClass {
-    RegisteredClass(const ClassInfo& info,
-                    const std::wstring& name,
-                    ATOM atom)
-        : info(info),
-          name(name),
-          atom(atom) {
-    }
-
-    // Info used to create the class.
-    ClassInfo info;
-
-    // The name given to the window.
-    std::wstring name;
-
-    // The ATOM returned from creating the window.
-    ATOM atom;
-  };
-
-  ClassRegistrar() : registered_count_(0) { }
-  friend struct DefaultSingletonTraits<ClassRegistrar>;
-
-  typedef std::list<RegisteredClass> RegisteredClasses;
-  RegisteredClasses registered_classes_;
-
-  // Counter of how many classes have ben registered so far.
-  int registered_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(ClassRegistrar);
-};
-
-///////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public
 
 WidgetWin::WidgetWin()
     : close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       has_capture_(false),
-      window_style_(0),
-      window_ex_style_(kWindowDefaultExStyle),
       use_layered_buffer_(true),
       layered_alpha_(255),
       delete_on_destroy_(true),
       can_update_layered_window_(true),
       last_mouse_event_was_move_(false),
       is_mouse_down_(false),
-      is_window_(false),
-      class_style_(CS_DBLCLKS),
-      hwnd_(NULL) {
+      is_window_(false) {
 }
 
 WidgetWin::~WidgetWin() {
   MessageLoopForUI::current()->RemoveObserver(this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Widget implementation:
 
 void WidgetWin::Init(gfx::NativeView parent, const gfx::Rect& bounds) {
-  if (window_style_ == 0)
-    window_style_ = parent ? kWindowDefaultChildStyle : kWindowDefaultStyle;
+  // Force creation of the RootView; otherwise, we may get a WM_SIZE after the
+  // window is created and before the root view is set up.
+  GetRootView();
+
+  // Create the window.
+  WindowImpl::Init(parent, bounds);
 
   // See if the style has been overridden.
-  opaque_ = !(window_ex_style_ & WS_EX_TRANSPARENT);
+  opaque_ = !(window_ex_style() & WS_EX_TRANSPARENT);
   use_layered_buffer_ = (use_layered_buffer_ &&
-                         !!(window_ex_style_ & WS_EX_LAYERED));
-
-  // Force creation of the RootView if it hasn't been created yet.
-  GetRootView();
+                         !!(window_ex_style() & WS_EX_LAYERED));
 
   default_theme_provider_.reset(new DefaultThemeProvider());
 
-  // Ensures the parent we have been passed is valid, otherwise CreateWindowEx
-  // will fail.
-  if (parent && !::IsWindow(parent)) {
-    NOTREACHED() << "invalid parent window specified.";
-    parent = NULL;
-  }
-
-  hwnd_ = CreateWindowEx(window_ex_style_, GetWindowClassName().c_str(), L"",
-                         window_style_, bounds.x(), bounds.y(), bounds.width(),
-                         bounds.height(), parent, NULL, NULL, this);
-  DCHECK(hwnd_);
-  SetWindowSupportsRerouteMouseWheel(hwnd_);
-
-  // The window procedure should have set the data for us.
-  DCHECK(win_util::GetWindowUserData(hwnd_) == this);
+  SetWindowSupportsRerouteMouseWheel(GetNativeView());
 
   root_view_->OnWidgetCreated();
 
-  if ((window_style_ & WS_CHILD) == 0) {
+  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(hwnd_, root_view_.get());
+  SetRootViewForHWND(GetNativeView(), 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));
@@ skipping 18 matching lines @@
 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(hwnd_, &p);
+  ::ClientToScreen(GetNativeView(), &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 38 matching lines @@
     // 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 hwnd_;
+  return WindowImpl::GetNativeView();
 }
 
 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(hwnd_, &location_in_parent);
+      ClientToScreen(GetNativeView(), &location_in_parent);
       ::ScreenToClient(GetParent(), &location_in_parent);
       parent_update_rect.OffsetRect(location_in_parent);
       ::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(hwnd_, &update_rect.ToRECT(), NULL,
+      ::RedrawWindow(GetNativeView(), &update_rect.ToRECT(), NULL,
                      RDW_INVALIDATE | RDW_UPDATENOW | RDW_NOCHILDREN);
 
       LPARAM lparam = reinterpret_cast<LPARAM>(&invalid_screen_rect);
-      EnumChildWindows(hwnd_, EnumChildProcForRedraw, lparam);
+      EnumChildWindows(GetNativeView(), 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(hwnd_, GA_ROOT)));
+      win_util::GetWindowUserData(GetAncestor(GetNativeView(), GA_ROOT)));
 }
 
 bool WidgetWin::IsVisible() const {
   return !!::IsWindowVisible(GetNativeView());
 }
 
 bool WidgetWin::IsActive() const {
   return win_util::IsWindowActive(GetNativeView());
 }
 
@@ skipping 19 matching lines @@
       return provider;
 
     provider = widget->GetDefaultThemeProvider();
     if (provider)
       return provider;
   }
   return default_theme_provider_.get();
 }
 
 Window* WidgetWin::GetWindow() {
-  return GetWindowImpl(hwnd_);
+  return GetWindowImpl(GetNativeView());
 }
 
 const Window* WidgetWin::GetWindow() const {
-  return GetWindowImpl(hwnd_);
+  return GetWindowImpl(GetNativeView());
 }
 
 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::SetUseLayeredBuffer(bool use_layered_buffer) {
   if (use_layered_buffer_ == use_layered_buffer)
     return;
 
   use_layered_buffer_ = use_layered_buffer;
-  if (!hwnd_)
+  if (!GetNativeView())
     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 88 matching lines @@
   }
 }
 
 void WidgetWin::OnClose() {
   Close();
 }
 
 void WidgetWin::OnDestroy() {
   root_view_->OnWidgetDestroyed();
 
-  RemoveProp(hwnd_, kRootViewWindowProperty);
+  RemoveProp(GetNativeView(), 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(hwnd_, w_param, l_param)) {
+      views::RerouteMouseWheel(GetNativeView(), 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 280 matching lines @@
   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(
-        hwnd_, NULL, &window_position, &size, dib_dc, &zero_origin,
+        GetNativeView(), NULL, &window_position, &size, dib_dc, &zero_origin,
         RGB(0xFF, 0xFF, 0xFF), &blend, ULW_ALPHA);
   }
 }
 
-std::wstring WidgetWin::GetWindowClassName() {
-  ClassInfo class_info(initial_class_style());
-  std::wstring name;
-  if (Singleton<ClassRegistrar>()->RetrieveClassName(class_info, &name))
-    return name;
-
-  // No class found, need to register one.
-  WNDCLASSEX class_ex;
-  class_ex.cbSize = sizeof(WNDCLASSEX);
-  class_ex.style = class_info.style;
-  class_ex.lpfnWndProc = &WidgetWin::WndProc;
-  class_ex.cbClsExtra = 0;
-  class_ex.cbWndExtra = 0;
-  class_ex.hInstance = NULL;
-  class_ex.hIcon = NULL;
-  if (ViewsDelegate::views_delegate)
-    class_ex.hIcon = ViewsDelegate::views_delegate->GetDefaultWindowIcon();
-  class_ex.hCursor = LoadCursor(NULL, IDC_ARROW);
-  class_ex.hbrBackground = reinterpret_cast<HBRUSH>(class_info.background + 1);
-  class_ex.lpszMenuName = NULL;
-  class_ex.lpszClassName = name.c_str();
-  class_ex.hIconSm = class_ex.hIcon;
-  ATOM atom = RegisterClassEx(&class_ex);
-  DCHECK(atom);
-
-  Singleton<ClassRegistrar>()->RegisterClass(class_info, name, atom);
-
-  return name;
-}
-
 // 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) {
     case WM_NOTIFY:
       return reinterpret_cast<NMHDR*>(l_param)->hwndFrom;
     case WM_COMMAND:
       return reinterpret_cast<HWND>(l_param);
     case WM_CONTEXTMENU:
       return reinterpret_cast<HWND>(w_param);
     case WM_CTLCOLORBTN:
     case WM_CTLCOLORSTATIC:
       return reinterpret_cast<HWND>(l_param);
   }
   return NULL;
 }
 
+HICON WidgetWin::GetDefaultWindowIcon() const {
+  if (ViewsDelegate::views_delegate)
+    return ViewsDelegate::views_delegate->GetDefaultWindowIcon();
+  return NULL;
+}
+
 // Some messages may be sent to us by a child HWND managed by
 // NativeControlWin. If this is the case, this function will forward those
 // messages on to the object associated with the source HWND and return true,
 // in which case the window procedure must not do any further processing of
 // the message. If there is no associated NativeControlWin, the return value
 // will be false and the WndProc can continue processing the message normally.
 // |l_result| contains the result of the message processing by the control and
 // must be returned by the WndProc if the return value is true.
 bool ProcessNativeControlMessage(UINT message,
                                  WPARAM w_param,
                                  LPARAM l_param,
                                  LRESULT* l_result) {
   *l_result = 0;
 
   HWND control_hwnd = GetControlHWNDForMessage(message, w_param, l_param);
   if (IsWindow(control_hwnd)) {
     NativeControlWin* wrapper = GetNativeControlWinForHWND(control_hwnd);
     if (wrapper)
       return wrapper->ProcessMessage(message, w_param, l_param, l_result);
   }
 
   return false;
 }
 
-// static
-LRESULT CALLBACK WidgetWin::WndProc(HWND window, UINT message,
-                                    WPARAM w_param, LPARAM l_param) {
-  if (message == WM_NCCREATE) {
-    CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(l_param);
-    WidgetWin* widget = reinterpret_cast<WidgetWin*>(cs->lpCreateParams);
-    DCHECK(widget);
-    win_util::SetWindowUserData(window, widget);
-    widget->hwnd_ = window;
-    return TRUE;
-  }
-
-  WidgetWin* widget = reinterpret_cast<WidgetWin*>(
-      win_util::GetWindowUserData(window));
-  if (!widget)
-    return 0;
-
+LRESULT WidgetWin::OnWndProc(UINT message, WPARAM w_param, LPARAM l_param) {
+  HWND window = GetNativeView();
   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 (!widget->ProcessWindowMessage(window, message, w_param, l_param, result))
+  if (!ProcessWindowMessage(window, message, w_param, l_param, result))
     result = DefWindowProc(window, message, w_param, l_param);
   if (message == WM_NCDESTROY)
-    widget->OnFinalMessage(window);
+    OnFinalMessage(window);
   if (message == WM_ACTIVATE)
-    PostProcessActivateMessage(widget, LOWORD(w_param));
+    PostProcessActivateMessage(this, LOWORD(w_param));
   return result;
 }
 
 // static
 void WidgetWin::PostProcessActivateMessage(WidgetWin* widget,
                                            int activation_state) {
   if (!widget->focus_manager_.get()) {
     NOTREACHED();
     return;
   }
@@ skipping 14 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
-