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/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 {
@@ skipping 591 matching lines @@
     {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
 };
 
 }  // anonymous namespace
 
+XkbKeyboardLayoutEngine::XkbKeymapLoader::XkbKeymapLoader(
+    XkbKeyboardLayoutEngine* layout_engine) : layout_engine_(layout_engine) {
+}
+
+void XkbKeyboardLayoutEngine::XkbKeymapLoader::loadKeymap(
+    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);
+  }
+  names = new xkb_rule_names {
+    .rules = NULL,
+        .model = "pc101",
+        .layout = layout_id.c_str(),
+        .variant = layout_variant.c_str(),
+        .options = ""
+  };
+  base::WorkerPool::PostTask(
+      FROM_HERE,
+      base::Bind(&XkbKeyboardLayoutEngine::XkbKeymapLoader::startLoadKeymap,
+                 base::Unretained(this),

[Shu Chen, 2014/12/23 08:46:49]

base::Owned(this)

[FengYuan, 2014/12/23 15:24:57]

Done.

+                 layout_name,
+                 base::Unretained(names)),
+      true);
+}
+
+void XkbKeyboardLayoutEngine::XkbKeymapLoader::startLoadKeymap(
+    const std::string& layout_name, xkb_rule_names* names) {

[Shu Chen, 2014/12/23 08:46:49]

You need to delete names in this method.

[FengYuan, 2014/12/23 15:24:57]

Done.

+  xkb_keymap* keymap = xkb_keymap_new_from_names(
+      layout_engine_->xkb_context_.get(),
+      names,
+      XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+  if (keymap) {
+    layout_engine_->xkb_keymaps_[layout_name] = keymap;

[Shu Chen, 2014/12/23 08:46:49]

Please make sure these operations are executed in UI thread, otherwise, you need
to make sure it is thread safe, because it is possible for 2 threads to execute
operations on layout_engine_ at the same time.

I think using PostTaskAndReply may be better.

[FengYuan, 2014/12/23 15:24:57]

These operations are in the worker thread, and reply is not necessary.

+    layout_engine_->SetKeymap(keymap);
+  }
+}
+
 XkbKeyCodeConverter::XkbKeyCodeConverter() {
 }
 
 XkbKeyCodeConverter::~XkbKeyCodeConverter() {
 }
 
 XkbKeyboardLayoutEngine::XkbKeyboardLayoutEngine(
     const XkbKeyCodeConverter& converter)
     : 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() {
+  std::map<std::string, xkb_keymap*>::const_iterator it = xkb_keymaps_.begin();
+  for(;it != xkb_keymaps_.end(); ++it) {
+    xkb_keymap_unref(it->second);
+  }
 }
 
 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)
-  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);
-  }
-  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);
+  xkb_keymap* keymap = xkb_keymaps_[layout_name];
   if (keymap) {
     SetKeymap(keymap);
-    return true;
+  } else {
+    XkbKeymapLoader* keymap_loader = new XkbKeymapLoader(this);

[Shu Chen, 2014/12/23 08:46:49]

nowhere to delete keymap_loader? Suggest to make it as a member variable.

[FengYuan, 2014/12/23 15:24:57]

Done.

+    keymap_loader->loadKeymap(layout_name);
   }
+  return true;
 #endif  // defined(OS_CHROMEOS)
   return false;
 }
 
 bool XkbKeyboardLayoutEngine::UsesISOLevel5Shift() const {
   // NOTIMPLEMENTED();
   return false;
 }
 
 bool XkbKeyboardLayoutEngine::UsesAltGr() const {
@@ skipping 180 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