Fixed a bug with the unit_tests, which caused it to leave hebrew enabled...

chrome/renderer/mock_keyboard_driver_win.cc

 // Copyright (c) 2009 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 "chrome/renderer/mock_keyboard_driver_win.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "chrome/renderer/mock_keyboard.h"
 
 MockKeyboardDriverWin::MockKeyboardDriverWin() {
   // Save the keyboard layout and status of the application.
   // This class changes the keyboard layout and status of this application.
   // This change may break succeeding tests. To prevent this possible break, we
   // should save the layout and status here to restore when this instance is
   // destroyed.
   original_keyboard_layout_ = GetKeyboardLayout(0);
+  active_keyboard_layout_ = original_keyboard_layout_;
   GetKeyboardState(&original_keyboard_states_[0]);
 
-  keyboard_handle_ = NULL;
+  const UINT num_keyboard_layouts = GetKeyboardLayoutList(0, NULL);
+  DCHECK(num_keyboard_layouts > 0);
+
+  orig_keyboard_layouts_list_.resize(num_keyboard_layouts);
+  GetKeyboardLayoutList(num_keyboard_layouts, &orig_keyboard_layouts_list_[0]);
+
   memset(&keyboard_states_[0], 0, sizeof(keyboard_states_));
 }
 
 MockKeyboardDriverWin::~MockKeyboardDriverWin() {
   // Unload the keyboard-layout driver, restore the keyboard state, and reset
   // the keyboard layout for succeeding tests.
-  if (keyboard_handle_)
-    UnloadKeyboardLayout(keyboard_handle_);
+  MaybeUnloadActiveLayout();
   SetKeyboardState(&original_keyboard_states_[0]);
   ActivateKeyboardLayout(original_keyboard_layout_, KLF_RESET);
 }
 
+void MockKeyboardDriverWin::MaybeUnloadActiveLayout() {
+  // Workaround for http://crbug.com/12093
+  // Only unload a keyboard layout if it was loaded by this mock driver.
+  // Contrary to the documentation on MSDN unloading a keyboard layout
+  // previously loaded by the system causes that layout to stop working.
+  // We have confirmation of this behavior on XP & Vista.
+  for (size_t i = 0; i < orig_keyboard_layouts_list_.size(); ++i) {
+    if (orig_keyboard_layouts_list_[i] == active_keyboard_layout_)
+      return;
+  }
+
+  // If we got here, this keyboard layout wasn't loaded by the system so it's
+  // safe to unload it ourselve's.
+  UnloadKeyboardLayout(active_keyboard_layout_);
+  active_keyboard_layout_ = original_keyboard_layout_;
+}
+
 bool MockKeyboardDriverWin::SetLayout(int layout) {
   // Unload the current keyboard-layout driver and load a new keyboard-layout
   // driver for mapping a virtual key-code to a Unicode character.
-  if (keyboard_handle_) {
-    UnloadKeyboardLayout(keyboard_handle_);
-    keyboard_handle_ = NULL;
-  }
+  MaybeUnloadActiveLayout();
 
   // Scan the mapping table and retrieve a Language ID for the input layout.
   // Load the keyboard-layout driver when we find a Language ID.
   // This Language IDs are copied from the registry
   //   "HKLM\SYSTEM\CurrentControlSet\Control\Keyboard layouts".
   // TODO(hbono): Add more keyboard-layout drivers.
   static const struct {
     const wchar_t* language;
     MockKeyboard::Layout keyboard_layout;
   } kLanguageIDs[] = {
@@ skipping 24 matching lines @@
     {L"0000041f", MockKeyboard::LAYOUT_TURKISH_Q},
     {L"0000042a", MockKeyboard::LAYOUT_VIETNAMESE},
     {L"00000439", MockKeyboard::LAYOUT_DEVANAGARI_INSCRIPT},
     {L"00000816", MockKeyboard::LAYOUT_PORTUGUESE},
     {L"00001409", MockKeyboard::LAYOUT_UNITED_STATES_DVORAK},
     {L"00001009", MockKeyboard::LAYOUT_CANADIAN_FRENCH},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kLanguageIDs); ++i) {
     if (layout == kLanguageIDs[i].keyboard_layout) {
-      keyboard_handle_ = LoadKeyboardLayout(kLanguageIDs[i].language,
-                                            KLF_ACTIVATE);
-      if (!keyboard_handle_)
-        return false;
-      return true;
+      HKL new_keyboard_layout = LoadKeyboardLayout(kLanguageIDs[i].language,
+                                                   KLF_ACTIVATE);
+      // loaded_keyboard_layout_ must always have a valid keyboard handle
+      // so we only assign upon success.
+      if (new_keyboard_layout) {
+        active_keyboard_layout_ = new_keyboard_layout;
+        return true;
+      }
+
+      return false;
     }
   }
 
   // Return false if there are not any matching drivers.
   return false;
 }
 
 bool MockKeyboardDriverWin::SetModifiers(int modifiers) {
   // Over-write the keyboard status with our modifier-key status.
   // WebInputEventFactory::keyboardEvent() uses GetKeyState() to retrive
@@ skipping 27 matching lines @@
 
 int MockKeyboardDriverWin::GetCharacters(int key_code,
                                          std::wstring* output) {
   // Retrieve Unicode characters composed from the input key-code and
   // the mofifiers.
   CHECK(output);
   wchar_t code[16];
   int length = ToUnicodeEx(key_code, MapVirtualKey(key_code, 0),
                            &keyboard_states_[0], &code[0],
                            ARRAYSIZE_UNSAFE(code), 0,
-                           keyboard_handle_);
+                           active_keyboard_layout_);
   if (length > 0)
     output->assign(code);
   return length;
 }