Makes sure the keyboard typing isn't blocked when InputMethod::OnFocus() is not correctly called.

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 <oleacc.h>
 #include <shellapi.h>
 #include <tchar.h>
@@ skipping 910 matching lines @@
     if (!ref || !::IsWindow(window))
       return result;
   }
 
   if (delegate_) {
     delegate_->PostHandleMSG(message, w_param, l_param);
     if (message == WM_NCDESTROY)
       delegate_->HandleDestroyed();
   }
 
-  if (message == WM_ACTIVATE && IsTopLevelWindow(window))
-    PostProcessActivateMessage(LOWORD(w_param), !!HIWORD(w_param));
+  if (message == WM_ACTIVATE) {
+    if (IsTopLevelWindow(window))
+      PostProcessActivateMessage(LOWORD(w_param), !!HIWORD(w_param));
+    else
+      delegate_->AddStringLog("WM_ACTIVATE on non-top-level window.");
+  }
   return result;
 }
 
 LRESULT HWNDMessageHandler::HandleMouseMessage(unsigned int message,
                                                WPARAM w_param,
                                                LPARAM l_param,
                                                bool* handled) {
   // Don't track forwarded mouse messages. We expect the caller to track the
   // mouse.
   base::WeakPtr<HWNDMessageHandler> ref(weak_factory_.GetWeakPtr());
@@ skipping 83 matching lines @@
     SetFocus(hwnd());
   }
 }
 
 void HWNDMessageHandler::PostProcessActivateMessage(int activation_state,
                                                     bool minimized) {
   DCHECK(IsTopLevelWindow(hwnd()));
   const bool active = activation_state != WA_INACTIVE && !minimized;
   if (delegate_->CanActivate())
     delegate_->HandleActivationChanged(active);
+  else
+    delegate_->AddStringLog("Missing call to HandleActivationChanged.");
 }
 
 void HWNDMessageHandler::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(hwnd(), GW_OWNER);
     while (start) {
       ::EnableWindow(start, TRUE);
@@ skipping 178 matching lines @@
                    attempts),
         base::TimeDelta::FromMilliseconds(500));
     return;
   }
   InvalidateRect(hwnd(), NULL, FALSE);
 }
 
 // Message handlers ------------------------------------------------------------
 
 void HWNDMessageHandler::OnActivateApp(BOOL active, DWORD thread_id) {
+  delegate_->AddStringLog("WM_ACTIVATEAPP: ");
+  delegate_->AddBooleanLog(active ? true : false);
   if (delegate_->IsWidgetWindow() && !active &&
       thread_id != GetCurrentThreadId()) {
     delegate_->HandleAppDeactivated();
     // Also update the native frame if it is rendering the non-client area.
     if (!remove_standard_frame_ && !delegate_->IsUsingCustomFrame())
       DefWindowProcWithRedrawLock(WM_NCACTIVATE, FALSE, 0);
   }
 }
 
 BOOL HWNDMessageHandler::OnAppCommand(HWND window,
@@ skipping 235 matching lines @@
 }
 
 void HWNDMessageHandler::OnInputLangChange(DWORD character_set,
                                            HKL input_language_id) {
   delegate_->HandleInputLanguageChange(character_set, input_language_id);
 }
 
 LRESULT HWNDMessageHandler::OnKeyEvent(UINT message,
                                        WPARAM w_param,
                                        LPARAM l_param) {
+  if (message == WM_KEYDOWN || message == WM_SYSKEYDOWN)
+    delegate_->AddStringLog("WM_KEYDOWN || WM_SYSKEYDOWN");
   MSG msg = {
       hwnd(), message, w_param, l_param, static_cast<DWORD>(GetMessageTime())};
   ui::KeyEvent key(msg);
   delegate_->HandleKeyEvent(&key);
   if (!key.handled())
     SetMsgHandled(FALSE);
   return 0;
 }
 
 void HWNDMessageHandler::OnKillFocus(HWND focused_window) {
   delegate_->HandleNativeBlur(focused_window);
   SetMsgHandled(FALSE);
 }
 
 LRESULT HWNDMessageHandler::OnMouseActivate(UINT message,
                                             WPARAM w_param,
                                             LPARAM l_param) {
+  delegate_->AddStringLog("WM_MOUSEACTIVATE");
   // Please refer to the comments in the header for the touch_down_contexts_
   // member for the if statement below.
   if (touch_down_contexts_)
     return MA_NOACTIVATE;
 
   // On Windows, if we select the menu item by touch and if the window at the
   // location is another window on the same thread, that window gets a
   // WM_MOUSEACTIVATE message and ends up activating itself, which is not
   // correct. We workaround this by setting a property on the window at the
   // current cursor location. We check for this property in our
@@ skipping 44 matching lines @@
   SetMsgHandled(FALSE);
 }
 
 void HWNDMessageHandler::OnMoving(UINT param, const RECT* new_bounds) {
   delegate_->HandleMove();
 }
 
 LRESULT HWNDMessageHandler::OnNCActivate(UINT message,
                                          WPARAM w_param,
                                          LPARAM l_param) {
+  delegate_->AddStringLog("WM_NCACTIVATE: ");
+  delegate_->AddBooleanLog(w_param ? true : false);
   // Per MSDN, w_param is either TRUE or FALSE. However, MSDN also hints that:
   // "If the window is minimized when this message is received, the application
   // should pass the message to the DefWindowProc function."
   // It is found out that the high word of w_param might be set when the window
   // is minimized or restored. To handle this, w_param's high word should be
   // cleared before it is converted to BOOL.
   BOOL active = static_cast<BOOL>(LOWORD(w_param));
 
   bool inactive_rendering_disabled = delegate_->IsInactiveRenderingDisabled();
 
@@ skipping 992 matching lines @@
 
     default:
       left_button_down_on_caption_ = false;
       break;
   }
   return handled;
 }
 
 
 }  // namespace views