Implement Enterprise Reporting policies

Makes the Enterprise Reporting policies from a previous CL [1]
effective. They now really control what gets reported and what doesn't,
instead of just serving as placeholders.

[1] https://chromium-review.googlesource.com/1187066

Bug: 877120
Change-Id: I5098e55ce337fd3e8a5a56fc98bdc08d105b6a86
Reviewed-on: https://chromium-review.googlesource.com/1190542
Commit-Queue: Nicolas Ouellet-Payeur <nicolaso@chromium.org>
Reviewed-by: Owen Min <zmin@chromium.org>
Reviewed-by: Julian Pastarmov <pastarmovj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#586797}

chrome/browser/extensions/api/enterprise_reporting_private/chrome_desktop_report_request_helper.cc

@@ -12,6 +12,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/api/enterprise_reporting_private/prefs.h"
 #include "chrome/browser/policy/chrome_browser_policy_connector.h"
 #include "chrome/browser/policy/machine_level_user_cloud_policy_controller.h"
 #include "chrome/browser/policy/policy_conversions.h"
@@ -77,42 +78,53 @@ int64_t GetMachineLevelUserCloudPolicyFetchTimestamp() {
 
 void AppendAdditionalBrowserInformation(em::ChromeDesktopReportRequest* request,
                                         Profile* profile) {
-  // Set Chrome version number
-  request->mutable_browser_report()->set_browser_version(
-      version_info::GetVersionNumber());
-  // Set Chrome channel
-  request->mutable_browser_report()->set_channel(
-      policy::ConvertToProtoChannel(chrome::GetChannel()));
-  // Set Chrome executable path
-  request->mutable_browser_report()->set_executable_path(GetChromePath());
+  const PrefService* prefs = profile->GetPrefs();
+
+  if (prefs->GetBoolean(enterprise_reporting::kReportVersionData)) {
+    // Set Chrome version number
+    request->mutable_browser_report()->set_browser_version(
+        version_info::GetVersionNumber());
+    // Set Chrome channel
+    request->mutable_browser_report()->set_channel(
+        policy::ConvertToProtoChannel(chrome::GetChannel()));
+  }
 
   // Add a new profile report if extension doesn't report any profile.
   if (request->browser_report().chrome_user_profile_reports_size() == 0)
     request->mutable_browser_report()->add_chrome_user_profile_reports();
 
   DCHECK_EQ(1, request->browser_report().chrome_user_profile_reports_size());
-  // Set profile ID for the first profile.
-  request->mutable_browser_report()
-      ->mutable_chrome_user_profile_reports(0)
-      ->set_id(GetProfileId(profile));
-
-  // Set policy data of the first profile. Extension will report this data in
-  // the future.
-  request->mutable_browser_report()
-      ->mutable_chrome_user_profile_reports(0)
-      ->set_policy_data(policy::GetAllPolicyValuesAsJSON(profile, true, false));
-
-  int64_t timestamp = GetMachineLevelUserCloudPolicyFetchTimestamp();
-  if (timestamp > 0) {
+
+  if (prefs->GetBoolean(enterprise_reporting::kReportUserIDData)) {
+    // Set Chrome executable path
+    request->mutable_browser_report()->set_executable_path(GetChromePath());
+
+    // Set profile ID for the first profile.
+    request->mutable_browser_report()
+        ->mutable_chrome_user_profile_reports(0)
+        ->set_id(GetProfileId(profile));
+
+    // Set the profile name
     request->mutable_browser_report()
         ->mutable_chrome_user_profile_reports(0)
-        ->set_policy_fetched_timestamp(timestamp);
+        ->set_name(prefs->GetString(prefs::kProfileName));
   }
 
-  // Set the profile name
-  request->mutable_browser_report()
-      ->mutable_chrome_user_profile_reports(0)
-      ->set_name(profile->GetPrefs()->GetString(prefs::kProfileName));
+  if (prefs->GetBoolean(enterprise_reporting::kReportPolicyData)) {
+    // Set policy data of the first profile. Extension will report this data in
+    // the future.
+    request->mutable_browser_report()
+        ->mutable_chrome_user_profile_reports(0)
+        ->set_policy_data(
+            policy::GetAllPolicyValuesAsJSON(profile, true, false));
+
+    int64_t timestamp = GetMachineLevelUserCloudPolicyFetchTimestamp();
+    if (timestamp > 0) {
+      request->mutable_browser_report()
+          ->mutable_chrome_user_profile_reports(0)
+          ->set_policy_fetched_timestamp(timestamp);
+    }
+  }
 }
 
 bool UpdateJSONEncodedStringEntry(const base::Value& dict_value,
@@ -135,37 +147,49 @@ bool UpdateJSONEncodedStringEntry(const base::Value& dict_value,
   return true;
 }
 
-void AppendPlatformInformation(em::ChromeDesktopReportRequest* request) {
-  const char kComputerName[] = "computername";
-  const char kUsername[] = "username";
-
-  base::Value os_info = base::Value(base::Value::Type::DICTIONARY);
-  os_info.SetKey(kOS, base::Value(policy::GetOSPlatform()));
-  os_info.SetKey(kOSVersion, base::Value(policy::GetOSVersion()));
-  os_info.SetKey(kOSArch, base::Value(policy::GetOSArchitecture()));
-  base::JSONWriter::Write(os_info, request->mutable_os_info());
+void AppendPlatformInformation(em::ChromeDesktopReportRequest* request,
+                               const PrefService* prefs) {
+  if (prefs->GetBoolean(enterprise_reporting::kReportVersionData)) {
+    base::Value os_info = base::Value(base::Value::Type::DICTIONARY);
+    os_info.SetKey(kOS, base::Value(policy::GetOSPlatform()));
+    os_info.SetKey(kOSVersion, base::Value(policy::GetOSVersion()));
+    os_info.SetKey(kOSArch, base::Value(policy::GetOSArchitecture()));
+    base::JSONWriter::Write(os_info, request->mutable_os_info());
+  }
 
-  base::Value machine_name = base::Value(base::Value::Type::DICTIONARY);
-  machine_name.SetKey(kComputerName, base::Value(policy::GetMachineName()));
-  base::JSONWriter::Write(machine_name, request->mutable_machine_name());
+  if (prefs->GetBoolean(enterprise_reporting::kReportMachineIDData)) {
+    const char kComputerName[] = "computername";
+    base::Value machine_name = base::Value(base::Value::Type::DICTIONARY);
+    machine_name.SetKey(kComputerName, base::Value(policy::GetMachineName()));
+    base::JSONWriter::Write(machine_name, request->mutable_machine_name());
+  }
 
-  base::Value os_user = base::Value(base::Value::Type::DICTIONARY);
-  os_user.SetKey(kUsername, base::Value(policy::GetOSUsername()));
-  base::JSONWriter::Write(os_user, request->mutable_os_user());
+  if (prefs->GetBoolean(enterprise_reporting::kReportUserIDData)) {
+    const char kUsername[] = "username";
+    base::Value os_user = base::Value(base::Value::Type::DICTIONARY);
+    os_user.SetKey(kUsername, base::Value(policy::GetOSUsername()));
+    base::JSONWriter::Write(os_user, request->mutable_os_user());
+  }
 }
 
 std::unique_ptr<em::ChromeUserProfileReport>
-GenerateChromeUserProfileReportRequest(const base::Value& profile_report) {
+GenerateChromeUserProfileReportRequest(const base::Value& profile_report,
+                                       const PrefService* prefs) {
   if (!profile_report.is_dict())
     return nullptr;
 
   std::unique_ptr<em::ChromeUserProfileReport> request =
       std::make_unique<em::ChromeUserProfileReport>();
 
-  if (!UpdateJSONEncodedStringEntry(profile_report, kChromeSignInUser,
-                                    request->mutable_chrome_signed_in_user(),
-                                    DICTIONARY) ||
-      !UpdateJSONEncodedStringEntry(profile_report, kExtensionData,
+  if (prefs->GetBoolean(enterprise_reporting::kReportUserIDData)) {
+    if (!UpdateJSONEncodedStringEntry(profile_report, kChromeSignInUser,
+                                      request->mutable_chrome_signed_in_user(),
+                                      DICTIONARY)) {
+      return nullptr;
+    }
+  }
+
+  if (!UpdateJSONEncodedStringEntry(profile_report, kExtensionData,
                                     request->mutable_extension_data(), LIST) ||
       !UpdateJSONEncodedStringEntry(profile_report, kPlugins,
                                     request->mutable_plugins(), LIST)) {
@@ -197,7 +221,9 @@ GenerateChromeDesktopReportRequest(const base::DictionaryValue& report,
   std::unique_ptr<em::ChromeDesktopReportRequest> request =
       std::make_unique<em::ChromeDesktopReportRequest>();
 
-  AppendPlatformInformation(request.get());
+  const PrefService* prefs = profile->GetPrefs();
+
+  AppendPlatformInformation(request.get(), prefs);
 
   if (const base::Value* browser_report =
           report.FindKeyOfType(kBrowserReport, base::Value::Type::DICTIONARY)) {
@@ -208,7 +234,7 @@ GenerateChromeDesktopReportRequest(const base::DictionaryValue& report,
         // Currently, profile send their browser reports individually.
         std::unique_ptr<em::ChromeUserProfileReport> profile_report_request =
             GenerateChromeUserProfileReportRequest(
-                profile_reports->GetList()[0]);
+                profile_reports->GetList()[0], prefs);
         if (!profile_report_request)
           return nullptr;
         request->mutable_browser_report()

chrome/browser/extensions/api/enterprise_reporting_private/chrome_desktop_report_request_helper_unittest.cc

@@ -7,6 +7,7 @@
 #include "base/json/json_reader.h"
 #include "base/json/string_escape.h"
 #include "base/values.h"
+#include "chrome/browser/extensions/api/enterprise_reporting_private/prefs.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/policy/core/common/cloud/cloud_policy_util.h"
@@ -19,6 +20,20 @@ namespace em = enterprise_management;
 
 namespace extensions {
 
+namespace {
+
+base::DictionaryValue CreateReport(base::Value profile_report) {
+  base::Value profile_reports(base::Value::Type::LIST);
+  profile_reports.GetList().push_back(std::move(profile_report));
+
+  base::DictionaryValue report;
+  report.SetPath({"browserReport", "chromeUserProfileReport"},
+                 std::move(profile_reports));
+  return report;
+}
+
+}  // namespace
+
 class ChromeDesktopReportRequestGeneratorTest : public ::testing::Test {
  protected:
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
@@ -183,4 +198,67 @@ TEST_F(ChromeDesktopReportRequestGeneratorTest, SafeBrowsing) {
                     .safe_browsing_warnings_click_through());
 }
 
+TEST_F(ChromeDesktopReportRequestGeneratorTest, DontReportVersionData) {
+  PrefService* prefs = profile_.GetPrefs();
+  prefs->SetBoolean(enterprise_reporting::kReportVersionData, false);
+
+  std::unique_ptr<em::ChromeDesktopReportRequest> request;
+
+  request =
+      GenerateChromeDesktopReportRequest(base::DictionaryValue(), &profile_);
+
+  ASSERT_TRUE(request);
+  EXPECT_FALSE(request->has_os_info());
+  EXPECT_FALSE(request->browser_report().has_browser_version());
+  EXPECT_FALSE(request->browser_report().has_channel());
+}
+
+TEST_F(ChromeDesktopReportRequestGeneratorTest, DontReportPolicyData) {
+  PrefService* prefs = profile_.GetPrefs();
+  prefs->SetBoolean(enterprise_reporting::kReportPolicyData, false);
+
+  std::unique_ptr<em::ChromeDesktopReportRequest> request =
+      GenerateChromeDesktopReportRequest(base::DictionaryValue(), &profile_);
+
+  ASSERT_TRUE(request);
+  const em::ChromeUserProfileReport& profile =
+      request->browser_report().chrome_user_profile_reports(0);
+  EXPECT_FALSE(profile.has_policy_data());
+  EXPECT_FALSE(profile.has_policy_fetched_timestamp());
+}
+
+TEST_F(ChromeDesktopReportRequestGeneratorTest, DontReportMachineIDData) {
+  PrefService* prefs = profile_.GetPrefs();
+  prefs->SetBoolean(enterprise_reporting::kReportMachineIDData, false);
+
+  std::unique_ptr<em::ChromeDesktopReportRequest> request =
+      GenerateChromeDesktopReportRequest(base::DictionaryValue(), &profile_);
+
+  ASSERT_TRUE(request);
+  EXPECT_FALSE(request->has_machine_name());
+}
+
+TEST_F(ChromeDesktopReportRequestGeneratorTest, DontReportUserIDData) {
+  PrefService* prefs = profile_.GetPrefs();
+  prefs->SetBoolean(enterprise_reporting::kReportUserIDData, false);
+
+  base::Value profile_report(base::Value::Type::DICTIONARY);
+  profile_report.SetPath({"chromeSignInUser", "email"},
+                         base::Value("john_doe@gmail.com"));
+  profile_report.SetPath({"chromeSignInUser", "id"}, base::Value("123456789"));
+
+  std::unique_ptr<em::ChromeDesktopReportRequest> request =
+      GenerateChromeDesktopReportRequest(
+          CreateReport(std::move(profile_report)), &profile_);
+
+  ASSERT_TRUE(request);
+  EXPECT_FALSE(request->has_os_user());
+  EXPECT_FALSE(request->browser_report().has_executable_path());
+  const em::ChromeUserProfileReport& profile =
+      request->browser_report().chrome_user_profile_reports(0);
+  EXPECT_FALSE(profile.has_id());
+  EXPECT_FALSE(profile.has_name());
+  EXPECT_FALSE(profile.has_chrome_signed_in_user());
+}
+
 }  // namespace extensions