Make HWNDMessageHandler build with use_aura==1

ui/views/win/hwnd_message_handler.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/win/hwnd_message_handler.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/bind.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/win/windows_version.h"
 #include "ui/base/event.h"
 #include "ui/base/keycodes/keyboard_code_conversion_win.h"
 #include "ui/base/native_theme/native_theme_win.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/insets.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
-#include "ui/views/accessibility/native_view_accessibility_win.h"
-#include "ui/views/ime/input_method_win.h"
 #include "ui/views/views_delegate.h"
-#include "ui/views/widget/child_window_message_processor.h"
 #include "ui/views/widget/monitor_win.h"
 #include "ui/views/widget/native_widget_win.h"
 #include "ui/views/widget/widget_hwnd_utils.h"
 #include "ui/views/win/fullscreen_handler.h"
 #include "ui/views/win/hwnd_message_handler_delegate.h"
 #include "ui/views/win/scoped_fullscreen_visibility.h"
 
 #if !defined(USE_AURA)
-#include "base/command_line.h"
-#include "ui/base/ui_base_switches.h"
+#include "ui/views/accessibility/native_view_accessibility_win.h"
+#include "ui/views/widget/child_window_message_processor.h"
 #endif
 
 namespace views {
 namespace {
 
 // MoveLoopMouseWatcher is used to determine if the user canceled or completed a
 // move. win32 doesn't appear to offer a way to determine the result of a move,
 // so we install hooks to determine if we got a mouse up and assume the move
 // completed.
 class MoveLoopMouseWatcher {
@@ skipping 132 matching lines @@
   *work_area = monitor_info.rcWork;
   return true;
 }
 
 struct FindOwnedWindowsData {
   HWND window;
   std::vector<Widget*> owned_widgets;
 };
 
 BOOL CALLBACK FindOwnedWindowsCallback(HWND hwnd, LPARAM param) {
+  // TODO(beng): resolve wrt aura.
+#if !defined(USE_AURA)
   FindOwnedWindowsData* data = reinterpret_cast<FindOwnedWindowsData*>(param);
   if (GetWindow(hwnd, GW_OWNER) == data->window) {
     Widget* widget = Widget::GetWidgetForNativeView(hwnd);
     if (widget)
       data->owned_widgets.push_back(widget);
   }
+#endif
   return TRUE;
 }
 
 // Enables or disables the menu item for the specified command and menu.
 void EnableMenuItemByCommand(HMENU menu, UINT command, bool enabled) {
   UINT flags = MF_BYCOMMAND | (enabled ? MF_ENABLED : MF_DISABLED | MF_GRAYED);
   EnableMenuItem(menu, command, flags);
 }
 
 // Callback used to notify child windows that the top level window received a
@@ skipping 24 matching lines @@
     GetWindowRect(window, &bounds);
     ExcludeClipRect(clip_state->dc,
       bounds.left - clip_state->x,
       bounds.top - clip_state->y,
       bounds.right - clip_state->x,
       bounds.bottom - clip_state->y);
   }
   return TRUE;
 }
 
+#if !defined(USE_AURA)
+
 // 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);
@@ skipping 24 matching lines @@
   if (IsWindow(control_hwnd)) {
     ChildWindowMessageProcessor* processor =
         ChildWindowMessageProcessor::Get(control_hwnd);
     if (processor)
       return processor->ProcessMessage(message, w_param, l_param, l_result);
   }
 
   return false;
 }
 
+#endif
+
 // A custom MSAA object id used to determine if a screen reader is actively
 // listening for MSAA events.
 const int kCustomObjectID = 1;
 
 // The thickness of an auto-hide taskbar in pixels.
 const int kAutoHideTaskbarThicknessPx = 2;
 
 }  // namespace
 
 // A scoping class that prevents a window from being able to redraw in response
@@ skipping 204 matching lines @@
   if (show_state) {
     if (wp.showCmd == SW_SHOWMAXIMIZED)
       *show_state = ui::SHOW_STATE_MAXIMIZED;
     else if (wp.showCmd == SW_SHOWMINIMIZED)
       *show_state = ui::SHOW_STATE_MINIMIZED;
     else
       *show_state = ui::SHOW_STATE_NORMAL;
   }
 }
 
