Immplement ConnectorsManager::GetReportingSettings().

This change also implements the ReportingServiceSettings class.

Bug: 1069068
Change-Id: I2c045380180aec65ff99d0b9f8d19d5e7928aae1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2210875
Commit-Queue: Roger Tawa <rogerta@chromium.org>
Reviewed-by: Dominique Fauteux-Chapleau <domfc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#770816}

chrome/browser/BUILD.gn

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

chrome/browser/enterprise/connectors/analysis_service_settings.h

@@ -6,7 +6,9 @@
 #define CHROME_BROWSER_ENTERPRISE_CONNECTORS_ANALYSIS_SERVICE_SETTINGS_H_
 
 #include <memory>
+#include <string>
 
+#include "base/optional.h"
 #include "base/values.h"
 #include "chrome/browser/enterprise/connectors/common.h"
 #include "components/url_matcher/url_matcher.h"

chrome/browser/enterprise/connectors/analysis_service_settings_unittest.cc

@@ -141,7 +141,6 @@ class AnalysisServiceSettingsTest : public testing::TestWithParam<TestParam> {
 };
 
 TEST_P(AnalysisServiceSettingsTest, Test) {
-  // auto value = base::Value::AsDictionaryValue(base::Value(pref_value()));
   auto settings = base::JSONReader::Read(settings_value(),
                                          base::JSON_ALLOW_TRAILING_COMMAS);
   ASSERT_TRUE(settings.has_value());

chrome/browser/enterprise/connectors/common.cc

@@ -28,4 +28,11 @@ const char* ConnectorPref(AnalysisConnector connector) {
   }
 }
 
+const char* ConnectorPref(ReportingConnector connector) {
+  switch (connector) {
+    case ReportingConnector::SECURITY_EVENT:
+      return kOnSecurityEventPref;
+  }
+}
+
 }  // namespace enterprise_connectors

chrome/browser/enterprise/connectors/common.h

@@ -7,7 +7,6 @@
 
 #include <set>
 #include <string>
-#include <vector>
 
 #include "url/gurl.h"
 
@@ -66,11 +65,12 @@ struct ReportingSettings {
   ReportingSettings& operator=(ReportingSettings&&);
   ~ReportingSettings();
 
-  std::vector<GURL> reporting_urls;
+  GURL reporting_url;
 };
 
-// Returns the pref path corresponding to an analysis connector.
+// Returns the pref path corresponding to a connector.
 const char* ConnectorPref(AnalysisConnector connector);
+const char* ConnectorPref(ReportingConnector connector);
 
 }  // namespace enterprise_connectors
 

chrome/browser/enterprise/connectors/connectors_manager.cc

@@ -71,13 +71,33 @@ bool ConnectorsManager::IsConnectorEnabled(AnalysisConnector connector) {
   if (!base::FeatureList::IsEnabled(kEnterpriseConnectorsEnabled))
     return false;
 
-  if (connector_settings_.count(connector) == 1)
+  if (analysis_connector_settings_.count(connector) == 1)
     return true;
 
   const char* pref = ConnectorPref(connector);
   return pref && g_browser_process->local_state()->HasPrefPath(pref);
 }
 
