Prevent Control+two-finger-scroll from zooming the page.

content/browser/renderer_host/render_widget_host_view_aura_unittest.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_view_aura.h"
 
 #include "base/basictypes.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 130 matching lines @@
   }
 
  private:
   gfx::Size size_;
   base::Callback<void(bool)> callback_;
 };
 
 class FakeRenderWidgetHostViewAura : public RenderWidgetHostViewAura {
  public:
   FakeRenderWidgetHostViewAura(RenderWidgetHost* widget)
-      : RenderWidgetHostViewAura(widget), has_resize_lock_(false) {}
+      : RenderWidgetHostViewAura(widget),
+        has_resize_lock_(false) {}
 
   virtual ~FakeRenderWidgetHostViewAura() {}
 
+  const blink::WebInputEvent* last_input_event() const {
+    return last_input_event_.get();
+  }
+
+  scoped_ptr<cc::CopyOutputRequest> ReleaseLastCopyRequest() {
+    return last_copy_request_.Pass();
+  }
+
+  void RunOnCompositingDidCommit() {
+    OnCompositingDidCommit(window()->GetHost()->compositor());
+  }
+
   virtual bool ShouldCreateResizeLock() OVERRIDE {
     gfx::Size desired_size = window()->bounds().size();
     return desired_size != current_frame_size_in_dip();
   }
 
   virtual scoped_ptr<ResizeLock> CreateResizeLock(bool defer_compositor_lock)
       OVERRIDE {
     gfx::Size desired_size = window()->bounds().size();
     return scoped_ptr<ResizeLock>(
         new FakeResizeLock(desired_size, defer_compositor_lock));
   }
 
   virtual void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request)
       OVERRIDE {
     last_copy_request_ = request.Pass();
     if (last_copy_request_->has_texture_mailbox()) {
       // Give the resulting texture a size.
       GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
       GLuint texture = gl_helper->ConsumeMailboxToTexture(
           last_copy_request_->texture_mailbox().mailbox(),
           last_copy_request_->texture_mailbox().sync_point());
       gl_helper->ResizeTexture(texture, window()->bounds().size());
       gl_helper->DeleteTexture(texture);
     }
   }
 
