Make limitations for input.ime.sendKeyEvents API.

chrome/browser/ui/input_method/input_method_engine.cc

 // Copyright 2016 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/ui/input_method/input_method_engine.h"
 
+#include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/url_constants.h"
+#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
+#include "content/public/common/url_constants.h"
+#include "extensions/common/constants.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/ime_bridge.h"
 #include "ui/base/ime/ime_input_context_handler_interface.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 
 namespace {
 
 const char kErrorFollowCursorWindowExists[] =
     "A follow cursor IME window exists.";
 const char kErrorNoInputFocus[] =
@@ skipping 160 matching lines @@
   for (auto ime_window : normal_windows_) {
     if (ime_window->GetFrameId() == window_id)
       return ime_window;
   }
   return nullptr;
 }
 
 bool InputMethodEngine::SendKeyEvent(ui::KeyEvent* event,
                                      const std::string& code) {
   DCHECK(event);
+
+  // input.ime.sendKeyEvents API is only allowed to work on text fields.
+  if (current_input_type_ == ui::TEXT_INPUT_TYPE_NONE)
+    return false;
+
   if (event->key_code() == ui::VKEY_UNKNOWN)
     event->set_key_code(ui::DomCodeToUsLayoutKeyboardCode(event->code()));
 
   ui::IMEInputContextHandlerInterface* input_context =
       ui::IMEBridge::Get()->GetInputContextHandler();
   if (!input_context)
     return false;
+
+  Browser* browser = chrome::FindLastActive();
+  DCHECK(browser);
+  content::WebContents* web_contents =
+      browser->tab_strip_model()->GetActiveWebContents();
+  ui::InputMethod* input_method =
+      browser->window()->GetNativeWindow()->GetHost()->GetInputMethod();
+  // If |input_context->GetInputMethod() != input_method|, treats |url| as
+  // special page no mater what it is.
+  if (web_contents &&
+      !IsValidKeyForSpecialPage(web_contents->GetLastCommittedURL(),
+                                input_context->GetInputMethod() == input_method,
+                                event))
+    return false;
+
   input_context->SendKeyEvent(event);
 
   return true;
 }
 
+bool InputMethodEngine::IsValidKeyForSpecialPage(const GURL& url,
+                                                 bool url_trustable,

[Devlin, 2016/06/28 20:56:44]

The more I look at the "url_trustable" bool, the more I think it sounds weird.
:)  Can we pull the whitelisted logic out into SendKeyEvent(), and change this
signature to take bool is_special_page, ui::KeyEvent* ui_event?

[Azure Wei, 2016/06/29 02:53:46]

Do you mean put all the logic of checking the url is special url into
SendKeyEvent(). If so, I think we don't need the |bool is_special_page|
parameter. 

[Devlin, 2016/06/29 16:07:23]

Ah, right, because otherwise we send all key events.

+                                                 ui::KeyEvent* ui_event) {
+  // input.ime.sendKeyEvents API is not allowed to send ENTER et al. keys on
+  // some special pages (like chrome://).
+  std::vector<const char*> whitelist_schemes{url::kFtpScheme, url::kHttpScheme,
+                                             url::kHttpsScheme};
+  std::vector<GURL> whitelist_urls{GURL(url::kAboutBlankURL),
+                                   GURL(chrome::kChromeUINewTabURL)};
+
+  // Checks if the current url is special url.
+  if (url_trustable) {
+    for (auto scheme : whitelist_schemes) {
+      if (url.SchemeIs(scheme))
+        return true;
+    }
+    for (auto whitelist_url : whitelist_urls) {
+      if (url == whitelist_url || url.GetOrigin() == whitelist_url)
+        return true;
+    }
+  }
+
+  std::vector<ui::KeyboardCode> whitelist_keycodes{
+      ui::VKEY_BACK, ui::VKEY_LEFT, ui::VKEY_RIGHT, ui::VKEY_UP, ui::VKEY_DOWN};
+  std::vector<ui::KeyboardCode> invalid_character_keycodes{ui::VKEY_TAB,
+                                                           ui::VKEY_RETURN};
+
+  // Whitelists all character keys.
+  if (ui_event->GetDomKey().IsCharacter() && !ui_event->IsControlDown() &&
+      !ui_event->IsCommandDown()) {
+    for (auto invalid_key : invalid_character_keycodes) {

[Devlin, 2016/06/28 20:56:44]

nit: I find it slightly more readable to make keycodes sets so you can do:
return invalid_character_keycodes.count(ui_event->key_code()) == 0;

[Azure Wei, 2016/06/29 02:53:46]

Done.

+      if (ui_event->key_code() == invalid_key)
+        return false;
+    }
+    return true;
+  }
+
+  // Checks if the key event is white listed key.

[Devlin, 2016/06/28 20:56:44]

and here
return whitelist_keycodes.count(ui_event->key_code()) != 0;

[Azure Wei, 2016/06/29 02:53:46]

Done.

+  for (auto key : whitelist_keycodes) {
+    if (ui_event->key_code() == key)
+      return true;
+  }
+
+  return false;
+}
+
 }  // namespace input_method