1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/ui/webui/flags_ui.h"
6
7 #include <string>
8
9 #include "base/bind.h"
10 #include "base/bind_helpers.h"
11 #include "base/memory/ref_counted_memory.h"
12 #include "base/prefs/pref_registry_simple.h"
13 #include "base/prefs/pref_service.h"
14 #include "base/strings/utf_string_conversions.h"
15 #include "base/values.h"
16 #include "chrome/browser/about_flags.h"
17 #include "chrome/browser/browser_process.h"
18 #include "chrome/browser/lifetime/application_lifetime.h"
19 #include "chrome/browser/pref_service_flags_storage.h"
20 #include "chrome/browser/profiles/profile.h"
21 #include "chrome/common/chrome_version_info.h"
22 #include "chrome/common/pref_names.h"
23 #include "chrome/common/url_constants.h"
24 #include "content/public/browser/web_contents.h"
25 #include "content/public/browser/web_ui.h"
26 #include "content/public/browser/web_ui_data_source.h"
27 #include "content/public/browser/web_ui_message_handler.h"
28 #include "grit/browser_resources.h"
29 #include "grit/chromium_strings.h"
30 #include "grit/generated_resources.h"
31 #include "grit/theme_resources.h"
32 #include "ui/base/l10n/l10n_util.h"
33 #include "ui/base/resource/resource_bundle.h"
34
35 #if defined(OS_CHROMEOS)
36 #include "base/sys_info.h"
37 #include "chrome/browser/chromeos/login/users/user_manager.h"
38 #include "chrome/browser/chromeos/ownership/owner_settings_service.h"
39 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h"
40 #include "chrome/browser/chromeos/settings/cros_settings.h"
41 #include "chrome/browser/chromeos/settings/owner_flags_storage.h"
42 #include "chromeos/dbus/dbus_thread_manager.h"
43 #include "chromeos/dbus/session_manager_client.h"
44 #include "components/pref_registry/pref_registry_syncable.h"
45 #endif
46
47 using content::WebContents;
48 using content::WebUIMessageHandler;
49
50 namespace {
51
CreateFlagsUIHTMLSource()52 content::WebUIDataSource* CreateFlagsUIHTMLSource() {
53 content::WebUIDataSource* source =
54 content::WebUIDataSource::Create(chrome::kChromeUIFlagsHost);
55
56 source->SetUseJsonJSFormatV2();
57 source->AddLocalizedString("flagsLongTitle", IDS_FLAGS_LONG_TITLE);
58 source->AddLocalizedString("flagsTableTitle", IDS_FLAGS_TABLE_TITLE);
59 source->AddLocalizedString("flagsNoExperimentsAvailable",
60 IDS_FLAGS_NO_EXPERIMENTS_AVAILABLE);
61 source->AddLocalizedString("flagsWarningHeader", IDS_FLAGS_WARNING_HEADER);
62 source->AddLocalizedString("flagsBlurb", IDS_FLAGS_WARNING_TEXT);
63 source->AddLocalizedString("channelPromoBeta",
64 IDS_FLAGS_PROMOTE_BETA_CHANNEL);
65 source->AddLocalizedString("channelPromoDev", IDS_FLAGS_PROMOTE_DEV_CHANNEL);
66 source->AddLocalizedString("flagsUnsupportedTableTitle",
67 IDS_FLAGS_UNSUPPORTED_TABLE_TITLE);
68 source->AddLocalizedString("flagsNoUnsupportedExperiments",
69 IDS_FLAGS_NO_UNSUPPORTED_EXPERIMENTS);
70 source->AddLocalizedString("flagsNotSupported", IDS_FLAGS_NOT_AVAILABLE);
71 source->AddLocalizedString("flagsRestartNotice", IDS_FLAGS_RELAUNCH_NOTICE);
72 source->AddLocalizedString("flagsRestartButton", IDS_FLAGS_RELAUNCH_BUTTON);
73 source->AddLocalizedString("resetAllButton", IDS_FLAGS_RESET_ALL_BUTTON);
74 source->AddLocalizedString("disable", IDS_FLAGS_DISABLE);
75 source->AddLocalizedString("enable", IDS_FLAGS_ENABLE);
76
77 #if defined(OS_CHROMEOS)
78 if (!chromeos::UserManager::Get()->IsCurrentUserOwner() &&
79 base::SysInfo::IsRunningOnChromeOS()) {
80 // Set the strings to show which user can actually change the flags.
81 std::string owner;
82 chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
83 source->AddString("ownerWarning",
84 l10n_util::GetStringFUTF16(IDS_SYSTEM_FLAGS_OWNER_ONLY,
85 base::UTF8ToUTF16(owner)));
86 } else {
87 // The warning will be only shown on ChromeOS, when the current user is not
88 // the owner.
89 source->AddString("ownerWarning", base::string16());
90 }
91 #endif
92
93 source->SetJsonPath("strings.js");
94 source->AddResourcePath("flags.js", IDR_FLAGS_JS);
95 source->SetDefaultResource(IDR_FLAGS_HTML);
96 return source;
97 }
98
99 ////////////////////////////////////////////////////////////////////////////////
100 //
101 // FlagsDOMHandler
102 //
103 ////////////////////////////////////////////////////////////////////////////////
104
105 // The handler for Javascript messages for the about:flags page.
106 class FlagsDOMHandler : public WebUIMessageHandler {
107 public:
FlagsDOMHandler()108 FlagsDOMHandler() : access_(about_flags::kGeneralAccessFlagsOnly),
109 flags_experiments_requested_(false) {
110 }
~FlagsDOMHandler()111 virtual ~FlagsDOMHandler() {}
112
113 // Initializes the DOM handler with the provided flags storage and flags
114 // access. If there were flags experiments requested from javascript before
115 // this was called, it calls |HandleRequestFlagsExperiments| again.
116 void Init(about_flags::FlagsStorage* flags_storage,
117 about_flags::FlagAccess access);
118
119 // WebUIMessageHandler implementation.
120 virtual void RegisterMessages() OVERRIDE;
121
122 // Callback for the "requestFlagsExperiments" message.
123 void HandleRequestFlagsExperiments(const base::ListValue* args);
124
125 // Callback for the "enableFlagsExperiment" message.
126 void HandleEnableFlagsExperimentMessage(const base::ListValue* args);
127
128 // Callback for the "restartBrowser" message. Restores all tabs on restart.
129 void HandleRestartBrowser(const base::ListValue* args);
130
131 // Callback for the "resetAllFlags" message.
132 void HandleResetAllFlags(const base::ListValue* args);
133
134 private:
135 scoped_ptr<about_flags::FlagsStorage> flags_storage_;
136 about_flags::FlagAccess access_;
137 bool flags_experiments_requested_;
138
139 DISALLOW_COPY_AND_ASSIGN(FlagsDOMHandler);
140 };
141
RegisterMessages()142 void FlagsDOMHandler::RegisterMessages() {
143 web_ui()->RegisterMessageCallback("requestFlagsExperiments",
144 base::Bind(&FlagsDOMHandler::HandleRequestFlagsExperiments,
145 base::Unretained(this)));
146 web_ui()->RegisterMessageCallback("enableFlagsExperiment",
147 base::Bind(&FlagsDOMHandler::HandleEnableFlagsExperimentMessage,
148 base::Unretained(this)));
149 web_ui()->RegisterMessageCallback("restartBrowser",
150 base::Bind(&FlagsDOMHandler::HandleRestartBrowser,
151 base::Unretained(this)));
152 web_ui()->RegisterMessageCallback("resetAllFlags",
153 base::Bind(&FlagsDOMHandler::HandleResetAllFlags,
154 base::Unretained(this)));
155 }
156
Init(about_flags::FlagsStorage * flags_storage,about_flags::FlagAccess access)157 void FlagsDOMHandler::Init(about_flags::FlagsStorage* flags_storage,
158 about_flags::FlagAccess access) {
159 flags_storage_.reset(flags_storage);
160 access_ = access;
161
162 if (flags_experiments_requested_)
163 HandleRequestFlagsExperiments(NULL);
164 }
165
HandleRequestFlagsExperiments(const base::ListValue * args)166 void FlagsDOMHandler::HandleRequestFlagsExperiments(
167 const base::ListValue* args) {
168 flags_experiments_requested_ = true;
169 // Bail out if the handler hasn't been initialized yet. The request will be
170 // handled after the initialization.
171 if (!flags_storage_)
172 return;
173
174 base::DictionaryValue results;
175
176 scoped_ptr<base::ListValue> supported_experiments(new base::ListValue);
177 scoped_ptr<base::ListValue> unsupported_experiments(new base::ListValue);
178 about_flags::GetFlagsExperimentsData(flags_storage_.get(),
179 access_,
180 supported_experiments.get(),
181 unsupported_experiments.get());
182 results.Set("supportedExperiments", supported_experiments.release());
183 results.Set("unsupportedExperiments", unsupported_experiments.release());
184 results.SetBoolean("needsRestart",
185 about_flags::IsRestartNeededToCommitChanges());
186 results.SetBoolean("showOwnerWarning",
187 access_ == about_flags::kGeneralAccessFlagsOnly);
188
189 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
190 chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
191 results.SetBoolean("showBetaChannelPromotion",
192 channel == chrome::VersionInfo::CHANNEL_STABLE);
193 results.SetBoolean("showDevChannelPromotion",
194 channel == chrome::VersionInfo::CHANNEL_BETA);
195 #else
196 results.SetBoolean("showBetaChannelPromotion", false);
197 results.SetBoolean("showDevChannelPromotion", false);
198 #endif
199 web_ui()->CallJavascriptFunction("returnFlagsExperiments", results);
200 }
201
HandleEnableFlagsExperimentMessage(const base::ListValue * args)202 void FlagsDOMHandler::HandleEnableFlagsExperimentMessage(
203 const base::ListValue* args) {
204 DCHECK(flags_storage_);
205 DCHECK_EQ(2u, args->GetSize());
206 if (args->GetSize() != 2)
207 return;
208
209 std::string experiment_internal_name;
210 std::string enable_str;
211 if (!args->GetString(0, &experiment_internal_name) ||
212 !args->GetString(1, &enable_str))
213 return;
214
215 about_flags::SetExperimentEnabled(
216 flags_storage_.get(),
217 experiment_internal_name,
218 enable_str == "true");
219 }
220
HandleRestartBrowser(const base::ListValue * args)221 void FlagsDOMHandler::HandleRestartBrowser(const base::ListValue* args) {
222 DCHECK(flags_storage_);
223 #if defined(OS_CHROMEOS)
224 // On ChromeOS be less intrusive and restart inside the user session after
225 // we apply the newly selected flags.
226 CommandLine user_flags(CommandLine::NO_PROGRAM);
227 about_flags::ConvertFlagsToSwitches(flags_storage_.get(),
228 &user_flags,
229 about_flags::kAddSentinels);
230 CommandLine::StringVector flags;
231 // argv[0] is the program name |CommandLine::NO_PROGRAM|.
232 flags.assign(user_flags.argv().begin() + 1, user_flags.argv().end());
233 VLOG(1) << "Restarting to apply per-session flags...";
234 chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
235 SetFlagsForUser(chromeos::UserManager::Get()->GetActiveUser()->email(),
236 flags);
237 #endif
238 chrome::AttemptRestart();
239 }
240
HandleResetAllFlags(const base::ListValue * args)241 void FlagsDOMHandler::HandleResetAllFlags(const base::ListValue* args) {
242 DCHECK(flags_storage_);
243 about_flags::ResetAllFlags(flags_storage_.get());
244 }
245
246
247 #if defined(OS_CHROMEOS)
248 // On ChromeOS verifying if the owner is signed in is async operation and only
249 // after finishing it the UI can be properly populated. This function is the
250 // callback for whether the owner is signed in. It will respectively pick the
251 // proper PrefService for the flags interface.
FinishInitialization(base::WeakPtr<FlagsUI> flags_ui,Profile * profile,FlagsDOMHandler * dom_handler,bool current_user_is_owner)252 void FinishInitialization(base::WeakPtr<FlagsUI> flags_ui,
253 Profile* profile,
254 FlagsDOMHandler* dom_handler,
255 bool current_user_is_owner) {
256 // If the flags_ui has gone away, there's nothing to do.
257 if (!flags_ui)
258 return;
259
260 // On Chrome OS the owner can set system wide flags and other users can only
261 // set flags for their own session.
262 // Note that |dom_handler| is owned by the web ui that owns |flags_ui|, so
263 // it is still alive if |flags_ui| is.
264 if (current_user_is_owner) {
265 dom_handler->Init(new chromeos::about_flags::OwnerFlagsStorage(
266 profile->GetPrefs(),
267 chromeos::CrosSettings::Get()),
268 about_flags::kOwnerAccessToFlags);
269 } else {
270 dom_handler->Init(
271 new about_flags::PrefServiceFlagsStorage(profile->GetPrefs()),
272 about_flags::kGeneralAccessFlagsOnly);
273 }
274 }
275 #endif
276
277 } // namespace
278
279 ///////////////////////////////////////////////////////////////////////////////
280 //
281 // FlagsUI
282 //
283 ///////////////////////////////////////////////////////////////////////////////
284
FlagsUI(content::WebUI * web_ui)285 FlagsUI::FlagsUI(content::WebUI* web_ui)
286 : WebUIController(web_ui),
287 weak_factory_(this) {
288 Profile* profile = Profile::FromWebUI(web_ui);
289
290 FlagsDOMHandler* handler = new FlagsDOMHandler();
291 web_ui->AddMessageHandler(handler);
292
293 #if defined(OS_CHROMEOS)
294 chromeos::OwnerSettingsService* service =
295 chromeos::OwnerSettingsServiceFactory::GetForProfile(profile);
296 if (service) {
297 service->IsOwnerAsync(base::Bind(
298 &FinishInitialization, weak_factory_.GetWeakPtr(), profile, handler));
299 } else {
300 FinishInitialization(weak_factory_.GetWeakPtr(),
301 profile,
302 handler,
303 false /* current_user_is_owner */);
304 }
305 #else
306 handler->Init(new about_flags::PrefServiceFlagsStorage(
307 g_browser_process->local_state()),
308 about_flags::kOwnerAccessToFlags);
309 #endif
310
311 // Set up the about:flags source.
312 content::WebUIDataSource::Add(profile, CreateFlagsUIHTMLSource());
313 }
314
~FlagsUI()315 FlagsUI::~FlagsUI() {
316 }
317
318 // static
GetFaviconResourceBytes(ui::ScaleFactor scale_factor)319 base::RefCountedMemory* FlagsUI::GetFaviconResourceBytes(
320 ui::ScaleFactor scale_factor) {
321 return ResourceBundle::GetSharedInstance().
322 LoadDataResourceBytesForScale(IDR_FLAGS_FAVICON, scale_factor);
323 }
324
325 // static
RegisterPrefs(PrefRegistrySimple * registry)326 void FlagsUI::RegisterPrefs(PrefRegistrySimple* registry) {
327 registry->RegisterListPref(prefs::kEnabledLabsExperiments);
328 }
329
330 #if defined(OS_CHROMEOS)
331 // static
RegisterProfilePrefs(user_prefs::PrefRegistrySyncable * registry)332 void FlagsUI::RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
333 registry->RegisterListPref(prefs::kEnabledLabsExperiments,
334 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
335 }
336
337 #endif
338