Fix is_browser_shortcut; add a test.

content/browser/renderer_host/render_widget_host_impl.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 "content/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 69 matching lines @@
 #include "gpu/ipc/common/gpu_messages.h"
 #include "net/base/filename_util.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/display/display_switches.h"
 #include "ui/events/blink/web_input_event_traits.h"
 #include "ui/events/event.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/snapshot/snapshot.h"
 
@@ skipping 1112 matching lines @@
     const NativeWebKeyboardEvent& key_event,
     const ui::LatencyInfo& latency) {
   ForwardKeyboardEventWithCommands(key_event, latency, nullptr, nullptr);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEventWithCommands(
     const NativeWebKeyboardEvent& key_event,
     const ui::LatencyInfo& latency,
     const std::vector<EditCommand>* commands,
     bool* update_event) {
+  LOG(ERROR) << "RenderWidgetHostImpl::ForwardKeyboardEventWithCommands";
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (owner_delegate_ &&
       !owner_delegate_->MayRenderWidgetForwardKeyboardEvent(key_event)) {
     return;
   }
 
   if (ShouldDropInputEvents())
     return;
 
   if (!process_->HasConnection())
@@ skipping 22 matching lines @@
         key_event.GetType() == WebKeyboardEvent::kChar)
       return;
     DCHECK(key_event.GetType() == WebKeyboardEvent::kRawKeyDown ||
            key_event.GetType() == WebKeyboardEvent::kKeyDown);
     suppress_events_until_keydown_ = false;
   }
 
   bool is_shortcut = false;
 
   // Only pre-handle the key event if it's not handled by the input method.
-  if (delegate_ && !key_event.skip_in_browser) {
+  LOG(ERROR) << " > delegate_ = " << delegate_;
+  LOG(ERROR) << " > key_event.skip_in_browser = " << key_event.skip_in_browser;
+  if (delegate_){// && !key_event.skip_in_browser) {
     // We need to set |suppress_events_until_keydown_| to true if
     // PreHandleKeyboardEvent() handles the event, but |this| may already be
     // destroyed at that time. So set |suppress_events_until_keydown_| true
     // here, then revert it afterwards when necessary.
     if (key_event.GetType() == WebKeyboardEvent::kRawKeyDown)
       suppress_events_until_keydown_ = true;
 
     // Tab switching/closing accelerators aren't sent to the renderer to avoid
     // a hung/malicious renderer from interfering.
     switch (delegate_->PreHandleKeyboardEvent(key_event)) {
@@ skipping 14 matching lines @@
 
     if (key_event.GetType() == WebKeyboardEvent::kRawKeyDown)
       suppress_events_until_keydown_ = false;
   }
 
   if (touch_emulator_ && touch_emulator_->HandleKeyboardEvent(key_event))
     return;
   NativeWebKeyboardEventWithLatencyInfo key_event_with_latency(key_event,
                                                                latency);
   key_event_with_latency.event.is_browser_shortcut = is_shortcut;
-  DispatchInputEventWithLatencyInfo(key_event, &key_event_with_latency.latency);
+  LOG(ERROR) << " > key_event_with_latency.event.GetType() "
+             << key_event_with_latency.event.GetType();
+  LOG(ERROR) << " > key_event_with_latency.event.is_browser_shortcut "
+             << key_event_with_latency.event.is_browser_shortcut;
+  LOG(ERROR) << " > key_event_with_latency.event.windows_key_code "
+             << key_event_with_latency.event.windows_key_code;
+  LOG(ERROR) << " > key_event_with_latency.event.dom_code "
+             << key_event_with_latency.event.dom_code;
+  LOG(ERROR) << " > key_event_with_latency.event.dom_key "
+             << key_event_with_latency.event.dom_key;
+  LOG(ERROR) << " > key_event_with_latency.event.text[0] "
+             << key_event_with_latency.event.text[0] << " "
+             << (key_event.text[0] ? ((char)key_event.text[0]) : ' ');
+  LOG(ERROR) << " > is_modifier "
+             << ui::KeycodeConverter::IsDomKeyForModifier(key_event.dom_key);
+  DispatchInputEventWithLatencyInfo(key_event_with_latency.event,
+                                    &key_event_with_latency.latency);
   // TODO(foolip): |InputRouter::SendKeyboardEvent()| may filter events, in
   // which the commands will be treated as belonging to the next key event.
   // InputMsg_SetEditCommandsForNextKeyEvent should only be sent if
   // InputMsg_HandleInputEvent is, but has to be sent first.
   // https://crbug.com/684298
   if (commands && !commands->empty()) {
     Send(
         new InputMsg_SetEditCommandsForNextKeyEvent(GetRoutingID(), *commands));
   }
   input_router_->SendKeyboardEvent(key_event_with_latency);
@@ skipping 1386 matching lines @@
           device::mojom::WakeLockType::PreventDisplaySleep,
           device::mojom::WakeLockReason::ReasonOther, "GetSnapshot",
           std::move(request));
     }
   }
   return wake_lock_.get();
 }
 #endif
 
 }  // namespace content