-gfx::Rect HWNDMessageHandler::GetWorkAreaBoundsInScreen() const {
-  return gfx::Screen::GetDisplayNearestWindow(hwnd()).work_area();
-}
-
 void HWNDMessageHandler::SetBounds(const gfx::Rect& bounds) {
   LONG style = GetWindowLong(hwnd(), GWL_STYLE);
   if (style & WS_MAXIMIZE)
     SetWindowLong(hwnd(), GWL_STYLE, style & ~WS_MAXIMIZE);
   SetWindowPos(hwnd(), NULL, bounds.x(), bounds.y(), bounds.width(),
                bounds.height(), SWP_NOACTIVATE | SWP_NOZORDER);
 }
 
 void HWNDMessageHandler::SetSize(const gfx::Size& size) {
   SetWindowPos(hwnd(), NULL, 0, 0, size.width(), size.height(),
@@ skipping 203 matching lines @@
 }
 
 void HWNDMessageHandler::SetVisibilityChangedAnimationsEnabled(bool enabled) {
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     int dwm_value = enabled ? FALSE : TRUE;
     DwmSetWindowAttribute(
         hwnd(), DWMWA_TRANSITIONS_FORCEDISABLED, &dwm_value, sizeof(dwm_value));
   }
 }
 
-InputMethod* HWNDMessageHandler::CreateInputMethod() {
-#if !defined(USE_AURA)
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (!command_line->HasSwitch(switches::kEnableViewsTextfield))
-    return NULL;
-#endif
-  return new InputMethodWin(this);
-}
-
 void HWNDMessageHandler::SetTitle(const string16& title) {
   SetWindowText(hwnd(), title.c_str());
   SetAccessibleName(title);
 }
 
 void HWNDMessageHandler::SetAccessibleName(const string16& name) {
+  // TODO(beng): figure out vis-a-vis aura.
+#if !defined(USE_AURA)
   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(hwnd(), OBJID_CLIENT, CHILDID_SELF,
                                           PROPID_ACC_NAME, name.c_str());
+#endif
 }
 
 void HWNDMessageHandler::SetAccessibleRole(ui::AccessibilityTypes::Role role) {
+  // TODO(beng): figure out vis-a-vis aura.
+#if !defined(USE_AURA)
   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(hwnd(), OBJID_CLIENT, CHILDID_SELF,
                                          PROPID_ACC_ROLE, var);
     }
   }
+#endif
 }
 
 void HWNDMessageHandler::SetAccessibleState(
     ui::AccessibilityTypes::State state) {
+  // TODO(beng): figure out vis-a-vis aura.
+#if !defined(USE_AURA)
   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(hwnd(), OBJID_CLIENT, CHILDID_SELF,
                                          PROPID_ACC_STATE, var);
     }
   }
+#endif
 }
 
 void HWNDMessageHandler::SendNativeAccessibilityEvent(
     int id,
     ui::AccessibilityTypes::Event event_type) {
+  // TODO(beng): figure out vis-a-vis aura.
+#if !defined(USE_AURA)
   // 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.
   ::NotifyWinEvent(NativeViewAccessibilityWin::MSAAEvent(event_type), hwnd(),
                    OBJID_CLIENT, id);
+#endif
 }
 
 void HWNDMessageHandler::SetCursor(HCURSOR cursor) {
   if (cursor) {
     previous_cursor_ = ::SetCursor(cursor);
   } else if (previous_cursor_) {
     ::SetCursor(previous_cursor_);
     previous_cursor_ = NULL;
   }
 }
