Move KeyIdentifier->KeyEvent conversion to src/ui/.

ui/base/events/key_identifier_conversion.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 "chrome/browser/extensions/key_identifier_conversion_views.h"
+#include "ui/base/events/key_identifier_conversion.h"
 
 #include <string.h>
-
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
-#include "base/logging.h"
-#include "content/public/browser/browser_thread.h"
 #include "ui/base/events/event.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
-using content::BrowserThread;
-
 namespace {
 
-static const int kNumIdentifierTypes = 3;
+const int kNumIdentifierTypes = 3;
 
 typedef struct KeyIdentifier {
   // In order: key identifier, character and unicode codepoint.  They are
   // searched in that order as well.
   // These are all placed into a single array as they are treated uniformly and
   // we never refer to a specific type of identifier.  This reduces code
   // duplication below.
   const char* identifiers[kNumIdentifierTypes];
   const ui::KeyboardCode key_code;
   const int event_flags;
 } KeyIdentifier;
 
 // Taken from Section 6.3.3 here:
 // http://www.w3.org/TR/DOM-Level-3-Events/#keyset-keyidentifiers
-// TODO(bryeung): keycodes could be wrong: I took the keydown code only
-static const KeyIdentifier kKeyIdentifiers[] = {
+// WARNING: keycodes could be wrong, as they are based soley on keydown
+const KeyIdentifier kKeyIdentifiers[] = {
   { {"Accept", "", ""}, ui::VKEY_ACCEPT, 0 },
   { {"Add", "", ""}, ui::VKEY_ADD, 0 },
   { {"Again", "", ""}, ui::VKEY_UNKNOWN, 0 },
   { {"AllCandidates", "", ""}, ui::VKEY_UNKNOWN, 0 },
   { {"Alphanumeric", "", ""}, ui::VKEY_UNKNOWN, 0 },
   { {"Alt", "", ""}, ui::VKEY_MENU, 0 },
   { {"AltGraph", "", ""}, ui::VKEY_UNKNOWN, 0 },
   { {"Apps", "", ""}, ui::VKEY_APPS, 0 },
   { {"Attn", "", ""}, ui::VKEY_ATTN, 0 },
   { {"BrowserBack", "", ""}, ui::VKEY_BROWSER_BACK, 0 },
@@ skipping 230 matching lines @@
   { {"DeadDoubleacute", "", "U+030B"}, ui::VKEY_UNKNOWN, 0 },
   { {"DeadCaron", "", "U+030C"}, ui::VKEY_UNKNOWN, 0 },
   { {"DeadCedilla", "", "U+0327"}, ui::VKEY_UNKNOWN, 0 },
   { {"DeadOgonek", "", "U+0328"}, ui::VKEY_UNKNOWN, 0 },
   { {"DeadIota", "", "U+0345"}, ui::VKEY_UNKNOWN, 0 },
   { {"Euro", "", "U+20AC"}, ui::VKEY_UNKNOWN, 0 },
   { {"DeadVoicedSound", "", "U+3099"}, ui::VKEY_UNKNOWN, 0 },
   { {"DeadSemivoicedSound", "", "U+309A"}, ui::VKEY_UNKNOWN, 0 }
 };
 
-static const int kNumKeyIdentifiers = arraysize(kKeyIdentifiers);
+const int kNumKeyIdentifiers = arraysize(kKeyIdentifiers);
 
 typedef base::hash_map<std::string, const ui::KeyEvent*> IdentifierMap;
 typedef std::pair<std::string, const ui::KeyEvent*> IdentifierPair;
-static IdentifierMap* identifierMaps[kNumIdentifierTypes] = { NULL };
+IdentifierMap* identifierMaps[kNumIdentifierTypes] = { NULL };
 
-static ui::KeyEvent* kUnknownKeyEvent = NULL;
+ui::KeyEvent* kUnknownKeyEvent = NULL;
 
-static void InitializeMaps() {
+void InitializeMaps() {
   if (identifierMaps[0])
     return;
 
   kUnknownKeyEvent = new ui::KeyEvent(ui::ET_KEY_PRESSED,
                                       ui::VKEY_UNKNOWN,
                                       0,
                                       false);
 
   for (int i = 0; i < kNumIdentifierTypes; ++i)
     identifierMaps[i] = new IdentifierMap;
@@ skipping 11 matching lines @@
             identifierMaps[j]->insert(
                 IdentifierPair(key.identifiers[j], event));
         DCHECK(result.second);
       }
     }
   }
 }
 
 }  // namespace
 
+namespace ui {
 
 const ui::KeyEvent& KeyEventFromKeyIdentifier(
     const std::string& key_identifier) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // This lazily initializes lookup tables for the conversion.  To prevent
+  // races, it should only ever be called from a single thread.
   InitializeMaps();
 
   for (int i = 0; i < kNumIdentifierTypes; ++i) {
     const IdentifierMap& map = *identifierMaps[i];
 
     IdentifierMap::const_iterator iter = map.find(key_identifier);
     if (iter != map.end())
       return *iter->second;
   }
 
   return *kUnknownKeyEvent;
 }
+
+}  // namespace ui