Move more code from NWW to HWNDMessageHandler.

ui/views/widget/native_widget_win.cc

 // Copyright (c) 2012 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 "ui/views/widget/native_widget_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include <algorithm>
@@ skipping 11 matching lines @@
 #include "ui/base/keycodes/keyboard_code_conversion_win.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/theme_provider.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/base/win/mouse_wheel_util.h"
 #include "ui/base/win/shell.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_paint.h"
 #include "ui/gfx/canvas_skia_paint.h"
-#include "ui/gfx/icon_util.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/accessibility/native_view_accessibility_win.h"
 #include "ui/views/controls/native_control_win.h"
 #include "ui/views/controls/textfield/native_textfield_views.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/focus/accelerator_handler.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/focus/widget_focus_manager.h"
 #include "ui/views/ime/input_method_win.h"
-#include "ui/views/views_delegate.h"
 #include "ui/views/widget/aero_tooltip_manager.h"
-#include "ui/views/widget/child_window_message_processor.h"
 #include "ui/views/widget/drop_target_win.h"
 #include "ui/views/widget/monitor_win.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/widget_hwnd_utils.h"
 #include "ui/views/win/fullscreen_handler.h"
 #include "ui/views/win/hwnd_message_handler.h"
 #include "ui/views/window/native_frame_view.h"
 
 #if !defined(USE_AURA)
 #include "base/command_line.h"
 #include "ui/base/ui_base_switches.h"
 #endif
 
 #pragma comment(lib, "dwmapi.lib")
 
 using ui::ViewProp;
 
 namespace views {
 
 namespace {
 
-// 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;
-}
-
-// Some messages may be sent to us by a child HWND. 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
-// ChildWindowMessageProcessor, 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 ProcessChildWindowMessage(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)) {
-    ChildWindowMessageProcessor* processor =
-        ChildWindowMessageProcessor::Get(control_hwnd);
-    if (processor)
-      return processor->ProcessMessage(message, w_param, l_param, l_result);
-  }
-
-  return false;
-}
-
 // Enumeration callback for NativeWidget::GetAllChildWidgets(). Called for each
 // child HWND beneath the original HWND.
 BOOL CALLBACK EnumerateChildWindowsForNativeWidgets(HWND hwnd, LPARAM l_param) {
   Widget* widget = Widget::GetWidgetForNativeView(hwnd);
   if (widget) {
     Widget::Widgets* widgets = reinterpret_cast<Widget::Widgets*>(l_param);
     widgets->insert(widget);
   }
   return TRUE;
 }
 
-// Enables or disables the menu item for the specified command and menu.
-void EnableMenuItem(HMENU menu, UINT command, bool enabled) {
-  UINT flags = MF_BYCOMMAND | (enabled ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
-  EnableMenuItem(menu, command, flags);
-}
-
 // Links the HWND to its NativeWidget.
 const char* const kNativeWidgetKey = "__VIEWS_NATIVE_WIDGET__";
 
 const int kDragFrameWindowAlpha = 200;
 
 }  // namespace
 
 // static
 bool NativeWidgetWin::screen_reader_active_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, public:
 
 NativeWidgetWin::NativeWidgetWin(internal::NativeWidgetDelegate* delegate)
     : delegate_(delegate),
-      ALLOW_THIS_IN_INITIALIZER_LIST(close_widget_factory_(this)),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
-      restore_focus_when_enabled_(false),
       accessibility_view_events_index_(-1),
       accessibility_view_events_(kMaxAccessibilityViewEvents),
