File: system_features_disable_list_policy_handler.cc

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (186 lines) | stat: -rw-r--r-- 6,417 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "system_features_disable_list_policy_handler.h"

#include "ash/constants/ash_pref_names.h"
#include "ash/constants/web_app_id_constants.h"
#include "base/containers/contains.h"
#include "base/logging.h"
#include "base/metrics/histogram_functions.h"
#include "base/values.h"
#include "build/build_config.h"
#include "components/policy/core/common/policy_pref_names.h"
#include "components/policy/policy_constants.h"
#include "components/prefs/pref_registry_simple.h"

static_assert(BUILDFLAG(IS_CHROMEOS));

namespace policy {

const char kCameraFeature[] = "camera";
const char kBrowserSettingsFeature[] = "browser_settings";
const char kOsSettingsFeature[] = "os_settings";
const char kScanningFeature[] = "scanning";
const char kWebStoreFeature[] = "web_store";
const char kCanvasFeature[] = "canvas";
const char kExploreFeature[] = "explore";
const char kCroshFeature[] = "crosh";
const char kTerminalFeature[] = "terminal";
const char kGalleryFeature[] = "gallery";
const char kPrintJobsFeature[] = "print_jobs";
const char kKeyShortcutsFeature[] = "key_shortcuts";
const char kRecorderFeature[] = "recorder";
const char kGmailFeature[] = "gmail";
const char kGoogleDocsFeature[] = "google_docs";
const char kGoogleSlidesFeature[] = "google_slides";
const char kGoogleSheetsFeature[] = "google_sheets";
const char kGoogleDriveFeature[] = "google_drive";
const char kGoogleKeepFeature[] = "google_keep";
const char kGoogleCalendarFeature[] = "google_calendar";
const char kGoogleChatFeature[] = "google_chat";
const char kYoutubeFeature[] = "youtube";
const char kGoogleMapsFeature[] = "google_maps";
const char kCalculatorFeature[] = "calculator";
const char kTextEditorFeature[] = "text_editor";

const char kSystemFeaturesDisableListHistogram[] =
    "Enterprise.SystemFeaturesDisableList";

SystemFeaturesDisableListPolicyHandler::SystemFeaturesDisableListPolicyHandler()
    : policy::ListPolicyHandler(key::kSystemFeaturesDisableList,
                                base::Value::Type::STRING) {}

SystemFeaturesDisableListPolicyHandler::
    ~SystemFeaturesDisableListPolicyHandler() = default;

SystemFeature SystemFeaturesDisableListPolicyHandler::GetSystemFeatureFromAppId(
    const std::string& app_id) {
  if (app_id == ash::kCanvasAppId) {
    return SystemFeature::kCanvas;
  }
  return SystemFeature::kUnknownSystemFeature;
}

bool SystemFeaturesDisableListPolicyHandler::IsSystemFeatureDisabled(
    SystemFeature feature,
    PrefService* const pref_service) {
  if (!pref_service) {  // Sometimes it's not available in tests.
    return false;
  }

  const base::Value::List& disabled_system_features =
      pref_service->GetList(policy::policy_prefs::kSystemFeaturesDisableList);

  return base::Contains(disabled_system_features,
                        base::Value(static_cast<int>(feature)));
}

void SystemFeaturesDisableListPolicyHandler::ApplyList(
    base::Value::List filtered_list,
    PrefValueMap* prefs) {
  base::Value::List enums_list;
  base::Value* old_list = nullptr;
  prefs->GetValue(policy_prefs::kSystemFeaturesDisableList, &old_list);

  for (const auto& element : filtered_list) {
    SystemFeature feature = ConvertToEnum(element.GetString());
    enums_list.Append(static_cast<int>(feature));

    if (!old_list || !base::Contains(old_list->GetList(),
                                     base::Value(static_cast<int>(feature)))) {
      base::UmaHistogramEnumeration(kSystemFeaturesDisableListHistogram,
                                    feature);
    }
  }

  bool os_settings_disabled = base::Contains(
      enums_list, base::Value(static_cast<int>(SystemFeature::kOsSettings)));
  prefs->SetBoolean(ash::prefs::kOsSettingsEnabled, !os_settings_disabled);
  prefs->SetValue(policy_prefs::kSystemFeaturesDisableList,
                  base::Value(std::move(enums_list)));
}

SystemFeature SystemFeaturesDisableListPolicyHandler::ConvertToEnum(
    const std::string& system_feature) {
  if (system_feature == kCameraFeature) {
    return SystemFeature::kCamera;
  }
  if (system_feature == kOsSettingsFeature) {
    return SystemFeature::kOsSettings;
  }
  if (system_feature == kBrowserSettingsFeature) {
    return SystemFeature::kBrowserSettings;
  }
  if (system_feature == kScanningFeature) {
    return SystemFeature::kScanning;
  }
  if (system_feature == kWebStoreFeature) {
    return SystemFeature::kWebStore;
  }
  if (system_feature == kCanvasFeature) {
    return SystemFeature::kCanvas;
  }
  if (system_feature == kExploreFeature) {
    return SystemFeature::kExplore;
  }
  if (system_feature == kCroshFeature) {
    return SystemFeature::kCrosh;
  }
  if (system_feature == kTerminalFeature) {
    return SystemFeature::kTerminal;
  }
  if (system_feature == kGalleryFeature) {
    return SystemFeature::kGallery;
  }
  if (system_feature == kPrintJobsFeature) {
    return SystemFeature::kPrintJobs;
  }
  if (system_feature == kKeyShortcutsFeature) {
    return SystemFeature::kKeyShortcuts;
  }
  if (system_feature == kRecorderFeature) {
    return SystemFeature::kRecorder;
  }
  if (system_feature == kGmailFeature) {
    return SystemFeature::kGmail;
  }
  if (system_feature == kGoogleDocsFeature) {
    return SystemFeature::kGoogleDocs;
  }
  if (system_feature == kGoogleSlidesFeature) {
    return SystemFeature::kGoogleSlides;
  }
  if (system_feature == kGoogleSheetsFeature) {
    return SystemFeature::kGoogleSheets;
  }
  if (system_feature == kGoogleDriveFeature) {
    return SystemFeature::kGoogleDrive;
  }
  if (system_feature == kGoogleKeepFeature) {
    return SystemFeature::kGoogleKeep;
  }
  if (system_feature == kGoogleCalendarFeature) {
    return SystemFeature::kGoogleCalendar;
  }
  if (system_feature == kGoogleChatFeature) {
    return SystemFeature::kGoogleChat;
  }
  if (system_feature == kYoutubeFeature) {
    return SystemFeature::kYoutube;
  }
  if (system_feature == kGoogleMapsFeature) {
    return SystemFeature::kGoogleMaps;
  }
  if (system_feature == kCalculatorFeature) {
    return SystemFeature::kCalculator;
  }
  if (system_feature == kTextEditorFeature) {
    return SystemFeature::kTextEditor;
  }
  LOG(ERROR) << "Unsupported system feature: " << system_feature;
  return SystemFeature::kUnknownSystemFeature;
}

}  // namespace policy