Revert of ozone: xkb: Load keymaps on worker thread & cache them

ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.cc

 // Copyright 2014 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/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
 
 #include <xkbcommon/xkbcommon-names.h>
 
-#include "base/bind.h"
-#include "base/location.h"
 #include "base/logging.h"
-#include "base/single_thread_task_runner.h"
-#include "base/task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/threading/worker_pool.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/dom3/dom_code.h"
 #include "ui/events/keycodes/dom3/dom_key.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
 #include "ui/events/ozone/layout/layout_util.h"
 #include "ui/events/ozone/layout/xkb/xkb_keyboard_code_conversion.h"
 
 namespace ui {
 
 namespace {
 
-typedef base::Callback<void(const std::string&,
-                            scoped_ptr<xkb_keymap, XkbKeymapDeleter> keymap)>
-    LoadKeymapCallback;
-
 DomKey CharacterToDomKey(base::char16 character) {
   switch (character) {
     case 0x08:
       return DomKey::BACKSPACE;
     case 0x09:
       return DomKey::TAB;
     case 0x0A:
     case 0x0D:
       return DomKey::ENTER;
     case 0x1B:
@@ skipping 578 matching lines @@
     {0x0163, VKEY_OEM_7},      // t cedilla
     {0x0165, VKEY_5},          // t caron
     {0x016F, VKEY_OEM_1},      // u ring above
     {0x0171, VKEY_OEM_5},      // u double acute
     {0x01A1, VKEY_OEM_6},      // o horn
     {0x01B0, VKEY_OEM_4},      // u horn
     {0x01B6, VKEY_OEM_6},      // z stroke
     {0x0259, VKEY_OEM_3},      // schwa
 };
 
-void LoadKeymap(const std::string& layout_name,
-                scoped_ptr<xkb_rule_names> names,
-                xkb_context* context,
-                scoped_refptr<base::SingleThreadTaskRunner> reply_runner,
-                const LoadKeymapCallback& reply_callback) {
-  scoped_ptr<xkb_keymap, XkbKeymapDeleter> keymap;
-  keymap.reset(xkb_keymap_new_from_names(context, names.get(),
-                                         XKB_KEYMAP_COMPILE_NO_FLAGS));
-  reply_runner->PostTask(FROM_HERE, base::Bind(reply_callback, layout_name,
-                                               base::Passed(&keymap)));
-}
-
 }  // anonymous namespace
 
 XkbKeyCodeConverter::XkbKeyCodeConverter() {
 }
 
 XkbKeyCodeConverter::~XkbKeyCodeConverter() {
 }
 
 XkbKeyboardLayoutEngine::XkbKeyboardLayoutEngine(
     const XkbKeyCodeConverter& converter)
-    : key_code_converter_(converter), weak_ptr_factory_(this) {
+    : key_code_converter_(converter) {
   // TODO: add XKB_CONTEXT_NO_ENVIRONMENT_NAMES
   xkb_context_.reset(xkb_context_new(XKB_CONTEXT_NO_DEFAULT_INCLUDES));
   xkb_context_include_path_append(xkb_context_.get(),
                                   "/usr/share/X11/xkb");
 }
 
 XkbKeyboardLayoutEngine::~XkbKeyboardLayoutEngine() {
-  for (const auto& entry : xkb_keymaps_) {
-    xkb_keymap_unref(entry.keymap);
-  }
 }
 
 bool XkbKeyboardLayoutEngine::CanSetCurrentLayout() const {
 #if defined(OS_CHROMEOS)
   return true;
 #else
   return false;
 #endif
 }
 
 bool XkbKeyboardLayoutEngine::SetCurrentLayoutByName(
     const std::string& layout_name) {
 #if defined(OS_CHROMEOS)
-  current_layout_name_ = layout_name;
-  for (const auto& entry : xkb_keymaps_) {
-    if (entry.layout_name == layout_name) {
-      SetKeymap(entry.keymap);
-      return true;
-    }
-  }
-  LoadKeymapCallback reply_callback = base::Bind(
-      &XkbKeyboardLayoutEngine::OnKeymapLoaded, weak_ptr_factory_.GetWeakPtr());
-  scoped_ptr<xkb_rule_names> names = GetXkbRuleNames(layout_name);
-  base::WorkerPool::PostTask(
-      FROM_HERE,
-      base::Bind(&LoadKeymap, layout_name, base::Passed(&names),
-                 base::Unretained(xkb_context_.get()),
-                 base::ThreadTaskRunnerHandle::Get(), reply_callback),
-      true);
-  return true;
-#endif  // defined(OS_CHROMEOS)
-  return false;
-}
-
-scoped_ptr<xkb_rule_names> XkbKeyboardLayoutEngine::GetXkbRuleNames(
-    const std::string& layout_name) {
   size_t dash_index = layout_name.find('-');
   size_t parentheses_index = layout_name.find('(');
   std::string layout_id = layout_name;
   std::string layout_variant = "";
   if (parentheses_index != std::string::npos) {
     layout_id = layout_name.substr(0, parentheses_index);
     size_t close_index = layout_name.find(')', parentheses_index);
     if (close_index == std::string::npos)
       close_index = layout_name.size();
     layout_variant = layout_name.substr(parentheses_index + 1,
                                         close_index - parentheses_index - 1);
   } else if (dash_index != std::string::npos) {
     layout_id = layout_name.substr(0, dash_index);
     layout_variant = layout_name.substr(dash_index + 1);
   }
-  return make_scoped_ptr<xkb_rule_names>(
-      new xkb_rule_names{.rules = NULL,
-                         .model = "pc101",
-                         .layout = layout_id.c_str(),
-                         .variant = layout_variant.c_str(),
-                         .options = ""});
-}
-
-void XkbKeyboardLayoutEngine::OnKeymapLoaded(
-    const std::string& layout_name,
-    scoped_ptr<xkb_keymap, XkbKeymapDeleter> keymap) {
+  struct xkb_rule_names names = {
+    .rules = NULL,
+    .model = "pc101",
+    .layout = layout_id.c_str(),
+    .variant = layout_variant.c_str(),
+    .options = ""
+  };
+  xkb_keymap* keymap = xkb_keymap_new_from_names(xkb_context_.get(),
+                                                 &names,
+                                                 XKB_KEYMAP_COMPILE_NO_FLAGS);
   if (keymap) {
-    XkbKeymapEntry entry = {layout_name, xkb_keymap_ref(keymap.get())};
-    xkb_keymaps_.push_back(entry);
-    if (layout_name == current_layout_name_)
-      SetKeymap(keymap.get());
-  } else {
-    LOG(ERROR) << "Keymap file fail to load: " << layout_name;
+    SetKeymap(keymap);
+    return true;
   }
+#endif  // defined(OS_CHROMEOS)
+  return false;
 }
 
 bool XkbKeyboardLayoutEngine::UsesISOLevel5Shift() const {
   // NOTIMPLEMENTED();
   return false;
 }
 
 bool XkbKeyboardLayoutEngine::UsesAltGr() const {
   // NOTIMPLEMENTED();
   return false;
@@ skipping 178 matching lines @@
   if (flags == base_flags)
     return base_character;
   xkb_keysym_t keysym;
   base::char16 character = 0;
   if (!XkbLookup(xkb_keycode, flags, &keysym, &character))
     character = kNone;
   return character;
 }
 
 }  // namespace ui