Re-land:

views/widget/widget_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 "views/widget/widget_win.h"
 
 #include <dwmapi.h>
 
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
@@ skipping 114 matching lines @@
 const int kCustomObjectID = 1;
 
 }  // namespace
 
 // static
 bool WidgetWin::screen_reader_active_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetWin, public:
 
-WidgetWin::WidgetWin()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)),
+WidgetWin::WidgetWin(internal::NativeWidgetDelegate* delegate)
+    : delegate_(delegate),
       close_widget_factory_(this),
       active_mouse_tracking_flags_(0),
       use_layered_buffer_(false),
       layered_alpha_(255),
       ALLOW_THIS_IN_INITIALIZER_LIST(paint_layered_window_factory_(this)),
       delete_on_destroy_(true),
       can_update_layered_window_(true),
       is_window_(false),
       restore_focus_when_enabled_(false),
       accessibility_view_events_index_(-1),
       accessibility_view_events_(kMaxAccessibilityViewEvents),
       previous_cursor_(NULL),
       is_input_method_win_(false) {
-  set_native_widget(this);
 }
 
 WidgetWin::~WidgetWin() {
   // We need to delete the input method before calling DestroyRootView(),
   // because it'll set focus_manager_ to NULL.
   input_method_.reset();
-  DestroyRootView();
+  if (delete_on_destroy_)
+    delete delegate_;
 }
 
 // static
 bool WidgetWin::IsAeroGlassEnabled() {
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return false;
   // If composition is not enabled, we behave like on XP.
   BOOL enabled = FALSE;
   return SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled;
 }