-      restored_enabled_(false),
       has_non_client_view_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           message_handler_(new HWNDMessageHandler(this))) {
 }
 
 NativeWidgetWin::~NativeWidgetWin() {
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete delegate_;
   else
     CloseNow();
 }
 
 // static
 gfx::Font NativeWidgetWin::GetWindowTitleFont() {
   NONCLIENTMETRICS ncm;
   base::win::GetNonClientMetrics(&ncm);
   l10n_util::AdjustUIFont(&(ncm.lfCaptionFont));
   base::win::ScopedHFONT caption_font(CreateFontIndirect(&(ncm.lfCaptionFont)));
   return gfx::Font(caption_font);
 }
 
 void NativeWidgetWin::Show(int show_state) {
-  ShowWindow(show_state);
-  // When launched from certain programs like bash and Windows Live Messenger,
-  // show_state is set to SW_HIDE, so we need to correct that condition. We
-  // don't just change show_state to SW_SHOWNORMAL because MSDN says we must
-  // always first call ShowWindow with the specified value from STARTUPINFO,
-  // otherwise all future ShowWindow calls will be ignored (!!#@@#!). Instead,
-  // we call ShowWindow again in this case.
-  if (show_state == SW_HIDE) {
-    show_state = SW_SHOWNORMAL;
-    ShowWindow(show_state);
-  }
-
-  // We need to explicitly activate the window if we've been shown with a state
-  // that should activate, because if we're opened from a desktop shortcut while
-  // an existing window is already running it doesn't seem to be enough to use
-  // one of these flags to activate the window.
-  if (show_state == SW_SHOWNORMAL || show_state == SW_SHOWMAXIMIZED)
-    Activate();
-
-  SetInitialFocus();
+  message_handler_->Show(show_state);
 }
 
 View* NativeWidgetWin::GetAccessibilityViewEventAt(int id) {
   // Convert from MSAA child id.
   id = -(id + 1);
   DCHECK(id >= 0 && id < kMaxAccessibilityViewEvents);
   return accessibility_view_events_[id];
 }
 
 int NativeWidgetWin::AddAccessibilityViewEvent(View* view) {
   accessibility_view_events_index_ =
       (accessibility_view_events_index_ + 1) % kMaxAccessibilityViewEvents;
   accessibility_view_events_[accessibility_view_events_index_] = view;
 
   // Convert to MSAA child id.
   return -(accessibility_view_events_index_ + 1);
 }
 
 void NativeWidgetWin::ClearAccessibilityViewEvent(View* view) {
   for (std::vector<View*>::iterator it = accessibility_view_events_.begin();
       it != accessibility_view_events_.end();
       ++it) {
     if (*it == view)
       *it = NULL;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetWin, CompositorDelegate implementation:
-
-////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, NativeWidget implementation:
 
 void NativeWidgetWin::InitNativeWidget(const Widget::InitParams& params) {
   SetInitParams(params);
 
   message_handler_->Init(params.bounds);
 
   // Create the window.
   WindowImpl::Init(params.GetParent(), params.bounds);
 }
@@ skipping 78 matching lines @@
   return tooltip_manager_.get();
 }
 
 bool NativeWidgetWin::IsScreenReaderActive() const {
   return screen_reader_active_;
 }
 
 void NativeWidgetWin::SendNativeAccessibilityEvent(
     View* view,
     ui::AccessibilityTypes::Event event_type) {
-  int child_id = AddAccessibilityViewEvent(view);
-  message_handler_->SendNativeAccessibilityEvent(child_id, event_type);
+  message_handler_->SendNativeAccessibilityEvent(
+      AddAccessibilityViewEvent(view), event_type);
 }
 
 void NativeWidgetWin::SetCapture() {
   message_handler_->SetCapture();
 }
 
 void NativeWidgetWin::ReleaseCapture() {
   message_handler_->ReleaseCapture();
 }
 
@@ skipping 13 matching lines @@
   message_handler_->CenterWindow(size);
 }
 
 void NativeWidgetWin::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   message_handler_->GetWindowPlacement(bounds, show_state);
 }
 
 void NativeWidgetWin::SetWindowTitle(const string16& title) {
-  SetWindowText(GetNativeView(), title.c_str());
-  SetAccessibleName(title);
+  message_handler_->SetTitle(title);
 }
 
 void NativeWidgetWin::SetWindowIcons(const gfx::ImageSkia& window_icon,
                                      const gfx::ImageSkia& app_icon) {
-  if (!window_icon.isNull()) {
-    HICON windows_icon = IconUtil::CreateHICONFromSkBitmap(window_icon);
-    // We need to make sure to destroy the previous icon, otherwise we'll leak
-    // these GDI objects until we crash!
-    HICON old_icon = reinterpret_cast<HICON>(
-        SendMessage(GetNativeView(), WM_SETICON, ICON_SMALL,
-                    reinterpret_cast<LPARAM>(windows_icon)));
-    if (old_icon)
-      DestroyIcon(old_icon);
-  }
-  if (!app_icon.isNull()) {
-    HICON windows_icon = IconUtil::CreateHICONFromSkBitmap(app_icon);
-    HICON old_icon = reinterpret_cast<HICON>(
-        SendMessage(GetNativeView(), WM_SETICON, ICON_BIG,
-                    reinterpret_cast<LPARAM>(windows_icon)));
-    if (old_icon)
-      DestroyIcon(old_icon);
-  }
+  message_handler_->SetWindowIcons(window_icon, app_icon);
 }
 
 void NativeWidgetWin::SetAccessibleName(const string16& name) {
-  base::win::ScopedComPtr<IAccPropServices> pAccPropServices;
-  HRESULT hr = CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER,
-      IID_IAccPropServices, reinterpret_cast<void**>(&pAccPropServices));
-  if (SUCCEEDED(hr))
-    hr = pAccPropServices->SetHwndPropStr(GetNativeView(), OBJID_CLIENT,
-                                          CHILDID_SELF, PROPID_ACC_NAME,
-                                          name.c_str());
+  message_handler_->SetAccessibleName(name);
 }
 
 void NativeWidgetWin::SetAccessibleRole(ui::AccessibilityTypes::Role role) {
-  base::win::ScopedComPtr<IAccPropServices> pAccPropServices;
-  HRESULT hr = CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER,
-      IID_IAccPropServices, reinterpret_cast<void**>(&pAccPropServices));
-  if (SUCCEEDED(hr)) {
-    VARIANT var;
-    if (role) {
-      var.vt = VT_I4;
-      var.lVal = NativeViewAccessibilityWin::MSAARole(role);
-      hr = pAccPropServices->SetHwndProp(GetNativeView(), OBJID_CLIENT,
-                                         CHILDID_SELF, PROPID_ACC_ROLE, var);
-    }
-  }
+  message_handler_->SetAccessibleRole(role);
 }
 
 void NativeWidgetWin::SetAccessibleState(ui::AccessibilityTypes::State state) {
-  base::win::ScopedComPtr<IAccPropServices> pAccPropServices;
-  HRESULT hr = CoCreateInstance(CLSID_AccPropServices, NULL, CLSCTX_SERVER,
-      IID_IAccPropServices, reinterpret_cast<void**>(&pAccPropServices));
-  if (SUCCEEDED(hr)) {
-    VARIANT var;
-    if (state) {
-      var.vt = VT_I4;
-      var.lVal = NativeViewAccessibilityWin::MSAAState(state);
-      hr = pAccPropServices->SetHwndProp(GetNativeView(), OBJID_CLIENT,
-                                         CHILDID_SELF, PROPID_ACC_STATE, var);
-    }
-  }
+  message_handler_->SetAccessibleState(state);
 }
 
 void NativeWidgetWin::InitModalType(ui::ModalType modal_type) {
   message_handler_->InitModalType(modal_type);
 }
 
 gfx::Rect NativeWidgetWin::GetWindowBoundsInScreen() const {
   return message_handler_->GetWindowBoundsInScreen();
 }
 
