Adds the ability for WebContentsDelegate to decide if event should be updated

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 46 matching lines @@
 #include "content/common/content_switches_internal.h"
 #include "content/common/cursors/webcursor.h"
 #include "content/common/drag_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/common/input_messages.h"
 #include "content/common/resize_params.h"
 #include "content/common/text_input_state.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/keyboard_event_processing_result.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/web_preferences.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 1082 matching lines @@
     }
     return;
   }
 
   DispatchInputEventWithLatencyInfo(touch_event, &touch_with_latency.latency);
   input_router_->SendTouchEvent(touch_with_latency);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
-  ForwardKeyboardEventWithCommands(key_event, nullptr);
+  ForwardKeyboardEventWithCommands(key_event, nullptr, nullptr);
 }
 
 void RenderWidgetHostImpl::ForwardKeyboardEventWithCommands(
     const NativeWebKeyboardEvent& key_event,
-    const std::vector<EditCommand>* commands) {
+    const std::vector<EditCommand>* commands,
+    bool* update_event) {
   TRACE_EVENT0("input", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (owner_delegate_ &&
       !owner_delegate_->MayRenderWidgetForwardKeyboardEvent(key_event)) {
     return;
   }
 
   if (ShouldDropInputEvents())
     return;
 
   if (!process_->HasConnection())
@@ skipping 24 matching lines @@
     DCHECK(key_event.type() == WebKeyboardEvent::RawKeyDown ||
            key_event.type() == WebKeyboardEvent::KeyDown);
     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) {
     // We need to set |suppress_events_until_keydown_| to true if
-    // PreHandleKeyboardEvent() returns true, but |this| may already be
+    // 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.type() == WebKeyboardEvent::RawKeyDown)
       suppress_events_until_keydown_ = true;
 
     // Tab switching/closing accelerators aren't sent to the renderer to avoid
     // a hung/malicious renderer from interfering.
-    if (delegate_->PreHandleKeyboardEvent(key_event, &is_shortcut))
-      return;
+    switch (delegate_->PreHandleKeyboardEvent(key_event)) {
+      case KeyboardEventProcessingResult::HANDLED:
+        return;
+#if defined(USE_AURA)
+      case KeyboardEventProcessingResult::HANDLED_DONT_UPDATE_EVENT:
+        if (update_event)
+          *update_event = false;
+        return;
+#endif
+      case KeyboardEventProcessingResult::NOT_HANDLED:
+        break;
+      case KeyboardEventProcessingResult::NOT_HANDLED_IS_SHORTCUT:
+        is_shortcut = true;
+        break;
+    }
 
     if (key_event.type() == WebKeyboardEvent::RawKeyDown)
       suppress_events_until_keydown_ = false;
   }
 
   if (touch_emulator_ && touch_emulator_->HandleKeyboardEvent(key_event))
     return;
   ui::LatencyInfo latency_info(ui::SourceEventType::OTHER);
   NativeWebKeyboardEventWithLatencyInfo key_event_with_latency(key_event,
                                                                latency_info);
@@ skipping 1376 matching lines @@
     // different from the receiver's.
     file_system_file.url =
         GURL(storage::GetIsolatedFileSystemRootURIString(
                  file_system_url.origin(), filesystem_id, std::string())
                  .append(register_name));
     file_system_file.filesystem_id = filesystem_id;
   }
 }
 
 }  // namespace content