@@ skipping 17 matching lines @@
 void WidgetWin::ClearAccessibilityViewEvent(View* view) {
   for (std::vector<View*>::iterator it = accessibility_view_events_.begin();
       it != accessibility_view_events_.end();
       ++it) {
     if (*it == view)
       *it = NULL;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// WidgetWin, Widget implementation:
+// WidgetWin, NativeWidget implementation:
+
+void WidgetWin::InitNativeWidget(const Widget::InitParams& params) {
+  SetInitParams(params);
+
+  // Create the window.
+  gfx::NativeView parent = params.parent_widget ?
+      params.parent_widget->GetNativeView() : params.parent;
+  WindowImpl::Init(parent, params.bounds);
+}
+
+Widget* WidgetWin::GetWidget() {
+  return delegate_->AsWidget();
+}
+
+const Widget* WidgetWin::GetWidget() const {
+  return delegate_->AsWidget();
+}
 
 gfx::NativeView WidgetWin::GetNativeView() const {
   return WindowImpl::hwnd();
 }
 
 gfx::NativeWindow WidgetWin::GetNativeWindow() const {
   return WindowImpl::hwnd();
 }
 
-bool WidgetWin::GetAccelerator(int cmd_id, ui::Accelerator* accelerator) {
-  return false;
-}
-
-Window* WidgetWin::GetWindow() {
+Window* WidgetWin::GetContainingWindow() {
   return GetWindowImpl(hwnd());
 }
 
-const Window* WidgetWin::GetWindow() const {
+const Window* WidgetWin::GetContainingWindow() const {
   return GetWindowImpl(hwnd());
 }
 
-void WidgetWin::ViewHierarchyChanged(bool is_add, View* parent,
-                                     View* child) {
-  Widget::ViewHierarchyChanged(is_add, parent, child);
+void WidgetWin::ViewRemoved(View* view) {
   if (drop_target_.get())
-    drop_target_->ResetTargetViewIfEquals(child);
+    drop_target_->ResetTargetViewIfEquals(view);
 
-  if (!is_add)
-    ClearAccessibilityViewEvent(child);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// WidgetWin, NativeWidget implementation:
-
-void WidgetWin::InitNativeWidget(const Widget::InitParams& params) {
-  SetInitParams(params);
-
-  // Create the window.
-  gfx::NativeView parent = params.parent_widget ?
-      params.parent_widget->GetNativeView() : params.parent;
-  WindowImpl::Init(parent, params.bounds);
-}
-
-Widget* WidgetWin::GetWidget() {
-  return this;
+  ClearAccessibilityViewEvent(view);
 }
 
 void WidgetWin::SetNativeWindowProperty(const char* name, void* value) {
   // Remove the existing property (if any).
   for (ViewProps::iterator i = props_.begin(); i != props_.end(); ++i) {
     if ((*i)->Key() == name) {
       props_.erase(i);
       break;
     }
   }
 
   if (value)
     props_.push_back(new ViewProp(hwnd(), name, value));
 }
 
 void* WidgetWin::GetNativeWindowProperty(const char* name) {
   return ViewProp::GetValue(hwnd(), name);
 }
 
 TooltipManager* WidgetWin::GetTooltipManager() const {
   return tooltip_manager_.get();
 }
 
 bool WidgetWin::IsScreenReaderActive() const {
   return screen_reader_active_;
 }
 
+void WidgetWin::SendNativeAccessibilityEvent(
+    View* view,
+    ui::AccessibilityTypes::Event event_type) {
+  // Now call the Windows-specific method to notify MSAA clients of this
+  // event.  The widget gives us a temporary unique child ID to associate
+  // with this view so that clients can call get_accChild in
+  // NativeViewAccessibilityWin to retrieve the IAccessible associated
+  // with this view.
+  int child_id = AddAccessibilityViewEvent(view);
+  ::NotifyWinEvent(NativeViewAccessibilityWin::MSAAEvent(event_type),
+                   GetNativeView(), OBJID_CLIENT, child_id);
+}
+
 void WidgetWin::SetMouseCapture() {
   DCHECK(!HasMouseCapture());
   SetCapture(hwnd());
 }
 
 void WidgetWin::ReleaseMouseCapture() {
   ReleaseCapture();
 }
 
 bool WidgetWin::HasMouseCapture() const {
   return GetCapture() == hwnd();
 }
 
+bool WidgetWin::IsMouseButtonDown() const {
+  return (GetKeyState(VK_LBUTTON) & 0x80) ||
+      (GetKeyState(VK_RBUTTON) & 0x80) ||
+      (GetKeyState(VK_MBUTTON) & 0x80) ||
+      (GetKeyState(VK_XBUTTON1) & 0x80) ||
+      (GetKeyState(VK_XBUTTON2) & 0x80);
+}
+
 InputMethod* WidgetWin::GetInputMethodNative() {
   return input_method_.get();
 }
 
 void WidgetWin::ReplaceInputMethod(InputMethod* input_method) {
   input_method_.reset(input_method);
   if (input_method) {
     input_method->set_delegate(this);
     input_method->Init(GetWidget());
   }
@@ skipping 149 matching lines @@
 
 void WidgetWin::SetCursor(gfx::NativeCursor cursor) {
   if(cursor) {
     previous_cursor_ = ::SetCursor(cursor);
   } else if (previous_cursor_) {
     ::SetCursor(previous_cursor_);
     previous_cursor_ = NULL;
   }
 }
 
-void WidgetWin::NotifyAccessibilityEvent(
-    View* view,
-    ui::AccessibilityTypes::Event event_type,
-    bool send_native_event) {
-  // Send the notification to the delegate.
-  if (ViewsDelegate::views_delegate)
-    ViewsDelegate::views_delegate->NotifyAccessibilityEvent(view, event_type);
-
-  // Now call the Windows-specific method to notify MSAA clients of this
-  // event.  The widget gives us a temporary unique child ID to associate
-  // with this view so that clients can call get_accChild in
-  // NativeViewAccessibilityWin to retrieve the IAccessible associated
-  // with this view.
-  if (send_native_event) {
-    int child_id = AddAccessibilityViewEvent(view);
-    ::NotifyWinEvent(NativeViewAccessibilityWin::MSAAEvent(event_type),
-                     GetNativeView(), OBJID_CLIENT, child_id);
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetWin, MessageLoop::Observer implementation:
 
 void WidgetWin::WillProcessMessage(const MSG& msg) {
 }
 
 void WidgetWin::DidProcessMessage(const MSG& msg) {
   RedrawInvalidRect();
 }
 
@@ skipping 20 matching lines @@
   if (!ProcessWindowMessage(window, message, w_param, l_param, result))
     result = DefWindowProc(window, message, w_param, l_param);
   if (message == WM_NCDESTROY) {
     MessageLoopForUI::current()->RemoveObserver(this);
     OnFinalMessage(window);
   }
   if (message == WM_ACTIVATE)
     PostProcessActivateMessage(this, LOWORD(w_param));
   if (message == WM_ENABLE && restore_focus_when_enabled_) {
     restore_focus_when_enabled_ = false;
-    GetFocusManager()->RestoreFocusedView();
+    GetWidget()->GetFocusManager()->RestoreFocusedView();
   }
   return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetWin, protected:
 
 // Message handlers ------------------------------------------------------------
 
 void WidgetWin::OnActivate(UINT action, BOOL minimized, HWND window) {
@@ skipping 30 matching lines @@
   CHECK_EQ(this, GetNativeWidgetForNativeView(hwnd()));
 
   use_layered_buffer_ = !!(window_ex_style() & WS_EX_LAYERED);
 
   // Attempt to detect screen readers by sending an event with our custom id.
   if (!IsAccessibleWidget())
     NotifyWinEvent(EVENT_SYSTEM_ALERT, hwnd(), kCustomObjectID, CHILDID_SELF);
 
   props_.push_back(SetWindowSupportsRerouteMouseWheel(hwnd()));
 
-  drop_target_ = new DropTargetWin(GetRootView());
+  drop_target_ = new DropTargetWin(GetWidget()->GetRootView());
 
   // We need to add ourselves as a message loop observer so that we can repaint
   // aggressively if the contents of our window become invalid. Unfortunately
   // WM_PAINT messages are starved and we get flickery redrawing when resizing
   // if we do not do this.
   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));
+  if (GetWidget()->GetThemeProvider()->ShouldUseNativeFrame()) {
+    tooltip_manager_.reset(new AeroTooltipManager(GetWidget()));
   } else {
-    tooltip_manager_.reset(new TooltipManagerWin(this));
+    tooltip_manager_.reset(new TooltipManagerWin(GetWidget()));
   }
 
   // This message initializes the window so that focus border are shown for
   // windows.
   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(hwnd(), NULL, 0);
@@ skipping 19 matching lines @@
 void WidgetWin::OnDestroy() {
   if (drop_target_.get()) {
     RevokeDragDrop(hwnd());
     drop_target_ = NULL;
   }
 
   props_.reset();
 }
 
 void WidgetWin::OnDisplayChange(UINT bits_per_pixel, CSize screen_size) {
-  if (widget_delegate())
-    widget_delegate()->OnDisplayChanged();
+  if (GetWidget()->widget_delegate())
+    GetWidget()->widget_delegate()->OnDisplayChanged();
 }
 
 LRESULT WidgetWin::OnDwmCompositionChanged(UINT msg,
                                            WPARAM w_param,
                                            LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void WidgetWin::OnEndSession(BOOL ending, UINT logoff) {
@@ skipping 17 matching lines @@
   SetMsgHandled(FALSE);
 }
 
 LRESULT WidgetWin::OnGetObject(UINT uMsg, WPARAM w_param, LPARAM l_param) {
   LRESULT reference_result = static_cast<LRESULT>(0L);
 
   // Accessibility readers will send an OBJID_CLIENT message
   if (OBJID_CLIENT == l_param) {
     // Retrieve MSAA dispatch object for the root view.
     base::win::ScopedComPtr<IAccessible> root(
-        NativeViewAccessibilityWin::GetAccessibleForView(GetRootView()));
+        NativeViewAccessibilityWin::GetAccessibleForView(
+            GetWidget()->GetRootView()));
 
     // Create a reference that MSAA will marshall to the client.
     reference_result = LresultFromObject(IID_IAccessible, w_param,
         static_cast<IAccessible*>(root.Detach()));
   }
 
   if (kCustomObjectID == l_param) {
     // An MSAA client requestes our custom id. Assume that we have detected an
     // active windows screen reader.
     OnScreenReaderDetected();
@@ skipping 117 matching lines @@
     // Reroute the mouse wheel to the window under the pointer if applicable.
     return (views::RerouteMouseWheel(hwnd(), w_param, l_param) ||
             delegate_->OnMouseEvent(MouseWheelEvent(msg))) ? 0 : 1;
   }
 
   SetMsgHandled(delegate_->OnMouseEvent(event));
   return 0;
 }
 
 void WidgetWin::OnMove(const CPoint& point) {
-  if (widget_delegate())
-    widget_delegate()->OnWidgetMove();
+  // TODO(beng): move to Widget.
+  if (GetWidget()->widget_delegate())
+    GetWidget()->widget_delegate()->OnWidgetMove();
   SetMsgHandled(FALSE);
 }
 
 void WidgetWin::OnMoving(UINT param, const LPRECT new_bounds) {
-  if (widget_delegate())
-    widget_delegate()->OnWidgetMove();
+  // TODO(beng): move to Widget.
+  if (GetWidget()->widget_delegate())
+    GetWidget()->widget_delegate()->OnWidgetMove();
 }
 
 LRESULT WidgetWin::OnNCActivate(BOOL active) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 LRESULT WidgetWin::OnNCCalcSize(BOOL w_param, LPARAM l_param) {
   SetMsgHandled(FALSE);
   return 0;
@@ skipping 76 matching lines @@
   SetMsgHandled(FALSE);
   return 0;
 }
 
 LRESULT WidgetWin::OnSetText(const wchar_t* text) {
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void WidgetWin::OnSettingChange(UINT flags, const wchar_t* section) {
-  if (flags == SPI_SETWORKAREA && widget_delegate())
-    widget_delegate()->OnWorkAreaChanged();
+  // TODO(beng): move to Widget.
+  if (flags == SPI_SETWORKAREA && GetWidget()->widget_delegate())
+    GetWidget()->widget_delegate()->OnWorkAreaChanged();
   SetMsgHandled(FALSE);
 }
 
 void WidgetWin::OnSize(UINT param, const CSize& size) {
   SetMsgHandled(FALSE);
 }
 
 void WidgetWin::OnSysCommand(UINT notification_code, CPoint click) {
 }
 
@@ skipping 46 matching lines @@
     TrackMouseEvents(active_mouse_tracking_flags_ | TME_CANCEL);
     TrackMouseEvents(mouse_tracking_flags);
   }
 }
 
 void WidgetWin::OnScreenReaderDetected() {
   screen_reader_active_ = true;
 }
 
 void WidgetWin::SetInitialFocus() {
-  View* v = widget_delegate() ?
-      widget_delegate()->GetInitiallyFocusedView() : NULL;
+  // TODO(beng): move to Widget.
+  View* v = GetWidget()->widget_delegate() ?
+      GetWidget()->widget_delegate()->GetInitiallyFocusedView() : NULL;
   if (v)
     v->RequestFocus();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetWin, private:
 
 // static
 Window* WidgetWin::GetWindowImpl(HWND hwnd) {
   // NOTE: we can't use GetAncestor here as constrained windows are a Window,
   // but not a top level window.
   HWND parent = hwnd;
   while (parent) {
     WidgetWin* widget =
         reinterpret_cast<WidgetWin*>(ui::GetWindowUserData(parent));
     if (widget && widget->is_window_)
-      return static_cast<WindowWin*>(widget);
+      return static_cast<WindowWin*>(widget)->GetWindow();
     parent = ::GetParent(parent);
   }
   return NULL;
 }
 
 // static
 void WidgetWin::PostProcessActivateMessage(WidgetWin* widget,
                                            int activation_state) {
   if (!widget->delegate_->HasFocusManager()) {
     NOTREACHED();
@@ skipping 16 matching lines @@
     // again.
     if (!IsWindowEnabled(widget->GetNativeView())) {
       DCHECK(!widget->restore_focus_when_enabled_);
       widget->restore_focus_when_enabled_ = true;
       return;
     }
     focus_manager->RestoreFocusedView();
   }
 }
 
-void WidgetWin::SetInitParams(const InitParams& params) {
+void WidgetWin::SetInitParams(const Widget::InitParams& params) {
   // Set non-style attributes.
   delete_on_destroy_ = params.delete_on_destroy;
 
   DWORD style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
   DWORD ex_style = 0;
   DWORD class_style = CS_DBLCLKS;
 
   // Set type-independent style attributes.
   if (params.child)
     style |= WS_CHILD | WS_VISIBLE;
   if (!params.accept_events)
     ex_style |= WS_EX_TRANSPARENT;
   if (!params.can_activate)
     ex_style |= WS_EX_NOACTIVATE;
   if (params.keep_on_top)
     ex_style |= WS_EX_TOPMOST;
   if (params.mirror_origin_in_rtl)
     ex_style |= l10n_util::GetExtendedTooltipStyles();
   if (params.transparent)
     ex_style |= WS_EX_LAYERED;
   if (params.has_dropshadow) {
     class_style |= (base::win::GetVersion() < base::win::VERSION_XP) ?
         0 : CS_DROPSHADOW;
   }
 
   // Set type-dependent style attributes.
   switch (params.type) {
-    case InitParams::TYPE_WINDOW:
-    case InitParams::TYPE_CONTROL:
+    case Widget::InitParams::TYPE_WINDOW:
+    case Widget::InitParams::TYPE_CONTROL:
       break;
-    case InitParams::TYPE_POPUP:
+    case Widget::InitParams::TYPE_POPUP:
       style |= WS_POPUP;
       ex_style |= WS_EX_TOOLWINDOW;
       break;
-    case InitParams::TYPE_MENU:
+    case Widget::InitParams::TYPE_MENU:
       style |= WS_POPUP;
-      is_mouse_button_pressed_ =
-          ((GetKeyState(VK_LBUTTON) & 0x80) ||
-          (GetKeyState(VK_RBUTTON) & 0x80) ||
-          (GetKeyState(VK_MBUTTON) & 0x80) ||
-          (GetKeyState(VK_XBUTTON1) & 0x80) ||
-          (GetKeyState(VK_XBUTTON2) & 0x80));
       break;
     default:
       NOTREACHED();
   }
 
   set_initial_class_style(class_style);
   set_window_style(window_style() | style);
   set_window_ex_style(window_ex_style() | ex_style);
 }
 
@@ skipping 10 matching lines @@
 void WidgetWin::RedrawLayeredWindowContents() {
   if (layered_window_invalid_rect_.IsEmpty())
     return;
 
   // We need to clip to the dirty rect ourselves.
   layered_window_contents_->save(SkCanvas::kClip_SaveFlag);
   layered_window_contents_->ClipRectInt(layered_window_invalid_rect_.x(),
                                         layered_window_invalid_rect_.y(),
                                         layered_window_invalid_rect_.width(),
                                         layered_window_invalid_rect_.height());
-  GetRootView()->Paint(layered_window_contents_.get());
+  GetWidget()->GetRootView()->Paint(layered_window_contents_.get());
   layered_window_contents_->restore();
 
   RECT wr;
   GetWindowRect(&wr);
   SIZE size = {wr.right - wr.left, wr.bottom - wr.top};
   POINT position = {wr.left, wr.top};
   HDC dib_dc = layered_window_contents_->beginPlatformPaint();
   POINT zero = {0, 0};
   BLENDFUNCTION blend = {AC_SRC_OVER, 0, layered_alpha_, AC_SRC_ALPHA};
   UpdateLayeredWindow(hwnd(), NULL, &position, &size, dib_dc, &zero,
                       RGB(0xFF, 0xFF, 0xFF), &blend, ULW_ALPHA);
   layered_window_invalid_rect_.SetRect(0, 0, 0, 0);
   layered_window_contents_->endPlatformPaint();
 }
 
 void WidgetWin::ClientAreaSizeChanged() {
   RECT r;
-  if (GetThemeProvider()->ShouldUseNativeFrame() || IsZoomed())
+  if (GetWidget()->GetThemeProvider()->ShouldUseNativeFrame() || IsZoomed())
     GetClientRect(&r);
   else
     GetWindowRect(&r);
   gfx::Size s(std::max(0, static_cast<int>(r.right - r.left)),
               std::max(0, static_cast<int>(r.bottom - r.top)));
   delegate_->OnSizeChanged(s);
   if (use_layered_buffer_) {
     layered_window_contents_.reset(
         new gfx::CanvasSkia(s.width(), s.height(), false));
   }
 }
 
 gfx::AcceleratedWidget WidgetWin::GetAcceleratedWidget() {
   // TODO(sky):
   return gfx::kNullAcceleratedWidget;
 }
 
 void WidgetWin::DispatchKeyEventPostIME(const KeyEvent& key) {
   SetMsgHandled(delegate_->OnKeyEvent(key));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
-Widget* Widget::CreateWidget() {
-  return new WidgetWin;
-}
-
-// static
 void Widget::NotifyLocaleChanged() {
   NOTIMPLEMENTED();
 }
 
+namespace {
+BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
+  NativeWidget* native_widget =
+      NativeWidget::GetNativeWidgetForNativeView(hwnd);
+  if (native_widget) {
+    Widget* widget = native_widget->GetWidget();
+    if (widget->is_secondary_widget())
+      widget->Close();
+  }
+  return TRUE;
+}
+}  // namespace
+
+// static
+void Widget::CloseAllSecondaryWidgets() {
+  EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
+}
+
 bool Widget::ConvertRect(const Widget* source,
                          const Widget* target,
                          gfx::Rect* rect) {
   DCHECK(source);
   DCHECK(target);
   DCHECK(rect);
 
   HWND source_hwnd = source->GetNativeView();
   HWND target_hwnd = target->GetNativeView();
   if (source_hwnd == target_hwnd)
     return true;
 
   RECT win_rect = rect->ToRECT();
   if (::MapWindowPoints(source_hwnd, target_hwnd,
                         reinterpret_cast<LPPOINT>(&win_rect),
                         sizeof(RECT)/sizeof(POINT))) {
     *rect = win_rect;
     return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidget, public:
 
+// static
+NativeWidget* NativeWidget::CreateNativeWidget(
+    internal::NativeWidgetDelegate* delegate) {
+  return new WidgetWin(delegate);
+}
+
+// static
 NativeWidget* NativeWidget::GetNativeWidgetForNativeView(
     gfx::NativeView native_view) {
   return reinterpret_cast<WidgetWin*>(
       ViewProp::GetValue(native_view, kNativeWidgetKey));
 }
 
+// static
 NativeWidget* NativeWidget::GetNativeWidgetForNativeWindow(
     gfx::NativeWindow native_window) {
   return GetNativeWidgetForNativeView(native_window);
 }
 
+// static
 NativeWidget* NativeWidget::GetTopLevelNativeWidget(
     gfx::NativeView native_view) {
   if (!native_view)
     return NULL;
 
   // First, check if the top-level window is a Widget.
   HWND root = ::GetAncestor(native_view, GA_ROOT);
   if (!root)
     return NULL;
 
   NativeWidget* widget = GetNativeWidgetForNativeView(root);
   if (widget)
     return widget;
 
   // Second, try to locate the last Widget window in the parent hierarchy.
   HWND parent_hwnd = native_view;
   NativeWidget* parent_widget;
   do {
     parent_widget = GetNativeWidgetForNativeView(parent_hwnd);
     if (parent_widget) {
       widget = parent_widget;
       parent_hwnd = ::GetAncestor(parent_hwnd, GA_PARENT);
     }
   } while (parent_hwnd != NULL && parent_widget != NULL);
 
   return widget;
 }
 
+// static
 void NativeWidget::GetAllNativeWidgets(gfx::NativeView native_view,
                                        NativeWidgets* children) {
   if (!native_view)
     return;
 
   NativeWidget* native_widget = GetNativeWidgetForNativeView(native_view);
   if (native_widget)
     children->insert(native_widget);
   EnumChildWindows(native_view, EnumerateChildWindowsForNativeWidgets,
       reinterpret_cast<LPARAM>(children));
 }
 
+// static
 void NativeWidget::ReparentNativeView(gfx::NativeView native_view,
                                       gfx::NativeView new_parent) {
   if (!native_view)
     return;
 
   HWND previous_parent = ::GetParent(native_view);
   if (previous_parent == new_parent)
     return;
 
   NativeWidgets widgets;
@@ skipping 13 matching lines @@
 
   // And now, notify them that they have a brand new parent.
   for (NativeWidgets::iterator it = widgets.begin();
        it != widgets.end(); ++it) {
     (*it)->GetWidget()->NotifyNativeViewHierarchyChanged(true,
                                                          new_parent);
   }
 }
 
 }  // namespace views