@@ skipping 91 matching lines @@
 
 LRESULT HWNDMessageHandler::OnWndProc(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) {
   HWND window = hwnd();
   LRESULT result = 0;
 
   if (delegate_->PreHandleMSG(message, w_param, l_param, &result))
     return result;
 
+#if !defined(USE_AURA)
   // 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;
+#endif
 
   // Otherwise we handle everything else.
   if (!ProcessWindowMessage(window, message, w_param, l_param, result))
     result = DefWindowProc(window, message, w_param, l_param);
   delegate_->PostHandleMSG(message, w_param, l_param);
   if (message == WM_NCDESTROY) {
     MessageLoopForUI::current()->RemoveObserver(this);
     delegate_->HandleDestroyed();
   }
 
@@ skipping 180 matching lines @@
     MONITORINFO mi;
     mi.cbSize = sizeof mi;
     GetMonitorInfo(monitor, &mi);
     CRect work_rect = mi.rcWork;
     work_rect.OffsetRect(-window_rect.left, -window_rect.top);
     new_region = CreateRectRgnIndirect(&work_rect);
   } else {
     gfx::Path window_mask;
     delegate_->GetWindowMask(
       gfx::Size(window_rect.Width(), window_rect.Height()), &window_mask);
+    // TODO(beng): resolve wrt aura.
+#if !defined(USE_AURA)
     new_region = window_mask.CreateNativeRegion();
+#endif
   }
 
   if (current_rgn_result == ERROR || !EqualRgn(current_rgn, new_region)) {
     // SetWindowRgn takes ownership of the HRGN created by CreateNativeRegion.
     SetWindowRgn(hwnd(), new_region, TRUE);
   } else {
     DeleteObject(new_region);
   }
 
   DeleteObject(current_rgn);
