BASELINE: Update Chromium to 102.0.5005.177

Change-Id: I0229f2402b8321f58c0092ec81d63372bec7e789
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

5 files changed, 49 insertions, 51 deletions

diff --git a/chromium/ui/events/keycodes/dom/keycode_converter.cc b/chromium/ui/events/keycodes/dom/keycode_converter.cc
index a8a1615e52f..88486fca8ba 100644
--- a/chromium/ui/events/keycodes/dom/keycode_converter.cc
+++ b/chromium/ui/events/keycodes/dom/keycode_converter.cc
@@ -5,6 +5,7 @@
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
 #include "base/logging.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "build/build_config.h"
 #include "ui/events/keycodes/dom/dom_code.h"
@@ -223,7 +224,7 @@ KeyboardCode KeycodeConverter::MapPositionalDomCodeToUSShortcutKey(
 #endif
 
 // static
-DomCode KeycodeConverter::CodeStringToDomCode(const std::string& code) {
+DomCode KeycodeConverter::CodeStringToDomCode(base::StringPiece code) {
   if (code.empty())
     return DomCode::NONE;
   for (auto& mapping : kDomCodeMappings) {
@@ -236,9 +237,29 @@ DomCode KeycodeConverter::CodeStringToDomCode(const std::string& code) {
 }
 
 // static
-const char* KeycodeConverter::DomCodeToCodeString(DomCode dom_code) {
+std::string KeycodeConverter::DomCodeToCodeString(DomCode dom_code) {
+  const auto usb_keycode = static_cast<uint32_t>(dom_code);
+
+  // Generate some continuous runs of codes, rather than looking them up.
+  if (dom_code >= DomCode::US_A && dom_code <= DomCode::US_Z) {
+    const int index = usb_keycode - static_cast<uint32_t>(DomCode::US_A);
+    return base::StringPrintf("Key%c", 'A' + index);
+  } else if (dom_code >= DomCode::DIGIT1 && dom_code <= DomCode::DIGIT0) {
+    const int index = usb_keycode - static_cast<uint32_t>(DomCode::DIGIT1);
+    return base::StringPrintf("Digit%d", (index + 1) % 10);
+  } else if (dom_code >= DomCode::NUMPAD1 && dom_code <= DomCode::NUMPAD0) {
+    const int index = usb_keycode - static_cast<uint32_t>(DomCode::NUMPAD1);
+    return base::StringPrintf("Numpad%d", (index + 1) % 10);
+  } else if (dom_code >= DomCode::F1 && dom_code <= DomCode::F12) {
+    const int index = usb_keycode - static_cast<uint32_t>(DomCode::F1);
+    return base::StringPrintf("F%d", index + 1);
+  } else if (dom_code >= DomCode::F13 && dom_code <= DomCode::F24) {
+    const int index = usb_keycode - static_cast<uint32_t>(DomCode::F13);
+    return base::StringPrintf("F%d", index + 13);
+  }
+
   for (auto& mapping : kDomCodeMappings) {
-    if (mapping.usb_keycode == static_cast<uint32_t>(dom_code)) {
+    if (mapping.usb_keycode == usb_keycode) {
       if (mapping.code)
         return mapping.code;
       break;
@@ -297,7 +318,7 @@ DomKeyLocation KeycodeConverter::DomCodeToLocation(DomCode dom_code) {
 }
 
 // static
-DomKey KeycodeConverter::KeyStringToDomKey(const std::string& key) {
+DomKey KeycodeConverter::KeyStringToDomKey(base::StringPiece key) {
   if (key.empty())
     return DomKey::NONE;
   // Check for standard key names.
@@ -315,12 +336,12 @@ DomKey KeycodeConverter::KeyStringToDomKey(const std::string& key) {
   }
   // Otherwise, if the string contains a single Unicode character,
   // the key value is that character.
+  const auto key_length = static_cast<int32_t>(key.length());
   int32_t char_index = 0;
   uint32_t character;
-  if (base::ReadUnicodeCharacter(key.c_str(),
-                                 static_cast<int32_t>(key.length()),
-                                 &char_index, &character) &&
-      key[++char_index] == 0) {
+  if (base::ReadUnicodeCharacter(key.data(), key_length, &char_index,
+                                 &character) &&
+      ++char_index == key_length) {
     return DomKey::FromCharacter(character);
   }
   return DomKey::NONE;
@@ -439,22 +460,4 @@ uint32_t KeycodeConverter::DomCodeToUsbKeycode(DomCode dom_code) {
   return InvalidUsbKeycode();
 }
 
-// static
-uint32_t KeycodeConverter::CodeStringToUsbKeycode(const std::string& code) {
-  if (code.empty())
-    return InvalidUsbKeycode();
-
-  for (auto& mapping : kDomCodeMappings) {
-    if (mapping.code && code == mapping.code) {
-      return mapping.usb_keycode;
-    }
-  }
-  return InvalidUsbKeycode();
-}
-
-// static
-int KeycodeConverter::CodeStringToNativeKeycode(const std::string& code) {
-  return UsbKeycodeToNativeKeycode(CodeStringToUsbKeycode(code));
-}
-
 }  // namespace ui
diff --git a/chromium/ui/events/keycodes/dom/keycode_converter.h b/chromium/ui/events/keycodes/dom/keycode_converter.h
index d06621cf194..ee5ff4b1e35 100644
--- a/chromium/ui/events/keycodes/dom/keycode_converter.h
+++ b/chromium/ui/events/keycodes/dom/keycode_converter.h
@@ -9,6 +9,7 @@
 #include <stdint.h>
 #include <string>
 
+#include "base/strings/string_piece.h"
 #include "build/build_config.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 
@@ -91,11 +92,11 @@ class KeycodeConverter {
   static KeyboardCode MapPositionalDomCodeToUSShortcutKey(DomCode code);
 #endif
 
-  // Convert a UI Events |code| string value into a DomCode.
-  static DomCode CodeStringToDomCode(const std::string& code);
-
-  // Convert a DomCode into a UI Events |code| string value.
-  static const char* DomCodeToCodeString(DomCode dom_code);
+  // Conversion between DOM Code string and DomCode enum values.
+  // Returns the invalid value if the supplied code is not recognized,
+  // or has no mapping.
+  static DomCode CodeStringToDomCode(base::StringPiece code);
+  static std::string DomCodeToCodeString(DomCode dom_code);
 
   // Return the DomKeyLocation of a DomCode. The DomKeyLocation distinguishes
   // keys with the same meaning, and therefore the same DomKey or non-located
@@ -108,10 +109,10 @@ class KeycodeConverter {
   // - a key name from http://www.w3.org/TR/DOM-Level-3-Events-key/, or
   // - a single Unicode character (represented in UTF-8).
   // Returns DomKey::NONE for other inputs, including |nullptr|.
-  static DomKey KeyStringToDomKey(const std::string& key);
+  static DomKey KeyStringToDomKey(base::StringPiece key);
 
   // Convert a DomKey into a UI Events |key| string value.
-  // For an invalid DomKey, returns an empty string.
+  // Returns an empty string for invalid DomKey values.
   static std::string DomKeyToKeyString(DomKey dom_key);
 
   // Returns true if the DomKey is a modifier.
@@ -128,24 +129,18 @@ class KeycodeConverter {
   // Return the value that identifies an invalid USB keycode.
   static uint32_t InvalidUsbKeycode();
 
-  // Convert a USB keycode into an equivalent platform native keycode.
+  // Conversion between USB keycode and native keycode values.
+  // Returns the invalid value if the supplied code is not recognized,
+  // or has no mapping.
   static int UsbKeycodeToNativeKeycode(uint32_t usb_keycode);
-
-  // Convert a platform native keycode into an equivalent USB keycode.
   static uint32_t NativeKeycodeToUsbKeycode(int native_keycode);
 
-  // Convert a USB keycode into a DomCode.
+  // Conversion between USB keycode and DomCode values.
+  // Returns the "invalid" value if the supplied key code is not
+  // recognized.
   static DomCode UsbKeycodeToDomCode(uint32_t usb_keycode);
-
-  // Convert a DomCode into a USB keycode.
   static uint32_t DomCodeToUsbKeycode(DomCode dom_code);
 
-  // Convert a UI Event |code| string into a USB keycode value.
-  static uint32_t CodeStringToUsbKeycode(const std::string& code);
-
-  // Convert a UI Event |code| string into a native keycode.
-  static int CodeStringToNativeKeycode(const std::string& code);
-
   // Static methods to support testing.
   static size_t NumKeycodeMapEntriesForTest();
   static const KeycodeMapEntry* GetKeycodeMapForTest();
diff --git a/chromium/ui/events/keycodes/dom/keycode_converter_unittest.cc b/chromium/ui/events/keycodes/dom/keycode_converter_unittest.cc
index 3cbe92c0dbd..0d72bd39ad7 100644
--- a/chromium/ui/events/keycodes/dom/keycode_converter_unittest.cc
+++ b/chromium/ui/events/keycodes/dom/keycode_converter_unittest.cc
@@ -169,7 +169,7 @@ TEST(KeycodeConverter, DomCode) {
     if (entry->code) {
       ui::DomCode code = ui::KeycodeConverter::CodeStringToDomCode(entry->code);
       EXPECT_STREQ(entry->code,
-                   ui::KeycodeConverter::DomCodeToCodeString(code));
+                   ui::KeycodeConverter::DomCodeToCodeString(code).c_str());
     }
     ui::DomCode code =
         ui::KeycodeConverter::NativeKeycodeToDomCode(entry->native_keycode);
diff --git a/chromium/ui/events/keycodes/keyboard_code_conversion_unittest.cc b/chromium/ui/events/keycodes/keyboard_code_conversion_unittest.cc
index 90bc05d5539..5fe65a1ebd4 100644
--- a/chromium/ui/events/keycodes/keyboard_code_conversion_unittest.cc
+++ b/chromium/ui/events/keycodes/keyboard_code_conversion_unittest.cc
@@ -36,10 +36,10 @@ void CheckDomCodeToMeaning(const char* label,
   ui::DomKey result_dom_key = ui::DomKey::NONE;
   ui::KeyboardCode result_key_code = ui::VKEY_UNKNOWN;
   bool success = f(dom_code, event_flags, &result_dom_key, &result_key_code);
-  SCOPED_TRACE(
-      base::StringPrintf("%s %s %06X:%04X", label,
-                         ui::KeycodeConverter::DomCodeToCodeString(dom_code),
-                         static_cast<int>(dom_code), event_flags));
+  SCOPED_TRACE(base::StringPrintf(
+      "%s %s %06X:%04X", label,
+      ui::KeycodeConverter::DomCodeToCodeString(dom_code).c_str(),
+      static_cast<int>(dom_code), event_flags));
   EXPECT_EQ(result.defined, success);
   if (success) {
     EXPECT_EQ(result.dom_key, result_dom_key)
diff --git a/chromium/ui/events/ozone/layout/keyboard_layout_engine_unittest.cc b/chromium/ui/events/ozone/layout/keyboard_layout_engine_unittest.cc
index cc0c54f8f25..d52acd96bff 100644
--- a/chromium/ui/events/ozone/layout/keyboard_layout_engine_unittest.cc
+++ b/chromium/ui/events/ozone/layout/keyboard_layout_engine_unittest.cc
@@ -201,7 +201,7 @@ void TestLookup(const char* name, KeyboardLayoutEngine* engine) {
     KeyboardCode keycode;
     SCOPED_TRACE(base::StringPrintf(
         "%s(%s, 0x%X)", name,
-        KeycodeConverter::DomCodeToCodeString(t.input_dom_code),
+        KeycodeConverter::DomCodeToCodeString(t.input_dom_code).c_str(),
         t.input_flags));
     EXPECT_TRUE(
         engine->Lookup(t.input_dom_code, t.input_flags, &dom_key, &keycode));