Improve tablet mode detection on Windows 10+

base/win/win_util.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 "base/win/win_util.h"
 
 #include <aclapi.h>
 #include <cfgmgr32.h>
 #include <lm.h>
 #include <powrprof.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <shobjidl.h>  // Must be before propkey.
 #include <initguid.h>
+#include <inspectable.h>
 #include <propkey.h>
 #include <propvarutil.h>
+#include <psapi.h>
+#include <roapi.h>
 #include <sddl.h>
 #include <setupapi.h>
 #include <signal.h>
 #include <stddef.h>
 #include <stdlib.h>
+#include <uiviewsettingsinterop.h>
+#include <windows.ui.viewmanagement.h>
+#include <winstring.h>
+#include <wrl/wrappers/corewrappers.h>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_co_mem.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/windows_version.h"
 
 namespace base {
 namespace win {
 
 namespace {
 
 // Sets the value of |property_key| to |property_value| in |property_store|.
@@ skipping 54 matching lines @@
 const wchar_t kWindows8OSKRegPath[] =
     L"Software\\Classes\\CLSID\\{054AAE20-4BEA-4347-8A35-64A533254A9D}"
     L"\\LocalServer32";
 
 // Returns the current platform role. We use the PowerDeterminePlatformRoleEx
 // API for that.
 POWER_PLATFORM_ROLE GetPlatformRole() {
   return PowerDeterminePlatformRoleEx(POWER_PLATFORM_ROLE_V2);
 }
 
+// Uses the Windows 10 WRL API's to query the current system state. The API's
+// we are using in the function below are supported in Win32 apps as per msdn.
+// It looks like the API implementation is buggy at least on Surface 4 causing
+// it to always return UserInteractionMode_Touch which as per documentation
+// indicates tablet mode.
+bool IsWindows10TabletDevice() {
+  if (GetVersion() < VERSION_WIN10)
+    return false;
+
+  using RoGetActivationFactoryFunction = decltype(&RoGetActivationFactory);
+  using WindowsCreateStringFunction = decltype(&WindowsCreateString);
+
+  static RoGetActivationFactoryFunction get_factory = nullptr;
+  static WindowsCreateStringFunction create_string = nullptr;
+
+  if (!get_factory) {
+    DCHECK_EQ(create_string, static_cast<WindowsCreateStringFunction>(
+        nullptr));
+
+    HMODULE combase_dll = ::LoadLibrary(L"combase.dll");
+    if (!combase_dll)
+      return false;
+
+    get_factory = reinterpret_cast<RoGetActivationFactoryFunction>(
+        ::GetProcAddress(combase_dll, "RoGetActivationFactory"));
+    if (!get_factory) {
+      CHECK(false);
+      return false;
+    }
+
+    create_string = reinterpret_cast<WindowsCreateStringFunction>(
+        ::GetProcAddress(combase_dll, "WindowsCreateString"));
+    if (!create_string) {
+      CHECK(false);
+      return false;
+    }
+  }
+
+  HRESULT hr = E_FAIL;
+  // This HSTRING is allocated on the heap and is leaked.
+  static HSTRING view_settings_guid = NULL;
+  if (!view_settings_guid) {
+    hr = create_string(
+        RuntimeClass_Windows_UI_ViewManagement_UIViewSettings,
+        static_cast<UINT32>(
+            wcslen(RuntimeClass_Windows_UI_ViewManagement_UIViewSettings)),
+        &view_settings_guid);
+    if (FAILED(hr))
+      return false;
+  }
+
+  base::win::ScopedComPtr<IUIViewSettingsInterop> view_settings_interop;
+  hr = get_factory(view_settings_guid,
+                   __uuidof(IUIViewSettingsInterop),
+                   view_settings_interop.ReceiveVoid());
+  if (FAILED(hr))
+    return false;
+
+  base::win::ScopedComPtr<ABI::Windows::UI::ViewManagement::IUIViewSettings>
+      view_settings;
+  // TODO(ananta)
+  // Avoid using GetForegroundWindow here and pass in the HWND of the window
+  // intiating the request to display the keyboard.
+  hr = view_settings_interop->GetForWindow(
+      ::GetForegroundWindow(),
+      __uuidof(ABI::Windows::UI::ViewManagement::IUIViewSettings),
+      view_settings.ReceiveVoid());
+  if (FAILED(hr))
+    return false;
+
+  ABI::Windows::UI::ViewManagement::UserInteractionMode mode =
+      ABI::Windows::UI::ViewManagement::UserInteractionMode_Mouse;
+  view_settings->get_UserInteractionMode(&mode);
+  return mode == ABI::Windows::UI::ViewManagement::UserInteractionMode_Touch;
+}
+
 }  // namespace
 
 // Returns true if a physical keyboard is detected on Windows 8 and up.
 // Uses the Setup APIs to enumerate the attached keyboards and returns true
 // if the keyboard count is 1 or more.. While this will work in most cases
 // it won't work if there are devices which expose keyboard interfaces which
 // are attached to the machine.
 bool IsKeyboardPresentOnSlate(std::string* reason) {
   bool result = false;
 
@@ skipping 14 matching lines @@
   if ((GetSystemMetrics(SM_DIGITIZER) & NID_INTEGRATED_TOUCH)
         != NID_INTEGRATED_TOUCH) {
     if (reason) {
       *reason += "NID_INTEGRATED_TOUCH\n";
       result = true;
     } else {
       return true;
     }
   }
 
+  // If it is a tablet device we assume that there is no keyboard attached.
   if (IsTabletDevice(reason)) {
     if (reason)
       *reason += "Tablet device.\n";
-    return true;
+    return false;
   } else {
     if (reason) {
       *reason += "Not a tablet device";
       result = true;
     } else {
       return true;
     }
   }
 
   // To determine whether a keyboard is present on the device, we do the
@@ skipping 226 matching lines @@
   signal(SIGABRT, ForceCrashOnSigAbort);
 }
 
 bool IsTabletDevice(std::string* reason) {
   if (GetVersion() < VERSION_WIN8) {
     if (reason)
       *reason = "Tablet device detection not supported below Windows 8\n";
     return false;
   }
 
+  if (IsWindows10TabletDevice())
+    return true;
+
   if (GetSystemMetrics(SM_MAXIMUMTOUCHES) == 0) {
     if (reason) {
       *reason += "Device does not support touch.\n";
     } else {
       return false;
     }
   }
 
   // If the device is docked, the user is treating the device as a PC.
   if (GetSystemMetrics(SM_SYSTEMDOCKED) != 0) {
     if (reason) {
       *reason += "SM_SYSTEMDOCKED\n";
     } else {
       return false;
     }
   }
 
   // PlatformRoleSlate was added in Windows 8+.
   POWER_PLATFORM_ROLE role = GetPlatformRole();
   bool mobile_power_profile = (role == PlatformRoleMobile);
   bool slate_power_profile = (role == PlatformRoleSlate);
 
   bool is_tablet = false;
-
+  bool is_tablet_pc = false;
   if (mobile_power_profile || slate_power_profile) {
+    is_tablet_pc = !GetSystemMetrics(SM_TABLETPC);
     is_tablet = !GetSystemMetrics(SM_CONVERTIBLESLATEMODE);
     if (!is_tablet) {
       if (reason) {
         *reason += "Not in slate mode.\n";
       } else {
         return false;
       }
     } else {
       if (reason) {
         *reason += (role == PlatformRoleMobile) ? "PlatformRoleMobile\n" :
                                                   "PlatformRoleSlate\n";
       }
     }
   } else {
     if (reason)
       *reason += "Device role is not mobile or slate.\n";
   }
-  return is_tablet;
+  return is_tablet && is_tablet_pc;
 }
 
 bool DisplayVirtualKeyboard() {
   if (GetVersion() < VERSION_WIN8)
     return false;
 
   if (IsKeyboardPresentOnSlate(nullptr))
     return false;
 
   static LazyInstance<string16>::Leaky osk_path = LAZY_INSTANCE_INITIALIZER;
@@ skipping 130 matching lines @@
 }
 
 bool IsUser32AndGdi32Available() {
   static base::LazyInstance<LazyIsUser32AndGdi32Available>::Leaky available =
       LAZY_INSTANCE_INITIALIZER;
   return available.Get().value();
 }
 
 }  // namespace win
 }  // namespace base