@@ skipping 23 matching lines @@
 
 void NativeWidgetWin::StackBelow(gfx::NativeView native_view) {
   NOTIMPLEMENTED();
 }
 
 void NativeWidgetWin::SetShape(gfx::NativeRegion region) {
   message_handler_->SetRegion(region);
 }
 
 void NativeWidgetWin::Close() {
-  if (!IsWindow())
-    return;  // No need to do anything.
-
-  // Let's hide ourselves right away.
-  Hide();
-
-  // Modal dialog windows disable their owner windows; re-enable them now so
-  // they can activate as foreground windows upon this window's destruction.
-  RestoreEnabledIfNecessary();
-
-  if (!close_widget_factory_.HasWeakPtrs()) {
-    // And we delay the close so that if we are called from an ATL callback,
-    // we don't destroy the window before the callback returned (as the caller
-    // may delete ourselves on destroy and the ATL callback would still
-    // dereference us when the callback returns).
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&NativeWidgetWin::CloseNow,
-                   close_widget_factory_.GetWeakPtr()));
-  }
+  message_handler_->Close();
 }
 
 void NativeWidgetWin::CloseNow() {
   message_handler_->CloseNow();
 }
 
 void NativeWidgetWin::Show() {
-  if (!IsWindow())
-    return;
-
-  ShowWindow(SW_SHOWNOACTIVATE);
-  SetInitialFocus();
+  message_handler_->Show();
 }
 
 void NativeWidgetWin::Hide() {
   message_handler_->Hide();
 }
 
 void NativeWidgetWin::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   message_handler_->ShowMaximizedWithBounds(restored_bounds);
 }
 
 void NativeWidgetWin::ShowWithWindowState(ui::WindowShowState show_state) {
-  DWORD native_show_state;
-  switch (show_state) {
-    case ui::SHOW_STATE_INACTIVE:
-      native_show_state = SW_SHOWNOACTIVATE;
-      break;
-    case ui::SHOW_STATE_MAXIMIZED:
-      native_show_state = SW_SHOWMAXIMIZED;
-      break;
-    case ui::SHOW_STATE_MINIMIZED:
-      native_show_state = SW_SHOWMINIMIZED;
-      break;
-    default:
-      native_show_state = GetShowState();
-      break;
-  }
-  Show(native_show_state);
+  message_handler_->ShowWindowWithState(show_state);
 }
 
 bool NativeWidgetWin::IsVisible() const {
   return message_handler_->IsVisible();
 }
 
 void NativeWidgetWin::Activate() {
   message_handler_->Activate();
 }
 
