Improve scroll performance on Windows 10 with high precision touchpads.

content/browser/renderer_host/legacy_render_widget_host_win.cc

 // Copyright (c) 2014 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/legacy_render_widget_host_win.h"
 
+#include <directmanipulation.h>
+
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/common/content_switches.h"
 #include "ui/base/touch/touch_enabled.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/win/internal_constants.h"
 #include "ui/base/win/window_event_target.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/win/dpi.h"
 
 namespace content {
 
+// Windows 10 provides a new API called Direct Manipulation which generates
+// smooth scroll events via WM_MOUSEWHEEL messages with predictable deltas
+// on high precision touch pads. This basically requires the application window
+// to register as a Direct Manipulation consumer. The way mouse wheel messages
+// are dispatched is
+// 1. The foreground window is checked to see if it is a Direct Manipulation
+//    consumer.
+// 2. If it is then Direct Manipulation takes over and sends the following
+//    messages. WM_POINTERACTIVATE, WM_POINTERDOWN and DM_POINTERHITTEST.
+// 3. It then posts WM_MOUSEWHEEL messages with precision deltas which vary
+//    based on the amount of the scroll.
+// 4. If the foreground window is not a Direct Manipulation consumer, it
+//    then takes a fallback route where it posts WM_MOUSEWHEEL messages
+//    with precision but varying deltas to the window. There is a also
+//    a slight delay in receiving the first set of mouse wheel messages.
+//    This causes scrolling in Chrome to appear janky and jumpy.
+// Our approach for addressing this is to do the absolute minimum to
+// register our window as a Direct Manipulation consumer. This class
+// provides the necessary functionality to register the legacy HWND as a
+// Direct Manipulation consumer. We don't rely on Direct manipulation
+// to do the smooth scrolling in the background thread as documented on
+// msdn.
+class DirectManipulationHelper {

[sky, 2015/08/11 15:43:12]

Would it make more sense to do this in views so that views also gets this logic
too?

[ananta, 2015/08/11 20:52:08]

I guess so. I moved the DirectManipulationHelper class to ui\gfx\win. The class
is used from views and from the LegacyRenderWidgetHostHWND class. Reason for the
latter is to continue supporting drivers which assume the existence of the
window class and send messages to it.

+ public:
+  DirectManipulationHelper() {}
+
+  // This function instantiates Direct Manipulation and creates a viewport for
+  // the passed in |window|.
+  // consumer. Most of the code is boiler plate and is based on the sample.
+  bool Initialize(HWND window) {
+    DCHECK(::IsWindow(window));
+
+    HRESULT hr = manager_.CreateInstance(CLSID_DirectManipulationManager,
+      nullptr, CLSCTX_INPROC_SERVER);
+    CHECK(SUCCEEDED(hr));

[sky, 2015/08/11 15:43:12]

Do these all need to be CHECKs, if any of these fail won't it all continue to
work?

[ananta, 2015/08/11 20:52:08]

Added a TODO to remove the CHECKs once this stablizes.

+
+    hr = compositor_.CreateInstance(CLSID_DCompManipulationCompositor,
+        nullptr, CLSCTX_INPROC_SERVER);
+    CHECK(SUCCEEDED(hr));
+
+    hr = manager_->GetUpdateManager(IID_PPV_ARGS(update_manager_.Receive()));
+    CHECK(SUCCEEDED(hr));
+
+    hr = compositor_->SetUpdateManager(update_manager_.get());
+    CHECK(SUCCEEDED(hr));
+
+    hr = frame_info_.QueryFrom(compositor_.get());
+    CHECK(SUCCEEDED(hr));
+
+    hr = manager_->CreateViewport(frame_info_.get(), window,
+        IID_PPV_ARGS(view_port_outer_.Receive()));
+    CHECK(SUCCEEDED(hr));
+
+    //
+    // Enable the desired configuration for each viewport.
+    //
+    DIRECTMANIPULATION_CONFIGURATION configuration =
+        DIRECTMANIPULATION_CONFIGURATION_INTERACTION
+        | DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_X
+        | DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_Y
+        | DIRECTMANIPULATION_CONFIGURATION_TRANSLATION_INERTIA
+        | DIRECTMANIPULATION_CONFIGURATION_RAILS_X
+        | DIRECTMANIPULATION_CONFIGURATION_RAILS_Y
+        | DIRECTMANIPULATION_CONFIGURATION_SCALING
+        | DIRECTMANIPULATION_CONFIGURATION_SCALING_INERTIA;
+
+    hr = view_port_outer_->ActivateConfiguration(configuration);
+    CHECK(SUCCEEDED(hr));
+    return true;

[sky, 2015/08/11 15:43:12]

Seems like you always return true.

[ananta, 2015/08/11 20:52:08]

Changed the type to void

+  }
+
+  // Sets the bounds of the fake Direct manipulation viewport to match those
+  // of the legacy window.
+  void SetBounds(const gfx::Rect& bounds) {
+    base::win::ScopedComPtr<IDirectManipulationPrimaryContent>
+        primary_content_outer;
+    HRESULT hr = view_port_outer_->GetPrimaryContent(
+        IID_PPV_ARGS(primary_content_outer.Receive()));
+    CHECK(SUCCEEDED(hr));
+
+    base::win::ScopedComPtr<IDirectManipulationContent> content_outer;
+    hr = content_outer.QueryFrom(primary_content_outer.get());
+    CHECK(SUCCEEDED(hr));
+
+    RECT rect = bounds.ToRECT();
+
+    hr = view_port_outer_->SetViewportRect(&rect);
+    CHECK(SUCCEEDED(hr));
+
+    hr = content_outer->SetContentRect(&rect);
+    CHECK(SUCCEEDED(hr));
+  }
+
+  // Registers the passed in |window| as a Direct Manipulation consumer.
+  void Activate(HWND window) {
+    DCHECK(::IsWindow(window));
+    HRESULT hr = manager_->Activate(window);
+    CHECK(SUCCEEDED(hr));
+  }
+
+  // Passes the WM_MOUSEWHEEL messages to Direct Manipulation. This is for
+  // logistics purposes.
+  void HandleMouseWheel(HWND window, UINT message, WPARAM w_param,
+      LPARAM l_param) {
+    MSG msg = { window, message, w_param, l_param};
+
+    HRESULT hr = view_port_outer_->SetContact(DIRECTMANIPULATION_MOUSEFOCUS);
+    if (SUCCEEDED(hr)) {
+      BOOL handled = FALSE;
+      manager_->ProcessInput(&msg, &handled);
+      view_port_outer_->ReleaseContact(DIRECTMANIPULATION_MOUSEFOCUS);
+    }
+  }
+
+ private:
+  base::win::ScopedComPtr<IDirectManipulationManager2> manager_;
+  base::win::ScopedComPtr<IDirectManipulationCompositor> compositor_;
+  base::win::ScopedComPtr<IDirectManipulationUpdateManager> update_manager_;
+  base::win::ScopedComPtr<IDirectManipulationFrameInfoProvider> frame_info_;
+  base::win::ScopedComPtr<IDirectManipulationViewport2> view_port_outer_;
+};

[sky, 2015/08/11 15:43:12]

DISALLOW...

[ananta, 2015/08/11 20:52:08]

Done.

+
 // A custom MSAA object id used to determine if a screen reader or some
 // other client is listening on MSAA events - if so, we enable full web
 // accessibility support.
 const int kIdScreenReaderHoneyPot = 1;
 
 // static
 LegacyRenderWidgetHostHWND* LegacyRenderWidgetHostHWND::Create(
     HWND parent) {
   // content_unittests passes in the desktop window as the parent. We allow
   // the LegacyRenderWidgetHostHWND instance to be created in this case for
@@ skipping 33 matching lines @@
     ::EnableWindow(hwnd(), TRUE);
   }
 }
 
 HWND LegacyRenderWidgetHostHWND::GetParent() {
   return ::GetParent(hwnd());
 }
 
 void LegacyRenderWidgetHostHWND::Show() {
   ::ShowWindow(hwnd(), SW_SHOW);
+  if (direct_manipulation_helper_)
+    direct_manipulation_helper_->Activate(hwnd());
 }
 
 void LegacyRenderWidgetHostHWND::Hide() {
   ::ShowWindow(hwnd(), SW_HIDE);
 }
 
 void LegacyRenderWidgetHostHWND::SetBounds(const gfx::Rect& bounds) {
   gfx::Rect bounds_in_pixel = gfx::win::DIPToScreenRect(bounds);
   ::SetWindowPos(hwnd(), NULL, bounds_in_pixel.x(), bounds_in_pixel.y(),
                  bounds_in_pixel.width(), bounds_in_pixel.height(),
                  SWP_NOREDRAW);
+  if (direct_manipulation_helper_)
+    direct_manipulation_helper_->SetBounds(bounds_in_pixel);
 }
 
 void LegacyRenderWidgetHostHWND::OnFinalMessage(HWND hwnd) {
   if (host_) {
     host_->OnLegacyWindowDestroyed();
     host_ = NULL;
   }
   delete this;
 }
 
