Merge M56:Trim AV names.

chrome/browser/metrics/antivirus_metrics_provider_win.cc

 // Copyright 2016 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 "chrome/browser/metrics/antivirus_metrics_provider_win.h"
 
 #include <iwscapi.h>
 #include <stddef.h>
 #include <wbemidl.h>
 #include <windows.h>
 #include <wscapi.h>
 
+#include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/file_version_info_win.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/version.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
 #include "base/win/windows_version.h"
@@ skipping 16 matching lines @@
   uint8_t definition_state : 4;  // 1 = Out of date, 0 = Up to date.
   uint8_t unknown_2 : 4;
   uint8_t security_state : 4;  //  0 = Inactive, 1 = Active, 2 = Snoozed.
   uint8_t security_provider;   // matches WSC_SECURITY_PROVIDER in wscapi.h.
   uint8_t unknown_3;
 };
 #pragma pack(pop)
 
 static_assert(sizeof(PRODUCT_STATE) == 4, "Wrong packing!");
 
+// Filter any part of a product string that looks like it might be a version
+// number. Returns true if the part should be removed from the product name.
+bool ShouldFilterPart(const std::string& str) {
+  // Special case for "360" (used by Norton), "365" (used by Kaspersky) and
+  // "NOD32" (used by ESET).
+  if (str == "365" || str == "360" || str == "NOD32")
+    return false;
+  for (const auto ch : str) {
+    if (isdigit(ch))
+      return true;
+  }
+  return false;
+}
+
 bool ShouldReportFullNames() {
   // The expectation is that this will be disabled for the majority of users,
   // but this allows a small group to be enabled on other channels if there are
   // a large percentage of hashes collected on these channels that are not
   // resolved to names previously collected on Canary channel.
   bool enabled = base::FeatureList::IsEnabled(
       AntiVirusMetricsProvider::kReportNamesFeature);
 
   if (chrome::GetChannel() == version_info::Channel::CANARY)
     return true;
@@ skipping 108 matching lines @@
 
   MaybeAddUnregisteredAntiVirusProducts(&av_products);
 
   UMA_HISTOGRAM_ENUMERATION("UMA.AntiVirusMetricsProvider.Result",
                             result,
                             RESULT_COUNT);
 
   return av_products;
 }
 
+std::string AntiVirusMetricsProvider::TrimVersionOfAvProductName(
+    const std::string& av_product) {
+  auto av_product_parts = base::SplitString(
+      av_product, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+
+  if (av_product_parts.size() >= 2) {
+    // Skipping first element, remove any that look like version numbers.
+    av_product_parts.erase(
+        std::remove_if(av_product_parts.begin() + 1, av_product_parts.end(),
+                       ShouldFilterPart),
+        av_product_parts.end());
+  }
+
+  return base::JoinString(av_product_parts, " ");
+}
+
 void AntiVirusMetricsProvider::GotAntiVirusProducts(
     const base::Closure& done_callback,
     const std::vector<AvProduct>& av_products) {
   DCHECK(thread_checker_.CalledOnValidThread());
   av_products_ = av_products;
   done_callback.Run();
 }
 
 // static
 AntiVirusMetricsProvider::ResultCode
@@ skipping 59 matching lines @@
       return RESULT_PRODUCT_STATE_INVALID;
 
     av_product.set_product_state(
         static_cast<metrics::SystemProfileProto::AntiVirusState>(
             product_state));
 
     base::win::ScopedBstr product_name;
     result = product->get_ProductName(product_name.Receive());
     if (FAILED(result))
       return RESULT_FAILED_TO_GET_PRODUCT_NAME;
-    std::string name =
-        base::SysWideToUTF8(std::wstring(product_name, product_name.Length()));
+    std::string name = TrimVersionOfAvProductName(
+        base::SysWideToUTF8(std::wstring(product_name, product_name.Length())));
     product_name.Release();
     if (ShouldReportFullNames())
       av_product.set_product_name(name);
     av_product.set_product_name_hash(metrics::HashName(name));
 
     base::win::ScopedBstr remediation_path;
     result = product->get_RemediationPath(remediation_path.Receive());
     if (FAILED(result))
       return RESULT_FAILED_TO_GET_REMEDIATION_PATH;
     std::wstring path_str(remediation_path, remediation_path.Length());
@@ skipping 109 matching lines @@
     }
 
     base::win::ScopedVariant display_name;
     hr = class_object->Get(L"displayName", 0, display_name.Receive(), 0, 0);
 
     if (FAILED(hr) || display_name.type() != VT_BSTR)
       return RESULT_FAILED_TO_GET_PRODUCT_NAME;
 
     // Owned by ScopedVariant.
     BSTR temp_bstr = V_BSTR(display_name.ptr());
-    std::string name(base::SysWideToUTF8(
+    std::string name = TrimVersionOfAvProductName(base::SysWideToUTF8(
         std::wstring(temp_bstr, ::SysStringLen(temp_bstr))));
 
     if (ShouldReportFullNames())
       av_product.set_product_name(name);
     av_product.set_product_name_hash(metrics::HashName(name));
 
     base::win::ScopedVariant exe_path;
     hr = class_object->Get(L"pathToSignedProductExe", 0, exe_path.Receive(), 0,
                            0);
 
@@ skipping 57 matching lines @@
   std::string product_name("Trusteer Endpoint Protection");
   if (ShouldReportFullNames()) {
     av_product.set_product_name(product_name);
     av_product.set_product_version(product_version);
   }
   av_product.set_product_name_hash(metrics::HashName(product_name));
   av_product.set_product_version_hash(metrics::HashName(product_version));
 
   products->push_back(av_product);
 }