win: Retrieve module version/type information

snapshot/win/system_snapshot_win.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "snapshot/win/system_snapshot_win.h"
 
 #include <intrin.h>
 #include <powrprof.h>
 #include <windows.h>
 #include <winnt.h>
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "util/win/module_version.h"
 
 namespace crashpad {
 
 namespace {
 
 //! \brief Gets a string representation for a VS_FIXEDFILEINFO.dwFileFlags
 //!     value.
 std::string GetStringForFileFlags(uint32_t file_flags) {
   std::string result;
   DCHECK_EQ(file_flags & VS_FF_INFOINFERRED, 0u);
@@ skipping 48 matching lines @@
 
   // We use both GetVersionEx and VerQueryValue. GetVersionEx is not trustworthy
   // after Windows 8 (depending on the application manifest) so its data is used
   // only to fill the os_server_ field, and the rest comes from the version
   // information stamped on kernel32.dll.
   OSVERSIONINFOEX version_info = {sizeof(version_info)};
   if (!GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&version_info))) {
     PLOG(WARNING) << "GetVersionEx";
   } else {
     const wchar_t kSystemDll[] = L"kernel32.dll";
-    DWORD size = GetFileVersionInfoSize(kSystemDll, nullptr);
-    if (!size) {
-      PLOG(WARNING) << "GetFileVersionInfoSize";
-    } else {
-      scoped_ptr<uint8_t[]> data(new uint8_t[size]);
-      if (!GetFileVersionInfo(kSystemDll, 0, size, data.get())) {
-        PLOG(WARNING) << "GetFileVersionInfo";
-      } else {
-        VS_FIXEDFILEINFO* fixed_file_info;
-        UINT size;
-        if (!VerQueryValue(data.get(),
-                           L"\\",
-                           reinterpret_cast<void**>(&fixed_file_info),
-                           &size)) {
-          PLOG(WARNING) << "VerQueryValue";
-        } else {
-          uint32_t valid_flags =
-              fixed_file_info->dwFileFlags & fixed_file_info->dwFileFlagsMask;
-          std::string flags_string = GetStringForFileFlags(valid_flags);
-          os_version_major_ =
-              (fixed_file_info->dwFileVersionMS & 0xffff0000) >> 16;
-          os_version_minor_ = fixed_file_info->dwFileVersionMS & 0xffff;
-          os_version_bugfix_ =
-              (fixed_file_info->dwFileVersionLS & 0xffff0000) >> 16;
-          os_version_build_ = base::StringPrintf(
-              "%d", fixed_file_info->dwFileVersionLS & 0xffff);
-          os_server_ = version_info.wProductType != VER_NT_WORKSTATION;
-          std::string os_name = GetStringForFileOS(fixed_file_info->dwFileOS);
-          os_version_full_ = base::StringPrintf(
-              "%s %d.%d.%d.%s%s",
-              os_name.c_str(),
-              os_version_major_,
-              os_version_minor_,
-              os_version_bugfix_,
-              os_version_build_.c_str(),
-              flags_string.empty() ? "" : (std::string(" (") + flags_string +
-                                           ")").c_str());
-        }
-      }
+    VS_FIXEDFILEINFO ffi;
+    if (GetModuleVersionAndType(base::FilePath(kSystemDll), &ffi)) {
+      std::string flags_string = GetStringForFileFlags(ffi.dwFileFlags);
+      os_server_ = version_info.wProductType != VER_NT_WORKSTATION;
+      std::string os_name = GetStringForFileOS(ffi.dwFileOS);
+      os_version_major_ = ffi.dwFileVersionMS >> 16;
+      os_version_minor_ = ffi.dwFileVersionMS & 0xffff;
+      os_version_bugfix_ = ffi.dwFileVersionLS >> 16;
+      os_version_build_ =
+          base::StringPrintf("%d", ffi.dwFileVersionLS & 0xffff);
+      os_version_full_ = base::StringPrintf(
+          "%s %d.%d.%d.%s%s",
+          os_name.c_str(),
+          os_version_major_,
+          os_version_minor_,
+          os_version_bugfix_,
+          os_version_build_.c_str(),
+          flags_string.empty() ? "" : (std::string(" (") + flags_string + ")")
+                                          .c_str());
     }
   }
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
 }
 
 CPUArchitecture SystemSnapshotWin::GetCPUArchitecture() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   return process_reader_->Is64Bit() ? kCPUArchitectureX86_64
@@ skipping 200 matching lines @@
   *standard_offset_seconds =
       (time_zone_information.Bias + time_zone_information.StandardBias) * -60;
   *daylight_offset_seconds =
       (time_zone_information.Bias + time_zone_information.DaylightBias) * -60;
   *standard_name = base::UTF16ToUTF8(time_zone_information.StandardName);
   *daylight_name = base::UTF16ToUTF8(time_zone_information.DaylightName);
 }
 
 }  // namespace internal
 }  // namespace crashpad