@@ skipping 20 matching lines @@
       reinterpret_cast<void **>(window_accessible_.Receive()));
   DCHECK(SUCCEEDED(hr));
 
   if (!BrowserAccessibilityState::GetInstance()->IsAccessibleBrowser()) {
     // Attempt to detect screen readers or other clients who want full
     // accessibility support, by seeing if they respond to this event.
     NotifyWinEvent(EVENT_SYSTEM_ALERT, hwnd(), kIdScreenReaderHoneyPot,
                    CHILDID_SELF);
   }
 
+  if (base::win::GetVersion() >= base::win::VERSION_WIN10) {
+    direct_manipulation_helper_.reset(new DirectManipulationHelper);
+    direct_manipulation_helper_->Initialize(hwnd());
+  }
+
   return !!SUCCEEDED(hr);
 }
 
 // static
 ui::WindowEventTarget* LegacyRenderWidgetHostHWND::GetWindowEventTarget(
     HWND parent) {
   return reinterpret_cast<ui::WindowEventTarget*>(ui::ViewProp::GetValue(
       parent, ui::WindowEventTarget::kWin32InputEventTarget));
 }
 
@@ skipping 96 matching lines @@
     // If the parent did not handle non client mouse messages, we call
     // DefWindowProc on the message with the parent window handle. This
     // ensures that WM_SYSCOMMAND is generated for the parent and we are
     // out of the picture.
     if (!handled &&
          (message >= WM_NCMOUSEMOVE && message <= WM_NCXBUTTONDBLCLK)) {
       ret = ::DefWindowProc(GetParent(), message, w_param, l_param);
       handled = TRUE;
     }
   }
+
+  if (direct_manipulation_helper_ &&
+      (message == WM_MOUSEWHEEL || message == WM_MOUSEHWHEEL)) {
+    direct_manipulation_helper_->HandleMouseWheel(hwnd(), message, w_param,
+        l_param);
+  }
   return ret;
 }
 
 LRESULT LegacyRenderWidgetHostHWND::OnMouseLeave(UINT message,
                                                  WPARAM w_param,
                                                  LPARAM l_param) {
   mouse_tracking_enabled_ = false;
   LRESULT ret = 0;
   if ((::GetCapture() != GetParent()) && GetWindowEventTarget(GetParent())) {
     // We should send a WM_MOUSELEAVE to the parent window only if the mouse
@@ skipping 118 matching lines @@
   // generate the legacy WM_VSCROLL/WM_HSCROLL messages.
   // We add these styles to ensure that trackpad/trackpoint scrolling
   // work.
   long current_style = ::GetWindowLong(hwnd(), GWL_STYLE);
   ::SetWindowLong(hwnd(), GWL_STYLE,
                   current_style | WS_VSCROLL | WS_HSCROLL);
   return 0;
 }
 
 }  // namespace content