@@ skipping 110 matching lines @@
 void NativeWidgetWin::SetInactiveRenderingDisabled(bool value) {
 }
 
 Widget::MoveLoopResult NativeWidgetWin::RunMoveLoop(
     const gfx::Point& drag_offset) {
   return message_handler_->RunMoveLoop(drag_offset) ?
       Widget::MOVE_LOOP_SUCCESSFUL : Widget::MOVE_LOOP_CANCELED;
 }
 
 void NativeWidgetWin::EndMoveLoop() {
-  SendMessage(hwnd(), WM_CANCELMODE, 0, 0);
+  message_handler_->EndMoveLoop();
 }
 
 void NativeWidgetWin::SetVisibilityChangedAnimationsEnabled(bool value) {
   message_handler_->SetVisibilityChangedAnimationsEnabled(value);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, MessageLoop::Observer implementation:
 
 base::EventStatus NativeWidgetWin::WillProcessEvent(
     const base::NativeEvent& event) {
   return base::EVENT_CONTINUE;
 }
 
 void NativeWidgetWin::DidProcessEvent(const base::NativeEvent& event) {
   message_handler_->RedrawInvalidRect();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, WindowImpl overrides:
 
 HICON NativeWidgetWin::GetDefaultWindowIcon() const {
-  if (ViewsDelegate::views_delegate)
-    return ViewsDelegate::views_delegate->GetDefaultWindowIcon();
-  return NULL;
+  return message_handler_->GetDefaultWindowIcon();
 }
 
 LRESULT NativeWidgetWin::OnWndProc(UINT message,
                                    WPARAM w_param,
                                    LPARAM l_param) {
-  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 NativeWidgetWin.
-  if (ProcessChildWindowMessage(message, w_param, l_param, &result))
-    return result;
-
-  // Otherwise we handle everything else.
-  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);
-  }
-
-  // Only top level widget should store/restore focus.
-  if (message == WM_ACTIVATE && GetWidget()->is_top_level())
-    PostProcessActivateMessage(this, LOWORD(w_param));
-  if (message == WM_ENABLE && restore_focus_when_enabled_) {
-    // This path should be executed only for top level as
-    // restore_focus_when_enabled_ is set in PostProcessActivateMessage.
-    DCHECK(GetWidget()->is_top_level());
-    restore_focus_when_enabled_ = false;
-    GetWidget()->GetFocusManager()->RestoreFocusedView();
-  }
-  return result;
+  return message_handler_->OnWndProc(message, w_param, l_param);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, protected:
 
 // Message handlers ------------------------------------------------------------
 
 void NativeWidgetWin::OnActivate(UINT action, BOOL minimized, HWND window) {
   message_handler_->OnActivate(action, minimized, window);
 }
@@ skipping 237 matching lines @@
   // WM_DESTROY that assume the properties are still valid (such as WM_CLOSE).
   props_.clear();
   delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, protected:
 
-int NativeWidgetWin::GetShowState() const {
-  return SW_SHOWNORMAL;
-}
-
 void NativeWidgetWin::OnScreenReaderDetected() {
   screen_reader_active_ = true;
 }
 
-void NativeWidgetWin::SetInitialFocus() {
-  if (!GetWidget()->SetInitialFocus() &&
-      !(GetWindowLong(GWL_EXSTYLE) & WS_EX_TRANSPARENT) &&
-      !(GetWindowLong(GWL_EXSTYLE) & WS_EX_NOACTIVATE)) {
-    // The window does not get keyboard messages unless we focus it.
-    SetFocus(GetNativeView());
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, HWNDMessageHandlerDelegate implementation:
 
 bool NativeWidgetWin::IsWidgetWindow() const {
   // We don't NULL check GetWidget()->non_client_view() here because this
   // function can be called before the widget is fully constructed.
   return has_non_client_view_;
 }
 
 bool NativeWidgetWin::IsUsingCustomFrame() const {
@@ skipping 17 matching lines @@
 }
 
 bool NativeWidgetWin::CanMaximize() const {
   return GetWidget()->widget_delegate()->CanMaximize();
 }
 
 bool NativeWidgetWin::CanActivate() const {
   return delegate_->CanActivate();
 }
 
+bool NativeWidgetWin::CanSaveFocus() const {
+  return GetWidget()->is_top_level();
+}
+
+void NativeWidgetWin::SaveFocusOnDeactivate() {
+  GetWidget()->GetFocusManager()->StoreFocusedView();
+}
+
+void NativeWidgetWin::RestoreFocusOnActivate() {
+  // Mysteriously, this only appears to be needed support restoration of focus
+  // to a child hwnd when restoring its top level window from the minimized
+  // state. If we don't do this, then ::SetFocus() to that child HWND returns
+  // ERROR_INVALID_PARAMETER, despite both HWNDs being of the same thread.
+  // See http://crbug.com/125976
+  {
+    // Since this is a synthetic reset, we don't need to tell anyone about it.
+    AutoNativeNotificationDisabler disabler;
+    GetWidget()->GetFocusManager()->ClearFocus();
+  }
+  RestoreFocusOnEnable();
+}
+
+void NativeWidgetWin::RestoreFocusOnEnable() {
+  GetWidget()->GetFocusManager()->RestoreFocusedView();
+}
+
+bool NativeWidgetWin::IsModal() const {
+  return delegate_->IsModal();
+}
+
+int NativeWidgetWin::GetInitialShowState() const {
+  return SW_SHOWNORMAL;
+}
+
 bool NativeWidgetWin::WillProcessWorkAreaChange() const {
   return GetWidget()->widget_delegate()->WillProcessWorkAreaChange();
 }
 
 int NativeWidgetWin::GetNonClientComponent(const gfx::Point& point) const {
   return delegate_->GetNonClientComponent(point);
 }
 
 void NativeWidgetWin::GetWindowMask(const gfx::Size& size, gfx::Path* path) {
   if (GetWidget()->non_client_view())
@@ skipping 96 matching lines @@
   if (!tooltip_manager_->Init()) {
     // There was a problem creating the TooltipManager. Common error is 127.
     // See 82193 for details.
     LOG_GETLASTERROR(WARNING) << "tooltip creation failed, disabling tooltips";
     tooltip_manager_.reset();
   }
 
   delegate_->OnNativeWidgetCreated();
 }
 
-void NativeWidgetWin::HandleDestroy() {
+void NativeWidgetWin::HandleDestroying() {
   delegate_->OnNativeWidgetDestroying();
   if (drop_target_.get()) {
     RevokeDragDrop(hwnd());
     drop_target_ = NULL;
   }
 }
 
+void NativeWidgetWin::HandleDestroyed() {
+  MessageLoopForUI::current()->RemoveObserver(this);
+  OnFinalMessage(hwnd());
+}
+
+bool NativeWidgetWin::HandleInitialFocus() {
+  return GetWidget()->SetInitialFocus();
+}
+
 void NativeWidgetWin::HandleDisplayChange() {
   GetWidget()->widget_delegate()->OnDisplayChanged();
 }
 
 void NativeWidgetWin::HandleGlassModeChange() {
   // For some reason, we need to hide the window while we're changing the frame
   // type only when we're changing it in response to WM_DWMCOMPOSITIONCHANGED.
   // If we don't, the client area will be filled with black. I'm suspecting
   // something skia-ey.
   // Frame type toggling caused by the user (e.g. switching theme) doesn't seem
@@ skipping 75 matching lines @@
     tooltip_manager_->OnMouse(message, w_param, l_param);
 }
 
 NativeWidgetWin* NativeWidgetWin::AsNativeWidgetWin() {
   return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetWin, private:
 
-// static
-void NativeWidgetWin::PostProcessActivateMessage(NativeWidgetWin* widget,
-                                                 int activation_state) {
-  DCHECK(widget->GetWidget()->is_top_level());
-  FocusManager* focus_manager = widget->GetWidget()->GetFocusManager();
-  if (WA_INACTIVE == activation_state) {
-    // We might get activated/inactivated without being enabled, so we need to
-    // clear restore_focus_when_enabled_.
-    widget->restore_focus_when_enabled_ = false;
-    focus_manager->StoreFocusedView();
-  } else {
-    // We must restore the focus after the message has been DefProc'ed as it
-    // does set the focus to the last focused HWND.
-    // Note that if the window is not enabled, we cannot restore the focus as
-    // calling ::SetFocus on a child of the non-enabled top-window would fail.
-    // This is the case when showing a modal dialog (such as 'open file',
-    // 'print'...) from a different thread.
-    // In that case we delay the focus restoration to when the window is enabled
-    // again.
-    if (!IsWindowEnabled(widget->GetNativeView())) {
-      DCHECK(!widget->restore_focus_when_enabled_);
-      widget->restore_focus_when_enabled_ = true;
-      return;
-    }
-
-    // Mysteriously, this only appears to be needed support restoration of focus
-    // to a child hwnd when restoring its top level window from the minimized
-    // state. If we don't do this, then ::SetFocus() to that child HWND returns
-    // ERROR_INVALID_PARAMETER, despite both HWNDs being of the same thread.
-    // See http://crbug.com/125976
-    {
-      // Since this is a synthetic reset, we don't need to tell anyone about it.
-      AutoNativeNotificationDisabler disabler;
-      focus_manager->ClearFocus();
-    }
-
-    focus_manager->RestoreFocusedView();
-  }
-}
-
 void NativeWidgetWin::SetInitParams(const Widget::InitParams& params) {
   // Set non-style attributes.
   ownership_ = params.ownership;
 
   DWORD style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
   DWORD ex_style = 0;
   DWORD class_style = CS_DBLCLKS;
 
   // Set type-independent style attributes.
   if (params.child)
@@ skipping 74 matching lines @@
 
   has_non_client_view_ = Widget::RequiresNonClientView(params.type);
   message_handler_->set_remove_standard_frame(params.remove_standard_frame);
 }
 
 bool NativeWidgetWin::WidgetSizeIsClientSize() const {
   const Widget* widget = GetWidget()->GetTopLevelWidget();
   return IsZoomed() || (widget && widget->ShouldUseNativeFrame());
 }
 
-void NativeWidgetWin::RestoreEnabledIfNecessary() {
-  if (delegate_->IsModal() && !restored_enabled_) {
-    restored_enabled_ = true;
-    // If we were run modally, we need to undo the disabled-ness we inflicted on
-    // the owner's parent hierarchy.
-    HWND start = ::GetWindow(GetNativeView(), GW_OWNER);
-    while (start) {
-      ::EnableWindow(start, TRUE);
-      start = ::GetParent(start);
-    }
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
 void Widget::NotifyLocaleChanged() {
   NOTIMPLEMENTED();
 }
 
 namespace {
 BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
@@ skipping 150 matching lines @@
 // static
 bool NativeWidgetPrivate::IsTouchDown() {
   // This currently isn't necessary because we're not generating touch events on
   // windows.  When we do, this will need to be updated.
   return false;
 }
 
 }  // namespace internal
 
 }  // namespace views