src/third_party/libjingle/source/talk/base/systeminfo.cc

   1 /*
   2  * libjingle
   3  * Copyright 2008 Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "talk/base/systeminfo.h"
  29
  30 #if defined(WIN32)
  31 #include <winsock2.h>
  32 #ifndef EXCLUDE_D3D9
  33 #include <d3d9.h>
  34 #endif
  35 #include <intrin.h>  // for __cpuid()
  36 #elif defined(OSX)
  37 #include <ApplicationServices/ApplicationServices.h>
  38 #include <CoreServices/CoreServices.h>
  39 #elif defined(LINUX) || defined(ANDROID)
  40 #include <unistd.h>
  41 #endif
  42 #if defined(OSX) || defined(IOS)
  43 #include <sys/sysctl.h>
  44 #endif
  45
  46 #if defined(WIN32)
  47 #include "talk/base/scoped_ptr.h"
  48 #include "talk/base/win32.h"
  49 #elif defined(OSX)
  50 #include "talk/base/macconversion.h"
  51 #elif defined(LINUX) || defined(ANDROID)
  52 #include "talk/base/linux.h"
  53 #endif
  54 #include "talk/base/common.h"
  55 #include "talk/base/logging.h"
  56 #include "talk/base/stringutils.h"
  57
  58 namespace talk_base {
  59
  60 // See Also: http://msdn.microsoft.com/en-us/library/ms683194(v=vs.85).aspx
  61 #if defined(WIN32)
  62 typedef BOOL (WINAPI *LPFN_GLPI)(
  63     PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
  64     PDWORD);
  65
  66 static void GetProcessorInformation(int* physical_cpus, int* cache_size) {
  67   // GetLogicalProcessorInformation() is available on Windows XP SP3 and beyond.
  68   LPFN_GLPI glpi = reinterpret_cast<LPFN_GLPI>(GetProcAddress(
  69       GetModuleHandle(L"kernel32"),
  70       "GetLogicalProcessorInformation"));
  71   if (NULL == glpi) {
  72     return;
  73   }
  74   // Determine buffer size, allocate and get processor information.
  75   // Size can change between calls (unlikely), so a loop is done.
  76   DWORD return_length = 0;
  77   scoped_ptr<SYSTEM_LOGICAL_PROCESSOR_INFORMATION[]> infos;
  78   while (!glpi(infos.get(), &return_length)) {
  79     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
  80       infos.reset(new SYSTEM_LOGICAL_PROCESSOR_INFORMATION[
  81           return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION)]);
  82     } else {
  83       return;
  84     }
  85   }
  86   *physical_cpus = 0;
  87   *cache_size = 0;
  88   for (size_t i = 0;
  89       i < return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i) {
  90     if (infos[i].Relationship == RelationProcessorCore) {
  91       ++*physical_cpus;
  92     } else if (infos[i].Relationship == RelationCache) {
  93       int next_cache_size = static_cast<int>(infos[i].Cache.Size);
  94       if (next_cache_size >= *cache_size) {
  95         *cache_size = next_cache_size;
  96       }
  97     }
  98   }
  99   return;
 100 }
 101 #else
 102 // TODO(fbarchard): Use gcc 4.4 provided cpuid intrinsic
 103 // 32 bit fpic requires ebx be preserved
 104 #if (defined(__pic__) || defined(__APPLE__)) && defined(__i386__)
 105 static inline void __cpuid(int cpu_info[4], int info_type) {
 106   __asm__ volatile (  // NOLINT
 107     "mov %%ebx, %%edi\n"
 108     "cpuid\n"
 109     "xchg %%edi, %%ebx\n"
 110     : "=a"(cpu_info[0]), "=D"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
 111     : "a"(info_type)
 112   );  // NOLINT
 113 }
 114 #elif defined(__i386__) || defined(__x86_64__)
 115 static inline void __cpuid(int cpu_info[4], int info_type) {
 116   __asm__ volatile (  // NOLINT
 117     "cpuid\n"
 118     : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
 119     : "a"(info_type)
 120   );  // NOLINT
 121 }
 122 #endif
 123 #endif  // WIN32
 124
 125 // Note(fbarchard):
 126 // Family and model are extended family and extended model.  8 bits each.
 127 SystemInfo::SystemInfo()
 128     : physical_cpus_(1), logical_cpus_(1), cache_size_(0),
 129       cpu_family_(0), cpu_model_(0), cpu_stepping_(0),
 130       cpu_speed_(0), memory_(0) {
 131   // Initialize the basic information.
 132 #if defined(__arm__) || defined(_M_ARM)
 133   cpu_arch_ = SI_ARCH_ARM;
 134 #elif defined(__x86_64__) || defined(_M_X64)
 135   cpu_arch_ = SI_ARCH_X64;
 136 #elif defined(__i386__) || defined(_M_IX86)
 137   cpu_arch_ = SI_ARCH_X86;
 138 #else
 139   cpu_arch_ = SI_ARCH_UNKNOWN;
 140 #endif
 141
 142 #if defined(WIN32)
 143   SYSTEM_INFO si;
 144   GetSystemInfo(&si);
 145   logical_cpus_ = si.dwNumberOfProcessors;
 146   GetProcessorInformation(&physical_cpus_, &cache_size_);
 147   if (physical_cpus_ <= 0) {
 148     physical_cpus_ = logical_cpus_;
 149   }
 150   cpu_family_ = si.wProcessorLevel;
 151   cpu_model_ = si.wProcessorRevision >> 8;
 152   cpu_stepping_ = si.wProcessorRevision & 0xFF;
 153 #elif defined(OSX) || defined(IOS)
 154   uint32_t sysctl_value;
 155   size_t length = sizeof(sysctl_value);
 156   if (!sysctlbyname("hw.physicalcpu_max", &sysctl_value, &length, NULL, 0)) {
 157     physical_cpus_ = static_cast<int>(sysctl_value);
 158   }
 159   length = sizeof(sysctl_value);
 160   if (!sysctlbyname("hw.logicalcpu_max", &sysctl_value, &length, NULL, 0)) {
 161     logical_cpus_ = static_cast<int>(sysctl_value);
 162   }
 163   uint64_t sysctl_value64;
 164   length = sizeof(sysctl_value64);
 165   if (!sysctlbyname("hw.l3cachesize", &sysctl_value64, &length, NULL, 0)) {
 166     cache_size_ = static_cast<int>(sysctl_value64);
 167   }
 168   if (!cache_size_) {
 169     length = sizeof(sysctl_value64);
 170     if (!sysctlbyname("hw.l2cachesize", &sysctl_value64, &length, NULL, 0)) {
 171       cache_size_ = static_cast<int>(sysctl_value64);
 172     }
 173   }
 174   length = sizeof(sysctl_value);
 175   if (!sysctlbyname("machdep.cpu.family", &sysctl_value, &length, NULL, 0)) {
 176     cpu_family_ = static_cast<int>(sysctl_value);
 177   }
 178   length = sizeof(sysctl_value);
 179   if (!sysctlbyname("machdep.cpu.model", &sysctl_value, &length, NULL, 0)) {
 180     cpu_model_ = static_cast<int>(sysctl_value);
 181   }
 182   length = sizeof(sysctl_value);
 183   if (!sysctlbyname("machdep.cpu.stepping", &sysctl_value, &length, NULL, 0)) {
 184     cpu_stepping_ = static_cast<int>(sysctl_value);
 185   }
 186 #elif defined(__native_client__)
 187   // TODO(ryanpetrie): Implement this via PPAPI when it's available.
 188 #else  // LINUX || ANDROID
 189   ProcCpuInfo proc_info;
 190   if (proc_info.LoadFromSystem()) {
 191     proc_info.GetNumCpus(&logical_cpus_);
 192     proc_info.GetNumPhysicalCpus(&physical_cpus_);
 193     proc_info.GetCpuFamily(&cpu_family_);
 194 #if defined(CPU_X86)
 195     // These values only apply to x86 systems.
 196     proc_info.GetSectionIntValue(0, "model", &cpu_model_);
 197     proc_info.GetSectionIntValue(0, "stepping", &cpu_stepping_);
 198     proc_info.GetSectionIntValue(0, "cpu MHz", &cpu_speed_);
 199     proc_info.GetSectionIntValue(0, "cache size", &cache_size_);
 200     cache_size_ *= 1024;
 201 #endif
 202   }
 203   // ProcCpuInfo reads cpu speed from "cpu MHz" under /proc/cpuinfo.
 204   // But that number is a moving target which can change on-the-fly according to
 205   // many factors including system workload.
 206   // See /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors.
 207   // The one in /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq is more
 208   // accurate. We use it as our cpu speed when it is available.
 209   // cpuinfo_max_freq is measured in KHz and requires conversion to MHz.
 210   int max_freq = talk_base::ReadCpuMaxFreq();
 211   if (max_freq > 0) {
 212     cpu_speed_ = max_freq / 1000;
 213   }
 214 #endif
 215 // For L2 CacheSize see also
 216 // http://www.flounder.com/cpuid_explorer2.htm#CPUID(0x800000006)
 217 #ifdef CPU_X86
 218   if (cache_size_ == 0) {
 219     int cpu_info[4];
 220     __cpuid(cpu_info, 0x80000000);  // query maximum extended cpuid function.
 221     if (static_cast<uint32>(cpu_info[0]) >= 0x80000006) {
 222       __cpuid(cpu_info, 0x80000006);
 223       cache_size_ = (cpu_info[2] >> 16) * 1024;
 224     }
 225   }
 226 #endif
 227 }
 228
 229 // Return the number of cpu threads available to the system.
 230 int SystemInfo::GetMaxCpus() {
 231   return logical_cpus_;
 232 }
 233
 234 // Return the number of cpu cores available to the system.
 235 int SystemInfo::GetMaxPhysicalCpus() {
 236   return physical_cpus_;
 237 }
 238
 239 // Return the number of cpus available to the process.  Since affinity can be
 240 // changed on the fly, do not cache this value.
 241 // Can be affected by heat.
 242 int SystemInfo::GetCurCpus() {
 243   int cur_cpus;
 244 #if defined(WIN32)
 245   DWORD_PTR process_mask, system_mask;
 246   ::GetProcessAffinityMask(::GetCurrentProcess(), &process_mask, &system_mask);
 247   for (cur_cpus = 0; process_mask; ++cur_cpus) {
 248     // Sparse-ones algorithm. There are slightly faster methods out there but
 249     // they are unintuitive and won't make a difference on a single dword.
 250     process_mask &= (process_mask - 1);
 251   }
 252 #elif defined(OSX) || defined(IOS)
 253   uint32_t sysctl_value;
 254   size_t length = sizeof(sysctl_value);
 255   int error = sysctlbyname("hw.ncpu", &sysctl_value, &length, NULL, 0);
 256   cur_cpus = !error ? static_cast<int>(sysctl_value) : 1;
 257 #else
 258   // Linux, Solaris, ANDROID
 259   cur_cpus = static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN));
 260 #endif
 261   return cur_cpus;
 262 }
 263
 264 // Return the type of this CPU.
 265 SystemInfo::Architecture SystemInfo::GetCpuArchitecture() {
 266   return cpu_arch_;
 267 }
 268
 269 // Returns the vendor string from the cpu, e.g. "GenuineIntel", "AuthenticAMD".
 270 // See "Intel Processor Identification and the CPUID Instruction"
 271 // (Intel document number: 241618)
 272 std::string SystemInfo::GetCpuVendor() {
 273   if (cpu_vendor_.empty()) {
 274 #if defined(CPU_X86)
 275     int cpu_info[4];
 276     __cpuid(cpu_info, 0);
 277     cpu_info[0] = cpu_info[1];  // Reorder output
 278     cpu_info[1] = cpu_info[3];
 279     cpu_info[2] = cpu_info[2];
 280     cpu_info[3] = 0;
 281     cpu_vendor_ = std::string(reinterpret_cast<char*>(&cpu_info[0]));
 282 #elif defined(CPU_ARM)
 283     cpu_vendor_ = std::string("ARM");
 284 #else
 285     cpu_vendor_ = std::string("Undefined");
 286 #endif
 287   }
 288   return cpu_vendor_;
 289 }
 290
 291 int SystemInfo::GetCpuCacheSize() {
 292   return cache_size_;
 293 }
 294
 295 // Return the "family" of this CPU.
 296 int SystemInfo::GetCpuFamily() {
 297   return cpu_family_;
 298 }
 299
 300 // Return the "model" of this CPU.
 301 int SystemInfo::GetCpuModel() {
 302   return cpu_model_;
 303 }
 304
 305 // Return the "stepping" of this CPU.
 306 int SystemInfo::GetCpuStepping() {
 307   return cpu_stepping_;
 308 }
 309
 310 // Return the clockrate of the primary processor in Mhz.  This value can be
 311 // cached.  Returns -1 on error.
 312 int SystemInfo::GetMaxCpuSpeed() {
 313   if (cpu_speed_) {
 314     return cpu_speed_;
 315   }
 316 #if defined(WIN32)
 317   HKEY key;
 318   static const WCHAR keyName[] =
 319       L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0";
 320
 321   if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName , 0, KEY_QUERY_VALUE, &key)
 322       == ERROR_SUCCESS) {
 323     DWORD data, len;
 324     len = sizeof(data);
 325
 326     if (RegQueryValueEx(key, L"~Mhz", 0, 0, reinterpret_cast<LPBYTE>(&data),
 327                         &len) == ERROR_SUCCESS) {
 328       cpu_speed_ = data;
 329     } else {
 330       LOG(LS_WARNING) << "Failed to query registry value HKLM\\" << keyName
 331                       << "\\~Mhz";
 332       cpu_speed_ = -1;
 333     }
 334
 335     RegCloseKey(key);
 336   } else {
 337     LOG(LS_WARNING) << "Failed to open registry key HKLM\\" << keyName;
 338     cpu_speed_ = -1;
 339   }
 340 #elif defined(IOS) || defined(OSX)
 341   uint64_t sysctl_value;
 342   size_t length = sizeof(sysctl_value);
 343   int error = sysctlbyname("hw.cpufrequency_max", &sysctl_value, &length,
 344                            NULL, 0);
 345   cpu_speed_ = !error ? static_cast<int>(sysctl_value/1000000) : -1;
 346 #else
 347   // TODO(fbarchard): Implement using proc/cpuinfo
 348   cpu_speed_ = 0;
 349 #endif
 350   return cpu_speed_;
 351 }
 352
 353 // Dynamically check the current clockrate, which could be reduced because of
 354 // powersaving profiles.  Eventually for windows we want to query WMI for
 355 // root\WMI::ProcessorPerformance.InstanceName="Processor_Number_0".frequency
 356 int SystemInfo::GetCurCpuSpeed() {
 357 #if defined(WIN32)
 358   // TODO(fbarchard): Add WMI check, requires COM initialization
 359   // NOTE(fbarchard): Testable on Sandy Bridge.
 360   return GetMaxCpuSpeed();
 361 #elif defined(IOS) || defined(OSX)
 362   uint64_t sysctl_value;
 363   size_t length = sizeof(sysctl_value);
 364   int error = sysctlbyname("hw.cpufrequency", &sysctl_value, &length, NULL, 0);
 365   return !error ? static_cast<int>(sysctl_value/1000000) : GetMaxCpuSpeed();
 366 #else  // LINUX || ANDROID
 367   // TODO(fbarchard): Use proc/cpuinfo for Cur speed on Linux.
 368   return GetMaxCpuSpeed();
 369 #endif
 370 }
 371
 372 // Returns the amount of installed physical memory in Bytes.  Cacheable.
 373 // Returns -1 on error.
 374 int64 SystemInfo::GetMemorySize() {
 375   if (memory_) {
 376     return memory_;
 377   }
 378
 379 #if defined(WIN32)
 380   MEMORYSTATUSEX status = {0};
 381   status.dwLength = sizeof(status);
 382
 383   if (GlobalMemoryStatusEx(&status)) {
 384     memory_ = status.ullTotalPhys;
 385   } else {
 386     LOG_GLE(LS_WARNING) << "GlobalMemoryStatusEx failed.";
 387     memory_ = -1;
 388   }
 389
 390 #elif defined(OSX) || defined(IOS)
 391   size_t len = sizeof(memory_);
 392   int error = sysctlbyname("hw.memsize", &memory_, &len, NULL, 0);
 393   if (error || memory_ == 0) {
 394     memory_ = -1;
 395   }
 396 #else  // LINUX || ANDROID
 397   memory_ = static_cast<int64>(sysconf(_SC_PHYS_PAGES)) *
 398       static_cast<int64>(sysconf(_SC_PAGESIZE));
 399   if (memory_ < 0) {
 400     LOG(LS_WARNING) << "sysconf(_SC_PHYS_PAGES) failed."
 401                     << "sysconf(_SC_PHYS_PAGES) " << sysconf(_SC_PHYS_PAGES)
 402                     << "sysconf(_SC_PAGESIZE) " << sysconf(_SC_PAGESIZE);
 403     memory_ = -1;
 404   }
 405 #endif
 406
 407   return memory_;
 408 }
 409
 410
 411 // Return the name of the machine model we are currently running on.
 412 // This is a human readable string that consists of the name and version
 413 // number of the hardware, i.e 'MacBookAir1,1'. Returns an empty string if
 414 // model can not be determined. The string is cached for subsequent calls.
 415 std::string SystemInfo::GetMachineModel() {
 416   if (!machine_model_.empty()) {
 417     return machine_model_;
 418   }
 419
 420 #if defined(OSX) || defined(IOS)
 421   char buffer[128];
 422   size_t length = sizeof(buffer);
 423   int error = sysctlbyname("hw.model", buffer, &length, NULL, 0);
 424   if (!error) {
 425     machine_model_.assign(buffer, length - 1);
 426   } else {
 427     machine_model_.clear();
 428   }
 429 #else
 430   machine_model_ = "Not available";
 431 #endif
 432
 433   return machine_model_;
 434 }
 435
 436 #ifdef OSX
 437 // Helper functions to query IOKit for video hardware properties.
 438 static CFTypeRef SearchForProperty(io_service_t port, CFStringRef name) {
 439   return IORegistryEntrySearchCFProperty(port, kIOServicePlane,
 440       name, kCFAllocatorDefault,
 441       kIORegistryIterateRecursively | kIORegistryIterateParents);
 442 }
 443
 444 static void GetProperty(io_service_t port, CFStringRef name, int* value) {
 445   if (!value) return;
 446   CFTypeRef ref = SearchForProperty(port, name);
 447   if (ref) {
 448     CFTypeID refType = CFGetTypeID(ref);
 449     if (CFNumberGetTypeID() == refType) {
 450       CFNumberRef number = reinterpret_cast<CFNumberRef>(ref);
 451       p_convertCFNumberToInt(number, value);
 452     } else if (CFDataGetTypeID() == refType) {
 453       CFDataRef data = reinterpret_cast<CFDataRef>(ref);
 454       if (CFDataGetLength(data) == sizeof(UInt32)) {
 455         *value = *reinterpret_cast<const UInt32*>(CFDataGetBytePtr(data));
 456       }
 457     }
 458     CFRelease(ref);
 459   }
 460 }
 461
 462 static void GetProperty(io_service_t port, CFStringRef name,
 463                         std::string* value) {
 464   if (!value) return;
 465   CFTypeRef ref = SearchForProperty(port, name);
 466   if (ref) {
 467     CFTypeID refType = CFGetTypeID(ref);
 468     if (CFStringGetTypeID() == refType) {
 469       CFStringRef stringRef = reinterpret_cast<CFStringRef>(ref);
 470       p_convertHostCFStringRefToCPPString(stringRef, *value);
 471     } else if (CFDataGetTypeID() == refType) {
 472       CFDataRef dataRef = reinterpret_cast<CFDataRef>(ref);
 473       *value = std::string(reinterpret_cast<const char*>(
 474           CFDataGetBytePtr(dataRef)), CFDataGetLength(dataRef));
 475     }
 476     CFRelease(ref);
 477   }
 478 }
 479 #endif
 480
 481 // Fills a struct with information on the graphics adapater and returns true
 482 // iff successful.
 483 bool SystemInfo::GetGpuInfo(GpuInfo *info) {
 484   if (!info) return false;
 485 #if defined(WIN32) && !defined(EXCLUDE_D3D9)
 486   D3DADAPTER_IDENTIFIER9 identifier;
 487   HRESULT hr = E_FAIL;
 488   HINSTANCE d3d_lib = LoadLibrary(L"d3d9.dll");
 489
 490   if (d3d_lib) {
 491     typedef IDirect3D9* (WINAPI *D3DCreate9Proc)(UINT);
 492     D3DCreate9Proc d3d_create_proc = reinterpret_cast<D3DCreate9Proc>(
 493         GetProcAddress(d3d_lib, "Direct3DCreate9"));
 494     if (d3d_create_proc) {
 495       IDirect3D9* d3d = d3d_create_proc(D3D_SDK_VERSION);
 496       if (d3d) {
 497         hr = d3d->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &identifier);
 498         d3d->Release();
 499       }
 500     }
 501     FreeLibrary(d3d_lib);
 502   }
 503
 504   if (hr != D3D_OK) {
 505     LOG(LS_ERROR) << "Failed to access Direct3D9 information.";
 506     return false;
 507   }
 508
 509   info->device_name = identifier.DeviceName;
 510   info->description = identifier.Description;
 511   info->vendor_id = identifier.VendorId;
 512   info->device_id = identifier.DeviceId;
 513   info->driver = identifier.Driver;
 514   // driver_version format: product.version.subversion.build
 515   std::stringstream ss;
 516   ss << HIWORD(identifier.DriverVersion.HighPart) << "."
 517      << LOWORD(identifier.DriverVersion.HighPart) << "."
 518      << HIWORD(identifier.DriverVersion.LowPart) << "."
 519      << LOWORD(identifier.DriverVersion.LowPart);
 520   info->driver_version = ss.str();
 521   return true;
 522 #elif defined(OSX)
 523   // We'll query the IOKit for the gpu of the main display.
 524   io_service_t display_service_port = CGDisplayIOServicePort(
 525       kCGDirectMainDisplay);
 526   GetProperty(display_service_port, CFSTR("vendor-id"), &info->vendor_id);
 527   GetProperty(display_service_port, CFSTR("device-id"), &info->device_id);
 528   GetProperty(display_service_port, CFSTR("model"), &info->description);
 529   return true;
 530 #else  // LINUX || ANDROID
 531   // TODO(fbarchard): Implement this on Linux
 532   return false;
 533 #endif
 534 }
 535 }  // namespace talk_base