@@ skipping 261 matching lines @@
     // Return with failure.
     return static_cast<LRESULT>(0L);
   }
 
   return reference_result;
 }
 
 LRESULT HWNDMessageHandler::OnImeMessages(UINT message,
                                           WPARAM w_param,
                                           LPARAM l_param) {
-  InputMethod* input_method = delegate_->GetInputMethod();
-  if (!input_method || input_method->IsMock()) {
-    SetMsgHandled(FALSE);
-    return 0;
-  }
-
-  InputMethodWin* ime_win = static_cast<InputMethodWin*>(input_method);
-  BOOL handled = FALSE;
-  LRESULT result = ime_win->OnImeMessages(message, w_param, l_param, &handled);
-  SetMsgHandled(handled);
+  LRESULT result = 0;
+  SetMsgHandled(delegate_->HandleIMEMessage(
+      message, w_param, l_param, &result));
   return result;
 }
 
 void HWNDMessageHandler::OnInitMenu(HMENU menu) {
   bool is_fullscreen = fullscreen_handler_->fullscreen();
   bool is_minimized = IsMinimized();
   bool is_maximized = IsMaximized();
   bool is_restored = !is_fullscreen && !is_minimized && !is_maximized;
 
   ScopedRedrawLock lock(this);
   EnableMenuItemByCommand(menu, SC_RESTORE, is_minimized || is_maximized);
   EnableMenuItemByCommand(menu, SC_MOVE, is_restored);
   EnableMenuItemByCommand(menu, SC_SIZE, delegate_->CanResize() && is_restored);
   EnableMenuItemByCommand(menu, SC_MAXIMIZE, delegate_->CanMaximize() &&
                           !is_fullscreen && !is_maximized);
   EnableMenuItemByCommand(menu, SC_MINIMIZE, delegate_->CanMaximize() &&
                           !is_minimized);
 }
 
 void HWNDMessageHandler::OnInputLangChange(DWORD character_set,
                                            HKL input_language_id) {
-  InputMethod* input_method = delegate_->GetInputMethod();
-  if (input_method && !input_method->IsMock()) {
-    static_cast<InputMethodWin*>(input_method)->OnInputLangChange(
-        character_set, input_language_id);
-  }
+  delegate_->HandleInputLanguageChange(character_set, input_language_id);
 }
 
 LRESULT HWNDMessageHandler::OnKeyEvent(UINT message,
                                        WPARAM w_param,
                                        LPARAM l_param) {
+
   MSG msg = { hwnd(), message, w_param, l_param };
   ui::KeyEvent key(msg, message == WM_CHAR);
-  InputMethod* input_method = delegate_->GetInputMethod();
-  if (input_method)
-    input_method->DispatchKeyEvent(key);
-  else
+  if (!delegate_->HandleUntranslatedKeyEvent(key))
     DispatchKeyEventPostIME(key);
   return 0;
 }
 
 void HWNDMessageHandler::OnKillFocus(HWND focused_window) {
   delegate_->HandleNativeBlur(focused_window);
-
-  InputMethod* input_method = delegate_->GetInputMethod();
-  if (input_method)
-    input_method->OnBlur();
   SetMsgHandled(FALSE);
 }
 
 LRESULT HWNDMessageHandler::OnMouseActivate(UINT message,
                                             WPARAM w_param,
                                             LPARAM l_param) {
   // TODO(beng): resolve this with the GetWindowLong() check on the subsequent
   //             line.
   if (delegate_->IsWidgetWindow())
     return delegate_->CanActivate() ? MA_ACTIVATE : MA_NOACTIVATEANDEAT;
@@ skipping 366 matching lines @@
 }
 
 void HWNDMessageHandler::OnPaint(HDC dc) {
   RECT dirty_rect;
   // Try to paint accelerated first.
   if (GetUpdateRect(hwnd(), &dirty_rect, FALSE) &&
       !IsRectEmpty(&dirty_rect)) {
     if (delegate_->HandlePaintAccelerated(gfx::Rect(dirty_rect))) {
       ValidateRect(hwnd(), NULL);
     } else {
+      // TODO(beng): resolve vis-a-vis aura
+#if !defined(USE_AURA)
       scoped_ptr<gfx::CanvasPaint> canvas(
           gfx::CanvasPaint::CreateCanvasPaint(hwnd()));
       delegate_->HandlePaint(canvas->AsCanvas());
+#endif
     }
   } else {
     // TODO(msw): Find a better solution for this crbug.com/93530 workaround.
     // Some scenarios otherwise fail to validate minimized app/popup windows.
     ValidateRect(hwnd(), NULL);
   }
 }
 
 LRESULT HWNDMessageHandler::OnPowerBroadcast(DWORD power_event, DWORD data) {
   base::SystemMonitor* monitor = base::SystemMonitor::Get();
@@ skipping 16 matching lines @@
   // Using ScopedRedrawLock here frequently allows content behind this window to
   // paint in front of this window, causing glaring rendering artifacts.
   // If omitting ScopedRedrawLock here triggers caption rendering artifacts via
   // DefWindowProc message handling, we'll need to find a better solution.
   SetMsgHandled(FALSE);
   return 0;
 }
 
 void HWNDMessageHandler::OnSetFocus(HWND last_focused_window) {
   delegate_->HandleNativeFocus(last_focused_window);
-  InputMethod* input_method = delegate_->GetInputMethod();
-  if (input_method)
-    input_method->OnFocus();
   SetMsgHandled(FALSE);
 }
 
 LRESULT HWNDMessageHandler::OnSetIcon(UINT size_type, HICON new_icon) {
   // Use a ScopedRedrawLock to avoid weird non-client painting.
   return DefWindowProcWithRedrawLock(WM_SETICON, size_type,
                                      reinterpret_cast<LPARAM>(new_icon));
 }
 
 LRESULT HWNDMessageHandler::OnSetText(const wchar_t* text) {
@@ skipping 71 matching lines @@
   }
 
   // If the delegate can't handle it, the system implementation will be called.
   if (!delegate_->HandleCommand(notification_code)) {
     DefWindowProc(hwnd(), WM_SYSCOMMAND, notification_code,
                   MAKELPARAM(point.x, point.y));
   }
 }
 
 void HWNDMessageHandler::OnThemeChanged() {
+  // TODO(beng): resolve vis-a-vis aura.
+#if !defined(USE_AURA)
   ui::NativeThemeWin::instance()->CloseHandles();
+#endif
 }
 
 LRESULT HWNDMessageHandler::OnTouchEvent(UINT message,
                                          WPARAM w_param,
                                          LPARAM l_param) {
   int num_points = LOWORD(w_param);
   scoped_array<TOUCHINPUT> input(new TOUCHINPUT[num_points]);
   if (GetTouchInputInfo(reinterpret_cast<HTOUCHINPUT>(l_param),
                         num_points, input.get(), sizeof(TOUCHINPUT))) {
     for (int i = 0; i < num_points; ++i) {
@@ skipping 105 matching lines @@
     DwmExtendFrameIntoClientArea(hwnd(), &m);
   }
   if (window_pos->flags & SWP_SHOWWINDOW)
     delegate_->HandleVisibilityChanged(true);
   else if (window_pos->flags & SWP_HIDEWINDOW)
     delegate_->HandleVisibilityChanged(false);
   SetMsgHandled(FALSE);
 }
 
 }  // namespace views