Create base implementation of ServiceProviderConfig

This only parses fields that will affect the behaviour of the analysis
and reporting. Other fields like "display_name" or "version" can be
parsed once they are needed in a follow-up CL.

Bug: 1069049, 1069048
Change-Id: I486c3b8c8c51a676423fab23a3c5977d3ca25d1f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2218763
Commit-Queue: Dominique Fauteux-Chapleau <domfc@chromium.org>
Reviewed-by: Roger Tawa <rogerta@chromium.org>
Cr-Commit-Position: refs/heads/master@{#772760}

chrome/browser/BUILD.gn

@@ -3239,6 +3239,8 @@ static_library("browser") {
       "enterprise/connectors/enterprise_connectors_policy_handler.h",
       "enterprise/connectors/reporting_service_settings.cc",
       "enterprise/connectors/reporting_service_settings.h",
+      "enterprise/connectors/service_provider_config.cc",
+      "enterprise/connectors/service_provider_config.h",
       "enterprise/reporting/browser_report_generator.cc",
       "enterprise/reporting/browser_report_generator.h",
       "enterprise/reporting/extension_info.cc",

chrome/browser/enterprise/connectors/connectors_manager.h

@@ -13,6 +13,7 @@
 #include "chrome/browser/enterprise/connectors/analysis_service_settings.h"
 #include "chrome/browser/enterprise/connectors/common.h"
 #include "chrome/browser/enterprise/connectors/reporting_service_settings.h"
+#include "chrome/browser/enterprise/connectors/service_provider_config.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "url/gurl.h"
 
@@ -133,6 +134,11 @@ class ConnectorsManager {
   base::Optional<ReportingSettings> GetReportingSettingsFromLegacyPolicies(
       ReportingConnector connector) const;
 
+  // Cached values of available service providers. This information validates
+  // the Connector policies have a valid provider.
+  ServiceProviderConfig service_provider_config_ =
+      ServiceProviderConfig(kServiceProviderConfig);
+
   // Cached values of the connector policies. Updated when a connector is first
   // used or when a policy is updated.
   AnalysisConnectorsSettings analysis_connector_settings_;

chrome/browser/enterprise/connectors/service_provider_config.cc

+// Copyright 2020 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/enterprise/connectors/service_provider_config.h"
+#include "base/json/json_reader.h"
+
+namespace enterprise_connectors {
+
+namespace {
+
+// Keys used to read service provider config values.
+constexpr char kKeyVersion[] = "version";
+constexpr char kKeyServiceProviders[] = "service_providers";
+constexpr char kKeyName[] = "name";
+constexpr char kKeyAnalysis[] = "analysis";
+constexpr char kKeyReporting[] = "reporting";
+constexpr char kKeyUrl[] = "url";
+constexpr char kKeySupportedTags[] = "supported_tags";
+constexpr char kKeyMimeTypes[] = "mime_types";
+constexpr char kKeyMaxFileSize[] = "max_file_size";
+
+// There is currently only 1 version of this config, so we can just treat it as
+// any other value in the JSON with its own key. Once that is no longer the
+// case extra code should be added to decide on the correct version to read.
+constexpr char kKeyV1[] = "1";
+
+}  // namespace
+
+ServiceProviderConfig::ServiceProviderConfig(const std::string& config) {
+  auto config_value = base::JSONReader::Read(config);
+  if (!config_value.has_value() || !config_value.value().is_dict())
+    return;
+
+  const base::Value* service_providers =
+      config_value.value().FindListKey(kKeyServiceProviders);
+  if (!service_providers)
+    return;
+
+  for (const base::Value& service_provider_value :
+       service_providers->GetList()) {
+    const std::string* name = service_provider_value.FindStringKey(kKeyName);
+    if (name)
+      service_providers_.emplace(*name, service_provider_value);
+  }
+}
+
+const ServiceProviderConfig::ServiceProvider*
+ServiceProviderConfig::GetServiceProvider(
+    const std::string& service_provider) const {
+  if (service_providers_.count(service_provider) == 0)
+    return nullptr;
+  return &service_providers_.at(service_provider);
+}
+
+ServiceProviderConfig::ServiceProviderConfig(ServiceProviderConfig&&) = default;
+ServiceProviderConfig::~ServiceProviderConfig() = default;
+
+ServiceProviderConfig::ServiceProvider::ServiceProvider(
+    const base::Value& config) {
+  if (!config.is_dict())
+    return;
+
+  const base::Value* versions = config.FindDictKey(kKeyVersion);
+  if (!versions || !versions->is_dict())
+    return;
+
+  const base::Value* version_1 = versions->FindDictKey(kKeyV1);
+  if (!version_1 || !version_1->is_dict())
+    return;
+
+  const base::Value* analysis = version_1->FindDictKey(kKeyAnalysis);
+  if (analysis && analysis->is_dict()) {
+    const std::string* analysis_url = analysis->FindStringKey(kKeyUrl);
+    if (analysis_url)
+      analysis_url_ = *analysis_url;
+
+    const base::Value* supported_tags =
+        analysis->FindListKey(kKeySupportedTags);
+    if (supported_tags) {
+      for (const base::Value& tag : supported_tags->GetList()) {
+        if (!tag.is_dict())
+          continue;
+
+        const std::string* name = tag.FindStringKey(kKeyName);
+        if (name)
+          analysis_tags_.emplace(*name, tag);
+      }
+    }
+  }
+
+  const base::Value* reporting = version_1->FindDictKey(kKeyReporting);
+  if (reporting) {
+    const std::string* reporting_url = reporting->FindStringKey(kKeyUrl);
+    if (reporting_url)
+      reporting_url_ = *reporting_url;
+  }
+}
+
+ServiceProviderConfig::ServiceProvider::ServiceProvider(ServiceProvider&&) =
+    default;
+ServiceProviderConfig::ServiceProvider::~ServiceProvider() = default;
+
+ServiceProviderConfig::ServiceProvider::Tag::Tag(const base::Value& tag_value) {
+  if (!tag_value.is_dict())
+    return;
+
+  const base::Value* mime_types = tag_value.FindListKey(kKeyMimeTypes);
+  if (mime_types) {
+    for (const base::Value& mime_type : mime_types->GetList()) {
+      if (!mime_type.is_string())
+        continue;
+
+      mime_types_.push_back(mime_type.GetString());
+    }
+  }
+
+  max_file_size_ = tag_value.FindIntKey(kKeyMaxFileSize).value_or(-1);
+}
+
+ServiceProviderConfig::ServiceProvider::Tag::Tag(Tag&&) = default;
+ServiceProviderConfig::ServiceProvider::Tag::~Tag() = default;
+
+}  // namespace enterprise_connectors

chrome/browser/enterprise/connectors/service_provider_config.h

+// Copyright 2020 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.
+
+#ifndef CHROME_BROWSER_ENTERPRISE_CONNECTORS_SERVICE_PROVIDER_CONFIG_H_
+#define CHROME_BROWSER_ENTERPRISE_CONNECTORS_SERVICE_PROVIDER_CONFIG_H_
+
+#include <map>
+#include <vector>
+
+#include "base/values.h"
+
+namespace enterprise_connectors {
+
+// The configuration used to describe available service providers for
+// Connectors. This configs holds the tags to use, supported mime types for each
+// tag, URLs to use for analysis/reporting and other information for each
+// service provider.
+class ServiceProviderConfig {
+ public:
+  // Configurations specific to a single service provider.
+  class ServiceProvider {
+   public:
+    class Tag {
+     public:
+      explicit Tag(const base::Value& tag_value);
+      Tag(Tag&&);
+      ~Tag();
+
+      const std::vector<std::string>& mime_types() const { return mime_types_; }
+      size_t max_file_size() const { return max_file_size_; }
+
+     private:
+      std::vector<std::string> mime_types_;
+      size_t max_file_size_;
+    };
+
+    explicit ServiceProvider(const base::Value& config);
+    ServiceProvider(ServiceProvider&&);
+    ~ServiceProvider();
+
+    const std::string& analysis_url() const { return analysis_url_; }
+    const std::map<std::string, Tag>& analysis_tags() const {
+      return analysis_tags_;
+    }
+    const std::string& reporting_url() const { return reporting_url_; }
+
+   private:
+    std::string analysis_url_;
+    std::map<std::string, Tag> analysis_tags_;
+    std::string reporting_url_;
+  };
+
+  explicit ServiceProviderConfig(const std::string& config);
+  ServiceProviderConfig(ServiceProviderConfig&&);
+  ~ServiceProviderConfig();
+
+  // Returns the matching service provider, or nullptr if it can't be found.
+  const ServiceProvider* GetServiceProvider(
+      const std::string& service_provider) const;
+
+ private:
+  // Providers known to this config. The key is the service provider name used
+  // by the Connector policies.
+  std::map<std::string, ServiceProvider> service_providers_;
+};
+
+}  // namespace enterprise_connectors
+
+#endif  // CHROME_BROWSER_ENTERPRISE_CONNECTORS_SERVICE_PROVIDER_CONFIG_H_

chrome/browser/enterprise/connectors/service_provider_config_unittest.cc

+// Copyright 2020 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/enterprise/connectors/service_provider_config.h"
+
+#include "base/json/json_reader.h"
+#include "chrome/browser/enterprise/connectors/connectors_manager.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace enterprise_connectors {
+
+namespace {
+
+constexpr size_t kMaxFileSize = 50 * 1024 * 1024;
+
+std::vector<std::string> MalwareMimeTypes() {
+  return {"application/vnd.microsoft.portable-executable",
+          "application/vnd.rar", "application/x-msdos-program",
+          "application/zip"};
+}
+
+std::vector<std::string> DlpMimeTypes() {
+  return {
+      "application/gzip",
+      "application/msword",
+      "application/pdf",
+      "application/postscript",
+      "application/rtf",
+      "application/vnd.google-apps.document.internal",
+      "application/vnd.google-apps.spreadsheet.internal",
+      "application/vnd.ms-cab-compressed",
+      "application/vnd.ms-excel",
+      "application/vnd.ms-powerpoint",
+      "application/vnd.ms-xpsdocument",
+      "application/vnd.oasis.opendocument.text",
+      "application/"
+      "vnd.openxmlformats-officedocument.presentationml.presentation",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+      "application/vnd.ms-excel.sheet.macroenabled.12",
+      "application/vnd.ms-excel.template.macroenabled.12",
+      "application/vnd.ms-word.document.macroenabled.12",
+      "application/vnd.ms-word.template.macroenabled.12",
+      "application/vnd.rar",
+      "application/vnd.wordperfect",
+      "application/x-7z-compressed",
+      "application/x-bzip",
+      "application/x-bzip2",
+      "application/x-tar",
+      "application/zip",
+      "text/csv",
+      "text/plain"};
+}
+
+}  // namespace
+
+TEST(ServiceProviderConfigTest, CurrentConfig) {
+  // Since this class should only be initialized with 1 value for now, all
+  // that's needed is a single test on that value checking every field.
+  ServiceProviderConfig config(kServiceProviderConfig);
+
+  const ServiceProviderConfig::ServiceProvider* service_provider =
+      config.GetServiceProvider("google");
+  ASSERT_NE(nullptr, service_provider);
+
+  ASSERT_EQ("https://safebrowsing.google.com/safebrowsing/uploads/scan",
+            service_provider->analysis_url());
+  ASSERT_TRUE(GURL(service_provider->analysis_url()).is_valid());
+  ASSERT_EQ("https://chromereporting-pa.googleapis.com/v1/events",
+            service_provider->reporting_url());
+  ASSERT_TRUE(GURL(service_provider->reporting_url()).is_valid());
+
+  ASSERT_EQ(2u, service_provider->analysis_tags().size());
+  ASSERT_EQ(1u, service_provider->analysis_tags().count("dlp"));
+  ASSERT_EQ(1u, service_provider->analysis_tags().count("malware"));
+
+  ASSERT_EQ(kMaxFileSize,
+            service_provider->analysis_tags().at("dlp").max_file_size());
+  ASSERT_EQ(kMaxFileSize,
+            service_provider->analysis_tags().at("malware").max_file_size());
+
+  ASSERT_EQ(DlpMimeTypes(),
+            service_provider->analysis_tags().at("dlp").mime_types());
+  ASSERT_EQ(MalwareMimeTypes(),
+            service_provider->analysis_tags().at("malware").mime_types());
+}
+
+}  // namespace enterprise_connectors

chrome/test/BUILD.gn

@@ -3940,6 +3940,7 @@ test("unit_tests") {
       "../browser/enterprise/connectors/connectors_manager_unittest.cc",
       "../browser/enterprise/connectors/enterprise_connectors_policy_handler_unittest.cc",
       "../browser/enterprise/connectors/reporting_service_settings_unittest.cc",
+      "../browser/enterprise/connectors/service_provider_config_unittest.cc",
       "../browser/enterprise/reporting/browser_report_generator_unittest.cc",
       "../browser/enterprise/reporting/extension_info_unittest.cc",
       "../browser/enterprise/reporting/notification/extension_request_notification_unittest.cc",