-  void RunOnCompositingDidCommit() {
-    OnCompositingDidCommit(window()->GetHost()->compositor());
+  virtual InputEventAckState FilterInputEvent(
+      const blink::WebInputEvent& input_event) OVERRIDE {

[Daniel Erat, 2014/04/21 23:26:39]

please let me know if there's a better way to capture the modified events

+    last_input_event_.reset(new blink::WebInputEvent(input_event));
+    return RenderWidgetHostViewAura::FilterInputEvent(input_event);
   }
 
+ private:
   // A lock that doesn't actually do anything to the compositor, and does not
   // time out.
   class FakeResizeLock : public ResizeLock {
    public:
     FakeResizeLock(const gfx::Size new_size, bool defer_compositor_lock)
         : ResizeLock(new_size, defer_compositor_lock) {}
   };
 
   bool has_resize_lock_;
   gfx::Size last_frame_size_;
   scoped_ptr<cc::CopyOutputRequest> last_copy_request_;
+  scoped_ptr<blink::WebInputEvent> last_input_event_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeRenderWidgetHostViewAura);
 };
 
 class RenderWidgetHostViewAuraTest : public testing::Test {
  public:
   RenderWidgetHostViewAuraTest()
       : browser_thread_for_ui_(BrowserThread::UI, &message_loop_) {}
 
   void SetUpEnvironment() {
     ImageTransportFactory::InitializeForUnitTests(
         scoped_ptr<ui::ContextFactory>(new ui::InProcessContextFactory));
@@ skipping 1036 matching lines @@
   // scale on it.
   view_->OnSwapCompositorFrame(
       1, MakeDelegatedFrame(2.f, frame_size, gfx::Rect(frame_size)));
 
   // When we get a new frame with the same frame size in physical pixels, but a
   // different scale, we should generate a new frame provider, as the final
   // result will need to be scaled differently to the screen.
   EXPECT_NE(frame_provider.get(), view_->frame_provider_.get());
 }
 
+TEST_F(RenderWidgetHostViewAuraTest, ClearControlOnScrollEvent) {
+  view_->InitAsChild(NULL);
+  view_->Show();
+  ui::ScrollEvent event(ui::ET_SCROLL,
+                        gfx::Point(30, 30),
+                        ui::EventTimeForNow(),
+                        ui::EF_CONTROL_DOWN,
+                        0, 0, 0, 0,
+                        2 /* finger_count */);
+
+  // The Control modifier should be cleared in the forwarded event.
+  view_->OnScrollEvent(&event);
+  const blink::WebInputEvent* web_event = view_->last_input_event();
+  ASSERT_TRUE(web_event);
+  EXPECT_EQ(blink::WebInputEvent::MouseWheel, web_event->type);
+  EXPECT_EQ(0, web_event->modifiers);
+}
+
+TEST_F(RenderWidgetHostViewAuraTest,
+       PreserveControlOnScrollEventWithOtherModifiers) {
+  view_->InitAsChild(NULL);
+  view_->Show();
+  ui::ScrollEvent event(ui::ET_SCROLL,
+                        gfx::Point(30, 30),
+                        ui::EventTimeForNow(),
+                        ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
+                        0, 0, 0, 0,
+                        2 /* finger_count */);
+
+  // The Control modifier should be preserved since Alt was also down.
+  view_->OnScrollEvent(&event);
+  const blink::WebInputEvent* web_event = view_->last_input_event();
+  ASSERT_TRUE(web_event);
+  EXPECT_EQ(blink::WebInputEvent::MouseWheel, web_event->type);
+  EXPECT_EQ(blink::WebInputEvent::ControlKey | blink::WebInputEvent::AltKey,
+            web_event->modifiers);
+}
+
 class RenderWidgetHostViewAuraCopyRequestTest
     : public RenderWidgetHostViewAuraShutdownTest {
  public:
   RenderWidgetHostViewAuraCopyRequestTest()
       : callback_count_(0), result_(false) {}
 
   void CallbackMethod(const base::Closure& quit_closure, bool result) {
     result_ = result;
     callback_count_++;
     quit_closure.Run();
@@ skipping 20 matching lines @@
   view_->SetSize(view_rect.size());
   view_->WasShown();
 
   scoped_ptr<FakeFrameSubscriber> frame_subscriber(new FakeFrameSubscriber(
       view_rect.size(),
       base::Bind(&RenderWidgetHostViewAuraCopyRequestTest::CallbackMethod,
                  base::Unretained(this),
                  run_loop.QuitClosure())));
 
   EXPECT_EQ(0, callback_count_);
-  EXPECT_FALSE(view_->last_copy_request_);
+  request = view_->ReleaseLastCopyRequest();
+  EXPECT_FALSE(request);
 
   view_->BeginFrameSubscription(
       frame_subscriber.PassAs<RenderWidgetHostViewFrameSubscriber>());
   view_->OnSwapCompositorFrame(
       1, MakeDelegatedFrame(1.f, view_rect.size(), gfx::Rect(view_rect)));
 
   EXPECT_EQ(0, callback_count_);
-  EXPECT_TRUE(view_->last_copy_request_);
-  EXPECT_TRUE(view_->last_copy_request_->has_texture_mailbox());
-  request = view_->last_copy_request_.Pass();
+  request = view_->ReleaseLastCopyRequest();
+  ASSERT_TRUE(request);
+  EXPECT_TRUE(request->has_texture_mailbox());
 
   // There should be one subscriber texture in flight.
   EXPECT_EQ(1u, view_->active_frame_subscriber_textures_.size());
 
   // Send back the mailbox included in the request. There's no release callback
   // since the mailbox came from the RWHVA originally.
   request->SendTextureResult(view_rect.size(),
                              request->texture_mailbox(),
                              scoped_ptr<cc::SingleReleaseCallback>());
 
   // This runs until the callback happens.
   run_loop.Run();
 
   // The callback should succeed.
   EXPECT_EQ(0u, view_->active_frame_subscriber_textures_.size());
   EXPECT_EQ(1, callback_count_);
   EXPECT_TRUE(result_);
 
   view_->OnSwapCompositorFrame(
       1, MakeDelegatedFrame(1.f, view_rect.size(), gfx::Rect(view_rect)));
 
   EXPECT_EQ(1, callback_count_);
-  request = view_->last_copy_request_.Pass();
+  request = view_->ReleaseLastCopyRequest();
 
   // There should be one subscriber texture in flight again.
   EXPECT_EQ(1u, view_->active_frame_subscriber_textures_.size());
 
   // Destroy the RenderWidgetHostViewAura and ImageTransportFactory.
   TearDownEnvironment();
 
   // Send back the mailbox included in the request. There's no release callback
   // since the mailbox came from the RWHVA originally.
   request->SendTextureResult(view_rect.size(),
                              request->texture_mailbox(),
                              scoped_ptr<cc::SingleReleaseCallback>());
 
   // Because the copy request callback may be holding state within it, that
   // state must handle the RWHVA and ImageTransportFactory going away before the
   // callback is called. This test passes if it does not crash as a result of
   // these things being destroyed.
   EXPECT_EQ(2, callback_count_);
   EXPECT_FALSE(result_);
 }
 
 }  // namespace content