+bool ConnectorsManager::IsConnectorEnabled(ReportingConnector connector) {
+  if (!base::FeatureList::IsEnabled(kEnterpriseConnectorsEnabled))
+    return false;
+
+  if (reporting_connector_settings_.count(connector) == 1)
+    return true;
+
+  const char* pref = ConnectorPref(connector);
+  return pref && g_browser_process->local_state()->HasPrefPath(pref);
+}
+
+base::Optional<ReportingSettings> ConnectorsManager::GetReportingSettings(
+    ReportingConnector connector) {
+  // Prioritize new Connector policies over legacy ones.
+  if (IsConnectorEnabled(connector))
+    return GetReportingSettingsFromConnectorPolicy(connector);
+
+  return GetReportingSettingsFromLegacyPolicies(connector);
+}
+
 base::Optional<AnalysisSettings> ConnectorsManager::GetAnalysisSettings(
     const GURL& url,
     AnalysisConnector connector) {
@@ -92,21 +112,22 @@ base::Optional<AnalysisSettings>
 ConnectorsManager::GetAnalysisSettingsFromConnectorPolicy(
     const GURL& url,
     AnalysisConnector connector) {
-  if (connector_settings_.count(connector) == 0)
-    CacheConnectorPolicy(connector);
+  if (analysis_connector_settings_.count(connector) == 0)
+    CacheAnalysisConnectorPolicy(connector);
 
   // If the connector is still not in memory, it means the pref is set to an
   // empty list or that it is not a list.
-  if (connector_settings_.count(connector) == 0)
+  if (analysis_connector_settings_.count(connector) == 0)
     return base::nullopt;
 
   // While multiple services can be set by the connector policies, only the
   // first one is considered for now.
-  return connector_settings_[connector][0].GetAnalysisSettings(url);
+  return analysis_connector_settings_[connector][0].GetAnalysisSettings(url);
 }
 
-void ConnectorsManager::CacheConnectorPolicy(AnalysisConnector connector) {
-  connector_settings_.erase(connector);
+void ConnectorsManager::CacheAnalysisConnectorPolicy(
+    AnalysisConnector connector) {
+  analysis_connector_settings_.erase(connector);
 
   // Connectors with non-existing policies should not reach this code.
   const char* pref = ConnectorPref(connector);
@@ -116,7 +137,23 @@ void ConnectorsManager::CacheConnectorPolicy(AnalysisConnector connector) {
       g_browser_process->local_state()->GetList(pref);
   if (policy_value && policy_value->is_list()) {
     for (const base::Value& service_settings : policy_value->GetList())
-      connector_settings_[connector].emplace_back(service_settings);
+      analysis_connector_settings_[connector].emplace_back(service_settings);
+  }
+}
+
+void ConnectorsManager::CacheReportingConnectorPolicy(
+    ReportingConnector connector) {
+  reporting_connector_settings_.erase(connector);
+
+  // Connectors with non-existing policies should not reach this code.
+  const char* pref = ConnectorPref(connector);
+  DCHECK(pref);
+
+  const base::ListValue* policy_value =
+      g_browser_process->local_state()->GetList(pref);
+  if (policy_value && policy_value->is_list()) {
+    for (const base::Value& service_settings : policy_value->GetList())
+      reporting_connector_settings_[connector].emplace_back(service_settings);
   }
 }
 
@@ -253,12 +290,35 @@ std::set<std::string> ConnectorsManager::MatchURLAgainstLegacyPolicies(
   return tags;
 }
 
+base::Optional<ReportingSettings>
+ConnectorsManager::GetReportingSettingsFromConnectorPolicy(
+    ReportingConnector connector) {
+  if (reporting_connector_settings_.count(connector) == 0)
+    CacheReportingConnectorPolicy(connector);
+
+  // If the connector is still not in memory, it means the pref is set to an
+  // empty list or that it is not a list.
+  if (reporting_connector_settings_.count(connector) == 0)
+    return base::nullopt;
+
+  // While multiple services can be set by the connector policies, only the
+  // first one is considered for now.
+  return reporting_connector_settings_[connector][0].GetReportingSettings();
+}
+
+base::Optional<ReportingSettings>
+ConnectorsManager::GetReportingSettingsFromLegacyPolicies(
+    ReportingConnector connector) const {
+  return ReportingSettings();
+}
+
 void ConnectorsManager::StartObservingPrefs() {
   pref_change_registrar_.Init(g_browser_process->local_state());
   if (base::FeatureList::IsEnabled(kEnterpriseConnectorsEnabled)) {
     StartObservingPref(AnalysisConnector::FILE_ATTACHED);
     StartObservingPref(AnalysisConnector::FILE_DOWNLOADED);
     StartObservingPref(AnalysisConnector::BULK_DATA_ENTRY);
+    StartObservingPref(ReportingConnector::SECURITY_EVENT);
   }
 }
 
@@ -267,14 +327,31 @@ void ConnectorsManager::StartObservingPref(AnalysisConnector connector) {
   DCHECK(pref);
   if (!pref_change_registrar_.IsObserved(pref)) {
     pref_change_registrar_.Add(
-        pref, base::BindRepeating(&ConnectorsManager::CacheConnectorPolicy,
-                                  base::Unretained(this), connector));
+        pref,
+        base::BindRepeating(&ConnectorsManager::CacheAnalysisConnectorPolicy,
+                            base::Unretained(this), connector));
+  }
+}
+
+void ConnectorsManager::StartObservingPref(ReportingConnector connector) {
+  const char* pref = ConnectorPref(connector);
+  DCHECK(pref);
+  if (!pref_change_registrar_.IsObserved(pref)) {
+    pref_change_registrar_.Add(
+        pref,
+        base::BindRepeating(&ConnectorsManager::CacheReportingConnectorPolicy,
+                            base::Unretained(this), connector));
   }
 }
 
 const ConnectorsManager::AnalysisConnectorsSettings&
 ConnectorsManager::GetAnalysisConnectorsSettingsForTesting() const {
-  return connector_settings_;
+  return analysis_connector_settings_;
+}
+
+const ConnectorsManager::ReportingConnectorsSettings&
+ConnectorsManager::GetReportingConnectorsSettingsForTesting() const {
+  return reporting_connector_settings_;
 }
 
 void ConnectorsManager::SetUpForTesting() {
@@ -283,7 +360,8 @@ void ConnectorsManager::SetUpForTesting() {
 
 void ConnectorsManager::TearDownForTesting() {
   pref_change_registrar_.RemoveAll();
-  connector_settings_.clear();
+  analysis_connector_settings_.clear();
+  reporting_connector_settings_.clear();
 }
 
 }  // namespace enterprise_connectors

chrome/browser/enterprise/connectors/connectors_manager.h

@@ -12,6 +12,7 @@
 #include "base/optional.h"
 #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 "components/prefs/pref_change_registrar.h"
 #include "url/gurl.h"
 
@@ -32,12 +33,20 @@ extern const base::Feature kEnterpriseConnectorsEnabled;
 // provide a simple interface to them.
 class ConnectorsManager {
  public:
-  // Map used to cache analysis connectors settings.
+  // Maps used to cache connectors settings.
   using AnalysisConnectorsSettings =
       std::map<AnalysisConnector, std::vector<AnalysisServiceSettings>>;
+  using ReportingConnectorsSettings =
+      std::map<ReportingConnector, std::vector<ReportingServiceSettings>>;
 
   static ConnectorsManager* GetInstance();
 
+  // Validates which settings should be applied to a reporting event
+  // against cached policies. This function will prioritize new connector
+  // policies over legacy ones if they are set.
+  base::Optional<ReportingSettings> GetReportingSettings(
+      ReportingConnector connector);
+
   // Validates which settings should be applied to an analysis connector event
   // against cached policies. This function will prioritize new connector
   // policies over legacy ones if they are set.
@@ -47,6 +56,7 @@ class ConnectorsManager {
 
   // Checks if the corresponding connector is enabled.
   bool IsConnectorEnabled(AnalysisConnector connector);
+  bool IsConnectorEnabled(ReportingConnector connector);
 
   bool DelayUntilVerdict(AnalysisConnector connector) const;
 
@@ -62,6 +72,8 @@ class ConnectorsManager {
   // Public testing functions.
   const AnalysisConnectorsSettings& GetAnalysisConnectorsSettingsForTesting()
       const;
+  const ReportingConnectorsSettings& GetReportingConnectorsSettingsForTesting()
+      const;
 
   // Helpers to reset the ConnectorManager instance across test since it's a
   // singleton that would otherwise persist its state.
@@ -84,12 +96,14 @@ class ConnectorsManager {
       AnalysisConnector connector);
 
   // Read and cache the policy corresponding to |connector|.
-  void CacheConnectorPolicy(AnalysisConnector connector);
+  void CacheAnalysisConnectorPolicy(AnalysisConnector connector);
+  void CacheReportingConnectorPolicy(ReportingConnector connector);
 
   // Sets up |pref_change_registrar_| if kEnterpriseConntorsEnabled is true.
   // Used by the constructor and SetUpForTesting.
   void StartObservingPrefs();
   void StartObservingPref(AnalysisConnector connector);
+  void StartObservingPref(ReportingConnector connector);
 
   // Private legacy functions.
   // These functions are used to interact with legacy policies and should stay
@@ -108,9 +122,20 @@ class ConnectorsManager {
   std::set<std::string> MatchURLAgainstLegacyPolicies(const GURL& url,
                                                       bool upload) const;
 
+  // Validates which settings should be applied to an analysis connector event
+  // against connector policies. Cache the policy value the first time this is
+  // called for every different connector.
+  base::Optional<ReportingSettings> GetReportingSettingsFromConnectorPolicy(
+      ReportingConnector connector);
+
+  // Returns reporting settings based on legacy policies.
+  base::Optional<ReportingSettings> GetReportingSettingsFromLegacyPolicies(
+      ReportingConnector connector) const;
+
   // Cached values of the connector policies. Updated when a connector is first
   // used or when a policy is updated.
-  AnalysisConnectorsSettings connector_settings_;
+  AnalysisConnectorsSettings analysis_connector_settings_;
+  ReportingConnectorsSettings reporting_connector_settings_;
 
   // Used to track changes of connector policies and propagate them in
   // |connector_settings_|.

chrome/browser/enterprise/connectors/connectors_manager_unittest.cc

@@ -35,6 +35,9 @@ constexpr AnalysisConnector kAllAnalysisConnectors[] = {
     AnalysisConnector::FILE_DOWNLOADED, AnalysisConnector::FILE_ATTACHED,
     AnalysisConnector::BULK_DATA_ENTRY};
 
+constexpr ReportingConnector kAllReportingConnectors[] = {
+    ReportingConnector::SECURITY_EVENT};
+
 constexpr safe_browsing::BlockLargeFileTransferValues
     kAllBlockLargeFilesPolicyValues[] = {
         safe_browsing::BlockLargeFileTransferValues::BLOCK_NONE,
@@ -74,7 +77,7 @@ constexpr safe_browsing::DelayDeliveryUntilVerdictValues
 
 constexpr char kEmptySettingsPref[] = "[]";
 
-constexpr char kNormalSettingsPref[] = R"([
+constexpr char kNormalAnalysisSettingsPref[] = R"([
   {
     "service_provider": "Google",
     "enable": [
@@ -92,6 +95,12 @@ constexpr char kNormalSettingsPref[] = R"([
   },
 ])";
 
+constexpr char kNormalReportingSettingsPref[] = R"([
+  {
+    "service_provider": "Google"
+  }
+])";
+
 constexpr char kDlpAndMalwareUrl[] = "https://foo.com";
 constexpr char kOnlyDlpUrl[] = "https://no.malware.com";
 constexpr char kOnlyMalwareUrl[] = "https://no.dlp.com";
@@ -123,6 +132,8 @@ class ConnectorsManagerTest : public testing::Test {
     ASSERT_EQ(settings.tags, expected_tags_);
   }
 
+  void ValidateSettings(const ReportingSettings& settings) {}
+
   class ScopedConnectorPref {
    public:
     ScopedConnectorPref(const char* pref, const char* pref_value)
@@ -425,8 +436,8 @@ class ConnectorsManagerConnectorPoliciesTest
 
   const char* pref() const { return ConnectorPref(connector()); }
 
-  void SetUpExpectedSettings(const char* pref) {
-    auto expected_settings = ExpectedSettings(pref, url());
+  void SetUpExpectedAnalysisSettings(const char* pref) {
+    auto expected_settings = ExpectedAnalysisSettings(pref, url());
     expect_settings_ = expected_settings.has_value();
     if (expected_settings.has_value()) {
       expected_tags_ = expected_settings.value().tags;
@@ -440,9 +451,14 @@ class ConnectorsManagerConnectorPoliciesTest
     }
   }
 
+  void SetUpExpectedReportingSettings(const char* pref) {
+    auto expected_settings = ExpectedReportingSettings(pref);
+    expect_settings_ = expected_settings.has_value();
+  }
+
  protected:
-  base::Optional<AnalysisSettings> ExpectedSettings(const char* pref,
-                                                    const char* url) {
+  base::Optional<AnalysisSettings> ExpectedAnalysisSettings(const char* pref,
+                                                            const char* url) {
     if (pref == kEmptySettingsPref || url == kNoTagsUrl)
       return base::nullopt;
 
@@ -463,6 +479,15 @@ class ConnectorsManagerConnectorPoliciesTest
     return settings;
   }
 
+  base::Optional<ReportingSettings> ExpectedReportingSettings(
+      const char* pref) {
+    if (pref == kEmptySettingsPref)
+      return base::nullopt;
+
+    ReportingSettings settings;
+    return settings;
+  }
+
   bool expect_settings_;
 };
 
@@ -470,8 +495,8 @@ TEST_P(ConnectorsManagerConnectorPoliciesTest, NormalPref) {
   ASSERT_TRUE(ConnectorsManager::GetInstance()
                   ->GetAnalysisConnectorsSettingsForTesting()
                   .empty());
-  ScopedConnectorPref scoped_pref(pref(), kNormalSettingsPref);
-  SetUpExpectedSettings(kNormalSettingsPref);
+  ScopedConnectorPref scoped_pref(pref(), kNormalAnalysisSettingsPref);
+  SetUpExpectedAnalysisSettings(kNormalAnalysisSettingsPref);
 
   // Verify that the expected settings are returned normally.
   auto settings_from_manager =
@@ -543,7 +568,7 @@ TEST_P(ConnectorsManagerAnalysisConnectorsTest, DynamicPolicies) {
   // Once the pref is updated, the settings should be cached, and analysis
   // settings can be obtained.
   {
-    ScopedConnectorPref scoped_pref(pref(), kNormalSettingsPref);
+    ScopedConnectorPref scoped_pref(pref(), kNormalAnalysisSettingsPref);
 
     const auto& cached_settings =
         manager->GetAnalysisConnectorsSettingsForTesting();
@@ -571,15 +596,15 @@ INSTANTIATE_TEST_CASE_P(ConnectorsManagerAnalysisConnectorsTest,
                         ConnectorsManagerAnalysisConnectorsTest,
                         testing::ValuesIn(kAllAnalysisConnectors));
 
-class ConnectorsManagerNoFeatureTest
+class ConnectorsManagerAnalysisNoFeatureTest
     : public ConnectorsManagerAnalysisConnectorsTest {
  public:
-  ConnectorsManagerNoFeatureTest()
+  ConnectorsManagerAnalysisNoFeatureTest()
       : ConnectorsManagerAnalysisConnectorsTest(false) {}
 };
 
-TEST_P(ConnectorsManagerNoFeatureTest, Test) {
-  ScopedConnectorPref scoped_pref(pref(), kNormalSettingsPref);
+TEST_P(ConnectorsManagerAnalysisNoFeatureTest, Test) {
+  ScopedConnectorPref scoped_pref(pref(), kNormalAnalysisSettingsPref);
 
   if (connector() == AnalysisConnector::FILE_DOWNLOADED)
     expected_tags_ = {"malware"};
@@ -601,7 +626,76 @@ TEST_P(ConnectorsManagerNoFeatureTest, Test) {
 }
 
 INSTANTIATE_TEST_CASE_P(,
-                        ConnectorsManagerNoFeatureTest,
+                        ConnectorsManagerAnalysisNoFeatureTest,
                         testing::ValuesIn(kAllAnalysisConnectors));
 
+class ConnectorsManagerReportingConnectorsTest
+    : public ConnectorsManagerTest,
+      public testing::WithParamInterface<ReportingConnector> {
+ public:
+  explicit ConnectorsManagerReportingConnectorsTest(bool enable = true) {
+    if (enable)
+      scoped_feature_list_.InitWithFeatures({kEnterpriseConnectorsEnabled}, {});
+  }
+
+  ReportingConnector connector() const { return GetParam(); }
+
+  const char* pref() const { return ConnectorPref(connector()); }
+};
+
+TEST_P(ConnectorsManagerReportingConnectorsTest, DynamicPolicies) {
+  // The cache is initially empty.
+  auto* manager = ConnectorsManager::GetInstance();
+  ASSERT_TRUE(manager->GetReportingConnectorsSettingsForTesting().empty());
+
+  // Once the pref is updated, the settings should be cached, and reporting
+  // settings can be obtained.
+  {
+    ScopedConnectorPref scoped_pref(pref(), kNormalReportingSettingsPref);
+
+    const auto& cached_settings =
+        manager->GetReportingConnectorsSettingsForTesting();
+    ASSERT_FALSE(cached_settings.empty());
+    ASSERT_EQ(1u, cached_settings.count(connector()));
+    ASSERT_EQ(1u, cached_settings.at(connector()).size());
+
+    auto settings =
+        cached_settings.at(connector()).at(0).GetReportingSettings();
+    ASSERT_TRUE(settings.has_value());
+    ValidateSettings(settings.value());
+  }
+
+  // The cache should be empty again after the pref is reset.
+  ASSERT_TRUE(manager->GetAnalysisConnectorsSettingsForTesting().empty());
+}
+
+INSTANTIATE_TEST_CASE_P(ConnectorsManagerReportingConnectorsTest,
+                        ConnectorsManagerReportingConnectorsTest,
+                        testing::ValuesIn(kAllReportingConnectors));
+
+class ConnectorsManagerReportingNoFeatureTest
+    : public ConnectorsManagerReportingConnectorsTest {
+ public:
+  ConnectorsManagerReportingNoFeatureTest()
+      : ConnectorsManagerReportingConnectorsTest(false) {}
+};
+
+TEST_P(ConnectorsManagerReportingNoFeatureTest, Test) {
+  ScopedConnectorPref scoped_pref(pref(), kNormalReportingSettingsPref);
+
+  auto settings =
+      ConnectorsManager::GetInstance()->GetReportingSettings(connector());
+  ASSERT_TRUE(settings.has_value());
+  ValidateSettings(settings.value());
+
+  // No cached settings imply the connector value was never read.
+  ASSERT_TRUE(ConnectorsManager::GetInstance()
+                  ->GetAnalysisConnectorsSettingsForTesting()
+                  .empty());
+}
+
+INSTANTIATE_TEST_CASE_P(,
+                        ConnectorsManagerReportingNoFeatureTest,
+                        testing::ValuesIn(kAllReportingConnectors));
+
 }  // namespace enterprise_connectors

chrome/browser/enterprise/connectors/reporting_service_settings.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/reporting_service_settings.h"
+
+#include "components/policy/core/browser/url_util.h"
+
+namespace enterprise_connectors {
+
+ReportingServiceSettings::ReportingServiceSettings(
+    const base::Value& settings_value) {
+  if (!settings_value.is_dict())
+    return;
+
+  // The service provider identifier should always be there.
+  const std::string* service_provider =
+      settings_value.FindStringKey(kKeyServiceProvider);
+  if (service_provider)
+    service_provider_ = *service_provider;
+}
+
+base::Optional<ReportingSettings>
+ReportingServiceSettings::GetReportingSettings() const {
+  if (!IsValid())
+    return base::nullopt;
+
+  ReportingSettings settings;
+
+  // TODO(rogerta): once service provider configs are implemented set the
+  // reporting URL field.
+
+  return settings;
+}
+
+bool ReportingServiceSettings::IsValid() const {
+  // The settings are valid only if provider was given.
+  return !service_provider_.empty();
+}
+
+ReportingServiceSettings::ReportingServiceSettings(ReportingServiceSettings&&) =
+    default;
+ReportingServiceSettings::~ReportingServiceSettings() = default;
+
+}  // namespace enterprise_connectors

chrome/browser/enterprise/connectors/reporting_service_settings.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_REPORTING_SERVICE_SETTINGS_H_
+#define CHROME_BROWSER_ENTERPRISE_CONNECTORS_REPORTING_SERVICE_SETTINGS_H_
+
+#include <string>
+
+#include "base/optional.h"
+#include "base/values.h"
+#include "chrome/browser/enterprise/connectors/common.h"
+
+namespace enterprise_connectors {
+
+// The settings for a report service obtained from a connector policy.
+class ReportingServiceSettings {
+ public:
+  explicit ReportingServiceSettings(const base::Value& settings_value);
+  ReportingServiceSettings(ReportingServiceSettings&&);
+  ~ReportingServiceSettings();
+
+  // Get the settings to apply to a specific report. base::nullopt implies no
+  // report should take place.
+  base::Optional<ReportingSettings> GetReportingSettings() const;
+
+ private:
+  // Returns true if the settings were initialized correctly. If this returns
+  // false, then GetAnalysisSettings will always return base::nullopt.
+  bool IsValid() const;
+
+  // The service provider's identifier. This is unique amongst providers.
+  std::string service_provider_;
+};
+
+}  // namespace enterprise_connectors
+
+#endif  // CHROME_BROWSER_ENTERPRISE_CONNECTORS_REPORTING_SERVICE_SETTINGS_H_

chrome/browser/enterprise/connectors/reporting_service_settings_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/reporting_service_settings.h"
+#include "base/json/json_reader.h"
+#include "base/no_destructor.h"
+#include "content/public/test/browser_task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace enterprise_connectors {
+
+namespace {
+
+struct TestParam {
+  TestParam(const char* settings_value, ReportingSettings* expected_settings)
+      : settings_value(settings_value), expected_settings(expected_settings) {}
+
+  const char* settings_value;
+  ReportingSettings* expected_settings;
+};
+
+constexpr char kNormalSettings[] = R"({ "service_provider": "Google" })";
+
+constexpr char kNoProviderSettings[] = "{}";
+
+ReportingSettings* NormalSettings() {
+  static base::NoDestructor<ReportingSettings> settings;
+  return settings.get();
+}
+
+ReportingSettings* NoSettings() {
+  return nullptr;
+}
+
+}  // namespace
+
+class ReportingServiceSettingsTest : public testing::TestWithParam<TestParam> {
+ public:
+  const char* settings_value() const { return GetParam().settings_value; }
+  ReportingSettings* expected_settings() const {
+    return GetParam().expected_settings;
+  }
+
+ private:
+  content::BrowserTaskEnvironment task_environment_;
+};
+
+TEST_P(ReportingServiceSettingsTest, Test) {
+  auto settings = base::JSONReader::Read(settings_value(),
+                                         base::JSON_ALLOW_TRAILING_COMMAS);
+  ASSERT_TRUE(settings.has_value());
+
+  ReportingServiceSettings service_settings(settings.value());
+
+  auto reporting_settings = service_settings.GetReportingSettings();
+  ASSERT_EQ((expected_settings() != nullptr), reporting_settings.has_value());
+}
+
+INSTANTIATE_TEST_CASE_P(
+    ,
+    ReportingServiceSettingsTest,
+    testing::Values(TestParam(kNormalSettings, NormalSettings()),
+                    TestParam(kNoProviderSettings, NoSettings())));
+
+}  // namespace enterprise_connectors

chrome/test/BUILD.gn

@@ -3932,6 +3932,7 @@ test("unit_tests") {
       "../browser/enterprise/connectors/analysis_service_settings_unittest.cc",
       "../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/reporting/browser_report_generator_unittest.cc",
       "../browser/enterprise/reporting/extension_info_unittest.cc",
       "../browser/enterprise/reporting/notification/extension_request_notification_unittest.cc",