Refactor the IsKeyboardPresentOnSlate function.

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>
@@ skipping 81 matching lines @@
 
   const bool value_;
 
   DISALLOW_COPY_AND_ASSIGN(LazyIsUser32AndGdi32Available);
 };
 
 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() {
+  HMODULE power_prof_module = ::GetModuleHandle(L"powrprof.dll");

[jschuh, 2016/01/07 01:18:40]

Skip the dynamic loads and just do a version check, because powrprof.dll is
already delay loaded anyway.

[ananta, 2016/01/07 22:41:05]

Done.

+  if (!power_prof_module)
+    power_prof_module = ::LoadLibrary(L"powrprof.dll");
+
+  DCHECK(power_prof_module);
+  if (!power_prof_module)
+    return PlatformRoleDesktop;
+
+  typedef POWER_PLATFORM_ROLE (WINAPI* DeterminePlatformRoleEx)(
+      unsigned long version);
+  DeterminePlatformRoleEx determine_platform_role_ex =
+      reinterpret_cast<DeterminePlatformRoleEx>(::GetProcAddress(
+          power_prof_module, "PowerDeterminePlatformRoleEx"));
+
+  DCHECK(determine_platform_role_ex);
+
+  return determine_platform_role_ex ?
+      determine_platform_role_ex(POWER_PLATFORM_ROLE_V2) : PlatformRoleDesktop;
+}
+
 }  // 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;
 
-  if (GetVersion() < VERSION_WIN7) {
-    *reason = "Detection not supported";
-    return false;
-  }
+  DCHECK(GetVersion() >= VERSION_WIN8);

[jschuh, 2016/01/07 01:18:40]

Keep the old code here, because it's called from
ChromeInternalLogSource::PopulateUsbKeyboardDetected().

[ananta, 2016/01/07 22:41:05]

Done.

 
   // This function is only supported for Windows 8 and up.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableUsbKeyboardDetect)) {
     if (reason)
       *reason = "Detection disabled";
     return false;
   }
 
   // This function should be only invoked for machines with touch screens.
   if ((GetSystemMetrics(SM_DIGITIZER) & NID_INTEGRATED_TOUCH)
         != NID_INTEGRATED_TOUCH) {
     if (reason) {
       *reason += "NID_INTEGRATED_TOUCH\n";
       result = true;
     } else {
       return true;
     }
   }
 
-  // If the device is docked, the user is treating the device as a PC.
-  if (GetSystemMetrics(SM_SYSTEMDOCKED) != 0) {
+  if (IsTabletDevice(reason)) {
+    if (reason)
+      *reason += "Tablet device.\n";
+    return true;
+  } else {
     if (reason) {
-      *reason += "SM_SYSTEMDOCKED\n";
+      *reason += "Not a tablet device";
       result = true;
     } else {
       return true;
     }
   }
 
   // To determine whether a keyboard is present on the device, we do the
   // following:-
   // 1. Check whether the device supports auto rotation. If it does then
   //    it possibly supports flipping from laptop to slate mode. If it
@@ skipping 25 matching lines @@
       if (reason) {
         *reason += (auto_rotation_state & AR_NOSENSOR) ? "AR_NOSENSOR\n" :
                                                          "AR_NOT_SUPPORTED\n";
         result = true;
       } else {
         return true;
       }
     }
   }
 
-  // Check if the device is being used as a laptop or a tablet. This can be
-  // checked by first checking the role of the device and then the
-  // corresponding system metric (SM_CONVERTIBLESLATEMODE). If it is being used
-  // as a tablet then we want the OSK to show up.
-  POWER_PLATFORM_ROLE role = PowerDeterminePlatformRole();
-
-  if (((role == PlatformRoleMobile) || (role == PlatformRoleSlate)) &&
-       (GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0)) {
-      if (reason) {
-        *reason += (role == PlatformRoleMobile) ? "PlatformRoleMobile\n" :
-                                                  "PlatformRoleSlate\n";
-        // Don't change result here if it's already true.
-      } else {
-        return false;
-      }
-  }
-
   const GUID KEYBOARD_CLASS_GUID =
       { 0x4D36E96B, 0xE325,  0x11CE,
           { 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 } };
 
   // Query for all the keyboard devices.
   HDEVINFO device_info =
       SetupDiGetClassDevs(&KEYBOARD_CLASS_GUID, NULL, NULL, DIGCF_PRESENT);
   if (device_info == INVALID_HANDLE_VALUE) {
     if (reason)
       *reason += "No keyboard info\n";
@@ skipping 171 matching lines @@
   // has the sideffect of clearing our exception filter, which means we
   // don't get any crash.
   _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 
   // Set a SIGABRT handler for good measure. We will crash even if the default
   // is left in place, however this allows us to crash earlier. And it also
   // lets us crash in response to code which might directly call raise(SIGABRT)
   signal(SIGABRT, ForceCrashOnSigAbort);
 }
 
-bool IsTabletDevice() {
-  if (GetSystemMetrics(SM_MAXIMUMTOUCHES) == 0)
+bool IsTabletDevice(std::string* reason) {
+  if (GetVersion() < VERSION_WIN8) {
+    if (reason)
+      *reason = "Tablet device detection not supported below Windows 8\n";
     return false;
+  }
 
-  Version version = GetVersion();
-  if (version == VERSION_XP)
-    return (GetSystemMetrics(SM_TABLETPC) != 0);
+  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)
-    return false;
+  if (GetSystemMetrics(SM_SYSTEMDOCKED) != 0) {
+    if (reason) {
+      *reason += "SM_SYSTEMDOCKED\n";
+    } else {
+      return false;
+    }
+  }
 
-  // PlatformRoleSlate was only added in Windows 8, but prior to Win8 it is
-  // still possible to check for a mobile power profile.
-  POWER_PLATFORM_ROLE role = PowerDeterminePlatformRole();
+  // PlatformRoleSlate was added in Windows 8+.
+  POWER_PLATFORM_ROLE role = GetPlatformRole();
   bool mobile_power_profile = (role == PlatformRoleMobile);
-  bool slate_power_profile = false;
-  if (version >= VERSION_WIN8)
-    slate_power_profile = (role == PlatformRoleSlate);
+  bool slate_power_profile = (role == PlatformRoleSlate);
 
-  if (mobile_power_profile || slate_power_profile)
-    return (GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0);
+  bool is_tablet = false;
 
-  return false;
+  if (mobile_power_profile || slate_power_profile) {
+    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;
 }
 
 bool DisplayVirtualKeyboard() {
   if (GetVersion() < VERSION_WIN8)
     return false;
 
   if (IsKeyboardPresentOnSlate(nullptr))
     return false;
 
   static LazyInstance<string16>::Leaky osk_path = LAZY_INSTANCE_INITIALIZER;
@@ skipping 132 matching lines @@
 }
 
 bool IsUser32AndGdi32Available() {
   static base::LazyInstance<LazyIsUser32AndGdi32Available>::Leaky available =
       LAZY_INSTANCE_INITIALIZER;
   return available.Get().value();
 }
 
 }  // namespace win
 }  // namespace base