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/nacl_ui.h"
6
7 #include <string>
8 #include <vector>
9
10 #include "base/bind.h"
11 #include "base/bind_helpers.h"
12 #include "base/command_line.h"
13 #include "base/file_util.h"
14 #include "base/json/json_file_value_serializer.h"
15 #include "base/memory/weak_ptr.h"
16 #include "base/path_service.h"
17 #include "base/strings/string16.h"
18 #include "base/strings/string_number_conversions.h"
19 #include "base/strings/utf_string_conversions.h"
20 #include "base/threading/sequenced_worker_pool.h"
21 #include "base/values.h"
22 #include "chrome/browser/plugins/plugin_prefs.h"
23 #include "chrome/browser/profiles/profile.h"
24 #include "chrome/common/chrome_paths.h"
25 #include "chrome/common/chrome_switches.h"
26 #include "chrome/common/chrome_version_info.h"
27 #include "chrome/common/url_constants.h"
28 #include "content/public/browser/browser_thread.h"
29 #include "content/public/browser/plugin_service.h"
30 #include "content/public/browser/user_metrics.h"
31 #include "content/public/browser/web_ui.h"
32 #include "content/public/browser/web_ui_data_source.h"
33 #include "content/public/browser/web_ui_message_handler.h"
34 #include "content/public/common/webplugininfo.h"
35 #include "grit/browser_resources.h"
36 #include "grit/chromium_strings.h"
37 #include "grit/generated_resources.h"
38 #include "grit/theme_resources.h"
39 #include "ui/base/l10n/l10n_util.h"
40 #include "ui/base/resource/resource_bundle.h"
41
42 #if defined(OS_WIN)
43 #include "base/win/windows_version.h"
44 #endif
45
46 using base::ASCIIToUTF16;
47 using base::UserMetricsAction;
48 using content::BrowserThread;
49 using content::PluginService;
50 using content::WebUIMessageHandler;
51
52 namespace {
53
CreateNaClUIHTMLSource()54 content::WebUIDataSource* CreateNaClUIHTMLSource() {
55 content::WebUIDataSource* source =
56 content::WebUIDataSource::Create(chrome::kChromeUINaClHost);
57
58 source->SetUseJsonJSFormatV2();
59 source->AddLocalizedString("loadingMessage", IDS_NACL_LOADING_MESSAGE);
60 source->AddLocalizedString("naclLongTitle", IDS_NACL_TITLE_MESSAGE);
61 source->SetJsonPath("strings.js");
62 source->AddResourcePath("about_nacl.css", IDR_ABOUT_NACL_CSS);
63 source->AddResourcePath("about_nacl.js", IDR_ABOUT_NACL_JS);
64 source->SetDefaultResource(IDR_ABOUT_NACL_HTML);
65 return source;
66 }
67
68 ////////////////////////////////////////////////////////////////////////////////
69 //
70 // NaClDomHandler
71 //
72 ////////////////////////////////////////////////////////////////////////////////
73
74 // The handler for JavaScript messages for the about:flags page.
75 class NaClDomHandler : public WebUIMessageHandler {
76 public:
77 NaClDomHandler();
78 virtual ~NaClDomHandler();
79
80 // WebUIMessageHandler implementation.
81 virtual void RegisterMessages() OVERRIDE;
82
83 private:
84 // Callback for the "requestNaClInfo" message.
85 void HandleRequestNaClInfo(const base::ListValue* args);
86
87 // Callback for the NaCl plugin information.
88 void OnGotPlugins(const std::vector<content::WebPluginInfo>& plugins);
89
90 // A helper callback that receives the result of checking if PNaCl path
91 // exists and checking the PNaCl |version|. |is_valid| is true if the PNaCl
92 // path that was returned by PathService is valid, and false otherwise.
93 void DidCheckPathAndVersion(const std::string* version, bool is_valid);
94
95 // Called when enough information is gathered to return data back to the page.
96 void MaybeRespondToPage();
97
98 // Helper for MaybeRespondToPage -- called after enough information
99 // is gathered.
100 void PopulatePageInformation(base::DictionaryValue* naclInfo);
101
102 // Returns whether the specified plugin is enabled.
103 bool isPluginEnabled(size_t plugin_index);
104
105 // Adds information regarding the operating system and chrome version to list.
106 void AddOperatingSystemInfo(base::ListValue* list);
107
108 // Adds the list of plugins for NaCl to list.
109 void AddPluginList(base::ListValue* list);
110
111 // Adds the information relevant to PNaCl (e.g., enablement, paths, version)
112 // to the list.
113 void AddPnaclInfo(base::ListValue* list);
114
115 // Adds the information relevant to NaCl to list.
116 void AddNaClInfo(base::ListValue* list);
117
118 // Whether the page has requested data.
119 bool page_has_requested_data_;
120
121 // Whether the plugin information is ready.
122 bool has_plugin_info_;
123
124 // Whether PNaCl path was validated. PathService can return a path
125 // that does not exists, so it needs to be validated.
126 bool pnacl_path_validated_;
127 bool pnacl_path_exists_;
128 std::string pnacl_version_string_;
129
130 // Factory for the creating refs in callbacks.
131 base::WeakPtrFactory<NaClDomHandler> weak_ptr_factory_;
132
133 DISALLOW_COPY_AND_ASSIGN(NaClDomHandler);
134 };
135
NaClDomHandler()136 NaClDomHandler::NaClDomHandler()
137 : page_has_requested_data_(false),
138 has_plugin_info_(false),
139 pnacl_path_validated_(false),
140 pnacl_path_exists_(false),
141 weak_ptr_factory_(this) {
142 PluginService::GetInstance()->GetPlugins(base::Bind(
143 &NaClDomHandler::OnGotPlugins, weak_ptr_factory_.GetWeakPtr()));
144 }
145
~NaClDomHandler()146 NaClDomHandler::~NaClDomHandler() {
147 }
148
RegisterMessages()149 void NaClDomHandler::RegisterMessages() {
150 web_ui()->RegisterMessageCallback(
151 "requestNaClInfo",
152 base::Bind(&NaClDomHandler::HandleRequestNaClInfo,
153 base::Unretained(this)));
154 }
155
156 // Helper functions for collecting a list of key-value pairs that will
157 // be displayed.
AddPair(base::ListValue * list,const base::string16 & key,const base::string16 & value)158 void AddPair(base::ListValue* list,
159 const base::string16& key,
160 const base::string16& value) {
161 base::DictionaryValue* results = new base::DictionaryValue();
162 results->SetString("key", key);
163 results->SetString("value", value);
164 list->Append(results);
165 }
166
167 // Generate an empty data-pair which acts as a line break.
AddLineBreak(base::ListValue * list)168 void AddLineBreak(base::ListValue* list) {
169 AddPair(list, ASCIIToUTF16(""), ASCIIToUTF16(""));
170 }
171
isPluginEnabled(size_t plugin_index)172 bool NaClDomHandler::isPluginEnabled(size_t plugin_index) {
173 std::vector<content::WebPluginInfo> info_array;
174 PluginService::GetInstance()->GetPluginInfoArray(
175 GURL(), "application/x-nacl", false, &info_array, NULL);
176 PluginPrefs* plugin_prefs =
177 PluginPrefs::GetForProfile(Profile::FromWebUI(web_ui())).get();
178 return (!info_array.empty() &&
179 plugin_prefs->IsPluginEnabled(info_array[plugin_index]));
180 }
181
AddOperatingSystemInfo(base::ListValue * list)182 void NaClDomHandler::AddOperatingSystemInfo(base::ListValue* list) {
183 // Obtain the Chrome version info.
184 chrome::VersionInfo version_info;
185 AddPair(list,
186 l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
187 ASCIIToUTF16(version_info.Version() + " (" +
188 chrome::VersionInfo::GetVersionStringModifier() + ")"));
189
190 // OS version information.
191 // TODO(jvoung): refactor this to share the extra windows labeling
192 // with about:flash, or something.
193 std::string os_label = version_info.OSType();
194 #if defined(OS_WIN)
195 base::win::OSInfo* os = base::win::OSInfo::GetInstance();
196 switch (os->version()) {
197 case base::win::VERSION_XP: os_label += " XP"; break;
198 case base::win::VERSION_SERVER_2003:
199 os_label += " Server 2003 or XP Pro 64 bit";
200 break;
201 case base::win::VERSION_VISTA: os_label += " Vista or Server 2008"; break;
202 case base::win::VERSION_WIN7: os_label += " 7 or Server 2008 R2"; break;
203 case base::win::VERSION_WIN8: os_label += " 8 or Server 2012"; break;
204 default: os_label += " UNKNOWN"; break;
205 }
206 os_label += " SP" + base::IntToString(os->service_pack().major);
207 if (os->service_pack().minor > 0)
208 os_label += "." + base::IntToString(os->service_pack().minor);
209 if (os->architecture() == base::win::OSInfo::X64_ARCHITECTURE)
210 os_label += " 64 bit";
211 #endif
212 AddPair(list,
213 l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_OS),
214 ASCIIToUTF16(os_label));
215 AddLineBreak(list);
216 }
217
AddPluginList(base::ListValue * list)218 void NaClDomHandler::AddPluginList(base::ListValue* list) {
219 // Obtain the version of the NaCl plugin.
220 std::vector<content::WebPluginInfo> info_array;
221 PluginService::GetInstance()->GetPluginInfoArray(
222 GURL(), "application/x-nacl", false, &info_array, NULL);
223 base::string16 nacl_version;
224 base::string16 nacl_key = ASCIIToUTF16("NaCl plugin");
225 if (info_array.empty()) {
226 AddPair(list, nacl_key, ASCIIToUTF16("Disabled"));
227 } else {
228 // Only the 0th plugin is used.
229 nacl_version = info_array[0].version + ASCIIToUTF16(" ") +
230 info_array[0].path.LossyDisplayName();
231 if (!isPluginEnabled(0)) {
232 nacl_version += ASCIIToUTF16(" (Disabled in profile prefs)");
233 }
234
235 AddPair(list, nacl_key, nacl_version);
236
237 // Mark the rest as not used.
238 for (size_t i = 1; i < info_array.size(); ++i) {
239 nacl_version = info_array[i].version + ASCIIToUTF16(" ") +
240 info_array[i].path.LossyDisplayName();
241 nacl_version += ASCIIToUTF16(" (not used)");
242 if (!isPluginEnabled(i)) {
243 nacl_version += ASCIIToUTF16(" (Disabled in profile prefs)");
244 }
245 AddPair(list, nacl_key, nacl_version);
246 }
247 }
248 AddLineBreak(list);
249 }
250
AddPnaclInfo(base::ListValue * list)251 void NaClDomHandler::AddPnaclInfo(base::ListValue* list) {
252 // Display whether PNaCl is enabled.
253 base::string16 pnacl_enabled_string = ASCIIToUTF16("Enabled");
254 if (!isPluginEnabled(0)) {
255 pnacl_enabled_string = ASCIIToUTF16("Disabled in profile prefs");
256 } else if (CommandLine::ForCurrentProcess()->HasSwitch(
257 switches::kDisablePnacl)) {
258 pnacl_enabled_string = ASCIIToUTF16("Disabled by flag '--disable-pnacl'");
259 }
260 AddPair(list,
261 ASCIIToUTF16("Portable Native Client (PNaCl)"),
262 pnacl_enabled_string);
263
264 // Obtain the version of the PNaCl translator.
265 base::FilePath pnacl_path;
266 bool got_path = PathService::Get(chrome::DIR_PNACL_COMPONENT, &pnacl_path);
267 if (!got_path || pnacl_path.empty() || !pnacl_path_exists_) {
268 AddPair(list,
269 ASCIIToUTF16("PNaCl translator"),
270 ASCIIToUTF16("Not installed"));
271 } else {
272 AddPair(list,
273 ASCIIToUTF16("PNaCl translator path"),
274 pnacl_path.LossyDisplayName());
275 AddPair(list,
276 ASCIIToUTF16("PNaCl translator version"),
277 ASCIIToUTF16(pnacl_version_string_));
278 }
279 AddLineBreak(list);
280 }
281
AddNaClInfo(base::ListValue * list)282 void NaClDomHandler::AddNaClInfo(base::ListValue* list) {
283 base::string16 nacl_enabled_string = ASCIIToUTF16("Disabled");
284 if (isPluginEnabled(0) &&
285 CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableNaCl)) {
286 nacl_enabled_string = ASCIIToUTF16("Enabled by flag '--enable-nacl'");
287 }
288 AddPair(list,
289 ASCIIToUTF16("Native Client (non-portable, outside web store)"),
290 nacl_enabled_string);
291 AddLineBreak(list);
292 }
293
HandleRequestNaClInfo(const base::ListValue * args)294 void NaClDomHandler::HandleRequestNaClInfo(const base::ListValue* args) {
295 page_has_requested_data_ = true;
296 // Force re-validation of PNaCl's path in the next call to
297 // MaybeRespondToPage(), in case PNaCl went from not-installed
298 // to installed since the request.
299 pnacl_path_validated_ = false;
300 MaybeRespondToPage();
301 }
302
OnGotPlugins(const std::vector<content::WebPluginInfo> & plugins)303 void NaClDomHandler::OnGotPlugins(
304 const std::vector<content::WebPluginInfo>& plugins) {
305 has_plugin_info_ = true;
306 MaybeRespondToPage();
307 }
308
PopulatePageInformation(base::DictionaryValue * naclInfo)309 void NaClDomHandler::PopulatePageInformation(base::DictionaryValue* naclInfo) {
310 DCHECK(pnacl_path_validated_);
311 // Store Key-Value pairs of about-information.
312 scoped_ptr<base::ListValue> list(new base::ListValue());
313 // Display the operating system and chrome version information.
314 AddOperatingSystemInfo(list.get());
315 // Display the list of plugins serving NaCl.
316 AddPluginList(list.get());
317 // Display information relevant to PNaCl.
318 AddPnaclInfo(list.get());
319 // Display information relevant to NaCl (non-portable.
320 AddNaClInfo(list.get());
321 // naclInfo will take ownership of list, and clean it up on destruction.
322 naclInfo->Set("naclInfo", list.release());
323 }
324
DidCheckPathAndVersion(const std::string * version,bool is_valid)325 void NaClDomHandler::DidCheckPathAndVersion(const std::string* version,
326 bool is_valid) {
327 pnacl_path_validated_ = true;
328 pnacl_path_exists_ = is_valid;
329 pnacl_version_string_ = *version;
330 MaybeRespondToPage();
331 }
332
CheckVersion(const base::FilePath & pnacl_path,std::string * version)333 void CheckVersion(const base::FilePath& pnacl_path, std::string* version) {
334 base::FilePath pnacl_json_path =
335 pnacl_path.AppendASCII("pnacl_public_pnacl_json");
336 JSONFileValueSerializer serializer(pnacl_json_path);
337 std::string error;
338 scoped_ptr<base::Value> root(serializer.Deserialize(NULL, &error));
339 if (!root || !root->IsType(base::Value::TYPE_DICTIONARY))
340 return;
341
342 // Now try to get the field. This may leave version empty if the
343 // the "get" fails (no key, or wrong type).
344 static_cast<base::DictionaryValue*>(root.get())->GetStringASCII(
345 "pnacl-version", version);
346 }
347
CheckPathAndVersion(std::string * version)348 bool CheckPathAndVersion(std::string* version) {
349 base::FilePath pnacl_path;
350 bool got_path = PathService::Get(chrome::DIR_PNACL_COMPONENT, &pnacl_path);
351 if (got_path && !pnacl_path.empty() && base::PathExists(pnacl_path)) {
352 CheckVersion(pnacl_path, version);
353 return true;
354 }
355 return false;
356 }
357
MaybeRespondToPage()358 void NaClDomHandler::MaybeRespondToPage() {
359 // Don't reply until everything is ready. The page will show a 'loading'
360 // message until then.
361 if (!page_has_requested_data_ || !has_plugin_info_)
362 return;
363
364 if (!pnacl_path_validated_) {
365 std::string* version_string = new std::string;
366 base::PostTaskAndReplyWithResult(
367 BrowserThread::GetBlockingPool(),
368 FROM_HERE,
369 base::Bind(&CheckPathAndVersion, version_string),
370 base::Bind(&NaClDomHandler::DidCheckPathAndVersion,
371 weak_ptr_factory_.GetWeakPtr(),
372 base::Owned(version_string)));
373 return;
374 }
375
376 base::DictionaryValue naclInfo;
377 PopulatePageInformation(&naclInfo);
378 web_ui()->CallJavascriptFunction("nacl.returnNaClInfo", naclInfo);
379 }
380
381 } // namespace
382
383 ///////////////////////////////////////////////////////////////////////////////
384 //
385 // NaClUI
386 //
387 ///////////////////////////////////////////////////////////////////////////////
388
NaClUI(content::WebUI * web_ui)389 NaClUI::NaClUI(content::WebUI* web_ui) : WebUIController(web_ui) {
390 content::RecordAction(UserMetricsAction("ViewAboutNaCl"));
391
392 web_ui->AddMessageHandler(new NaClDomHandler());
393
394 // Set up the about:nacl source.
395 Profile* profile = Profile::FromWebUI(web_ui);
396 content::WebUIDataSource::Add(profile, CreateNaClUIHTMLSource());
397 }
398