The Tor Browser / file comparison

comparison: browser/components/preferences/privacy.js

browser/components/preferences/privacy.js

branch
TOR_BUG_3246
changeset 6
8bccb770b82d
equal deleted inserted replaced
-1:000000000000 0:1ede1abf3261
1 /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
7
8 var gPrivacyPane = {
9
10 /**
11 * Whether the use has selected the auto-start private browsing mode in the UI.
12 */
13 _autoStartPrivateBrowsing: false,
14
15 /**
16 * Whether the prompt to restart Firefox should appear when changing the autostart pref.
17 */
18 _shouldPromptForRestart: true,
19
20 /**
21 * Sets up the UI for the number of days of history to keep, and updates the
22 * label of the "Clear Now..." button.
23 */
24 init: function ()
25 {
26 this._updateSanitizeSettingsButton();
27 this.initializeHistoryMode();
28 this.updateHistoryModePane();
29 this.updatePrivacyMicroControls();
30 this.initAutoStartPrivateBrowsingReverter();
31 },
32
33 // HISTORY MODE
34
35 /**
36 * The list of preferences which affect the initial history mode settings.
37 * If the auto start private browsing mode pref is active, the initial
38 * history mode would be set to "Don't remember anything".
39 * If all of these preferences have their default values, and the auto-start
40 * private browsing mode is not active, the initial history mode would be
41 * set to "Remember everything".
42 * Otherwise, the initial history mode would be set to "Custom".
43 *
44 * Extensions adding their own preferences can append their IDs to this array if needed.
45 */
46 prefsForDefault: [
47 "places.history.enabled",
48 "browser.formfill.enable",
49 "network.cookie.cookieBehavior",
50 "network.cookie.lifetimePolicy",
51 "privacy.sanitize.sanitizeOnShutdown"
52 ],
53
54 /**
55 * The list of control IDs which are dependent on the auto-start private
56 * browsing setting, such that in "Custom" mode they would be disabled if
57 * the auto-start private browsing checkbox is checked, and enabled otherwise.
58 *
59 * Extensions adding their own controls can append their IDs to this array if needed.
60 */
61 dependentControls: [
62 "rememberHistory",
63 "rememberForms",
64 "keepUntil",
65 "keepCookiesUntil",
66 "alwaysClear",
67 "clearDataSettings"
68 ],
69
70 /**
71 * Check whether all the preferences values are set to their default values
72 *
73 * @param aPrefs an array of pref names to check for
74 * @returns boolean true if all of the prefs are set to their default values,
75 * false otherwise
76 */
77 _checkDefaultValues: function(aPrefs) {
78 for (let i = 0; i < aPrefs.length; ++i) {
79 let pref = document.getElementById(aPrefs[i]);
80 if (pref.value != pref.defaultValue)
81 return false;
82 }
83 return true;
84 },
85
86 /**
87 * Initialize the history mode menulist based on the privacy preferences
88 */
89 initializeHistoryMode: function PPP_initializeHistoryMode()
90 {
91 let mode;
92 let getVal = function (aPref)
93 document.getElementById(aPref).value;
94
95 if (this._checkDefaultValues(this.prefsForDefault)) {
96 if (getVal("browser.privatebrowsing.autostart"))
97 mode = "dontremember";
98 else
99 mode = "remember";
100 }
101 else
102 mode = "custom";
103
104 document.getElementById("historyMode").value = mode;
105 },
106
107 /**
108 * Update the selected pane based on the history mode menulist
109 */
110 updateHistoryModePane: function PPP_updateHistoryModePane()
111 {
112 let selectedIndex = -1;
113 switch (document.getElementById("historyMode").value) {
114 case "remember":
115 selectedIndex = 0;
116 break;
117 case "dontremember":
118 selectedIndex = 1;
119 break;
120 case "custom":
121 selectedIndex = 2;
122 break;
123 }
124 document.getElementById("historyPane").selectedIndex = selectedIndex;
125 },
126
127 /**
128 * Update the Tracking preferences based on controls.
129 */
130 setTrackingPrefs: function PPP_setTrackingPrefs()
131 {
132 let dntRadioGroup = document.getElementById("doNotTrackSelection"),
133 dntValuePref = document.getElementById("privacy.donottrackheader.value"),
134 dntEnabledPref = document.getElementById("privacy.donottrackheader.enabled");
135
136 // if the selected radio button says "no preference", set on/off pref to
137 // false and don't change the value pref.
138 if (dntRadioGroup.selectedItem.value == -1) {
139 dntEnabledPref.value = false;
140 return dntValuePref.value;
141 }
142
143 dntEnabledPref.value = true;
144 return dntRadioGroup.selectedItem.value;
145 },
146
147 /**
148 * Obtain the tracking preference value and reflect it in the UI.
149 */
150 getTrackingPrefs: function PPP_getTrackingPrefs()
151 {
152 let dntValuePref = document.getElementById("privacy.donottrackheader.value"),
153 dntEnabledPref = document.getElementById("privacy.donottrackheader.enabled");
154
155 // if DNT is enbaled, select the value from the selected radio
156 // button, otherwise choose the "no preference" radio button
157 if (dntEnabledPref.value)
158 return dntValuePref.value;
159
160 return document.getElementById("dntnopref").value;
161 },
162
163 /**
164 * Update the private browsing auto-start pref and the history mode
165 * micro-management prefs based on the history mode menulist
166 */
167 updateHistoryModePrefs: function PPP_updateHistoryModePrefs()
168 {
169 let pref = document.getElementById("browser.privatebrowsing.autostart");
170 switch (document.getElementById("historyMode").value) {
171 case "remember":
172 if (pref.value)
173 pref.value = false;
174
175 // select the remember history option if needed
176 let rememberHistoryCheckbox = document.getElementById("rememberHistory");
177 if (!rememberHistoryCheckbox.checked)
178 rememberHistoryCheckbox.checked = true;
179
180 // select the remember forms history option
181 document.getElementById("browser.formfill.enable").value = true;
182
183 #ifdef RELEASE_BUILD
184 // select the accept cookies option
185 document.getElementById("network.cookie.cookieBehavior").value = 0;
186 #else
187 // select the limit cookies option
188 document.getElementById("network.cookie.cookieBehavior").value = 3;
189 #endif
190 // select the cookie lifetime policy option
191 document.getElementById("network.cookie.lifetimePolicy").value = 0;
192
193 // select the clear on close option
194 document.getElementById("privacy.sanitize.sanitizeOnShutdown").value = false;
195 break;
196 case "dontremember":
197 if (!pref.value)
198 pref.value = true;
199 break;
200 }
201 },
202
203 /**
204 * Update the privacy micro-management controls based on the
205 * value of the private browsing auto-start checkbox.
206 */
207 updatePrivacyMicroControls: function PPP_updatePrivacyMicroControls()
208 {
209 if (document.getElementById("historyMode").value == "custom") {
210 let disabled = this._autoStartPrivateBrowsing =
211 document.getElementById("privateBrowsingAutoStart").checked;
212 this.dependentControls
213 .forEach(function (aElement)
214 document.getElementById(aElement).disabled = disabled);
215
216 // adjust the cookie controls status
217 this.readAcceptCookies();
218 document.getElementById("keepCookiesUntil").value = disabled ? 2 :
219 document.getElementById("network.cookie.lifetimePolicy").value;
220
221 // adjust the checked state of the sanitizeOnShutdown checkbox
222 document.getElementById("alwaysClear").checked = disabled ? false :
223 document.getElementById("privacy.sanitize.sanitizeOnShutdown").value;
224
225 // adjust the checked state of the remember history checkboxes
226 document.getElementById("rememberHistory").checked = disabled ? false :
227 document.getElementById("places.history.enabled").value;
228 document.getElementById("rememberForms").checked = disabled ? false :
229 document.getElementById("browser.formfill.enable").value;
230
231 if (!disabled) {
232 // adjust the Settings button for sanitizeOnShutdown
233 this._updateSanitizeSettingsButton();
234 }
235 }
236 },
237
238 // PRIVATE BROWSING
239
240 /**
241 * Initialize the starting state for the auto-start private browsing mode pref reverter.
242 */
243 initAutoStartPrivateBrowsingReverter: function PPP_initAutoStartPrivateBrowsingReverter()
244 {
245 let mode = document.getElementById("historyMode");
246 let autoStart = document.getElementById("privateBrowsingAutoStart");
247 this._lastMode = mode.selectedIndex;
248 this._lastCheckState = autoStart.hasAttribute('checked');
249 },
250
251 _lastMode: null,
252 _lastCheckState: null,
253 updateAutostart: function PPP_updateAutostart() {
254 let mode = document.getElementById("historyMode");
255 let autoStart = document.getElementById("privateBrowsingAutoStart");
256 let pref = document.getElementById("browser.privatebrowsing.autostart");
257 if ((mode.value == "custom" && this._lastCheckState == autoStart.checked) ||
258 (mode.value == "remember" && !this._lastCheckState) ||
259 (mode.value == "dontremember" && this._lastCheckState)) {
260 // These are all no-op changes, so we don't need to prompt.
261 this._lastMode = mode.selectedIndex;
262 this._lastCheckState = autoStart.hasAttribute('checked');
263 return;
264 }
265
266 if (!this._shouldPromptForRestart) {
267 // We're performing a revert. Just let it happen.
268 return;
269 }
270
271 const Cc = Components.classes, Ci = Components.interfaces;
272 let brandName = document.getElementById("bundleBrand").getString("brandShortName");
273 let bundle = document.getElementById("bundlePreferences");
274 let msg = bundle.getFormattedString(autoStart.checked ?
275 "featureEnableRequiresRestart" : "featureDisableRequiresRestart",
276 [brandName]);
277 let title = bundle.getFormattedString("shouldRestartTitle", [brandName]);
278 let prompts = Cc["@mozilla.org/embedcomp/prompt-service;1"].getService(Ci.nsIPromptService);
279 let shouldProceed = prompts.confirm(window, title, msg)
280 if (shouldProceed) {
281 let cancelQuit = Cc["@mozilla.org/supports-PRBool;1"]
282 .createInstance(Ci.nsISupportsPRBool);
283 Services.obs.notifyObservers(cancelQuit, "quit-application-requested",
284 "restart");
285 shouldProceed = !cancelQuit.data;
286
287 if (shouldProceed) {
288 pref.value = autoStart.hasAttribute('checked');
289 document.documentElement.acceptDialog();
290 let appStartup = Cc["@mozilla.org/toolkit/app-startup;1"]
291 .getService(Ci.nsIAppStartup);
292 appStartup.quit(Ci.nsIAppStartup.eAttemptQuit | Ci.nsIAppStartup.eRestart);
293 return;
294 }
295 }
296
297 this._shouldPromptForRestart = false;
298
299 if (this._lastCheckState) {
300 autoStart.checked = "checked";
301 } else {
302 autoStart.removeAttribute('checked');
303 }
304 pref.value = autoStart.hasAttribute('checked');
305 mode.selectedIndex = this._lastMode;
306 mode.doCommand();
307
308 this._shouldPromptForRestart = true;
309 },
310
311 // HISTORY
312
313 /**
314 * Read the location bar enabled and suggestion prefs
315 * @return Int value for suggestion menulist
316 */
317 readSuggestionPref: function PPP_readSuggestionPref()
318 {
319 let getVal = function(aPref)
320 document.getElementById("browser.urlbar." + aPref).value;
321
322 // Suggest nothing if autocomplete is not enabled
323 if (!getVal("autocomplete.enabled"))
324 return -1;
325
326 // Bottom 2 bits of default.behavior specify history/bookmark
327 return getVal("default.behavior") & 3;
328 },
329
330 /**
331 * Write the location bar enabled and suggestion prefs when necessary
332 * @return Bool value for enabled pref
333 */
334 writeSuggestionPref: function PPP_writeSuggestionPref()
335 {
336 let menuVal = document.getElementById("locationBarSuggestion").value;
337 let enabled = menuVal != -1;
338
339 // Only update default.behavior if we're giving suggestions
340 if (enabled) {
341 // Put the selected menu item's value directly into the bottom 2 bits
342 let behavior = document.getElementById("browser.urlbar.default.behavior");
343 behavior.value = behavior.value >> 2 << 2 | menuVal;
344 }
345
346 // Always update the enabled pref
347 return enabled;
348 },
349
350 /*
351 * Preferences:
352 *
353 * places.history.enabled
354 * - whether history is enabled or not
355 * browser.formfill.enable
356 * - true if entries in forms and the search bar should be saved, false
357 * otherwise
358 */
359
360 // COOKIES
361
362 /*
363 * Preferences:
364 *
365 * network.cookie.cookieBehavior
366 * - determines how the browser should handle cookies:
367 * 0 means enable all cookies
368 * 1 means reject all third party cookies
369 * 2 means disable all cookies
370 * 3 means reject third party cookies unless at least one is already set for the eTLD
371 * see netwerk/cookie/src/nsCookieService.cpp for details
372 * network.cookie.lifetimePolicy
373 * - determines how long cookies are stored:
374 * 0 means keep cookies until they expire
375 * 1 means ask how long to keep each cookie
376 * 2 means keep cookies until the browser is closed
377 */
378
379 /**
380 * Reads the network.cookie.cookieBehavior preference value and
381 * enables/disables the rest of the cookie UI accordingly, returning true
382 * if cookies are enabled.
383 */
384 readAcceptCookies: function ()
385 {
386 var pref = document.getElementById("network.cookie.cookieBehavior");
387 var acceptThirdPartyLabel = document.getElementById("acceptThirdPartyLabel");
388 var acceptThirdPartyMenu = document.getElementById("acceptThirdPartyMenu");
389 var keepUntil = document.getElementById("keepUntil");
390 var menu = document.getElementById("keepCookiesUntil");
391
392 // enable the rest of the UI for anything other than "disable all cookies"
393 var acceptCookies = (pref.value != 2);
394
395 acceptThirdPartyLabel.disabled = acceptThirdPartyMenu.disabled = !acceptCookies;
396 keepUntil.disabled = menu.disabled = this._autoStartPrivateBrowsing || !acceptCookies;
397
398 return acceptCookies;
399 },
400
401 /**
402 * Enables/disables the "keep until" label and menulist in response to the
403 * "accept cookies" checkbox being checked or unchecked.
404 */
405 writeAcceptCookies: function ()
406 {
407 var accept = document.getElementById("acceptCookies");
408 var acceptThirdPartyMenu = document.getElementById("acceptThirdPartyMenu");
409
410 #ifdef RELEASE_BUILD
411 // if we're enabling cookies, automatically select 'accept third party always'
412 if (accept.checked)
413 acceptThirdPartyMenu.selectedIndex = 0;
414
415 return accept.checked ? 0 : 2;
416 #else
417 // if we're enabling cookies, automatically select 'accept third party from visited'
418 if (accept.checked)
419 acceptThirdPartyMenu.selectedIndex = 1;
420
421 return accept.checked ? 3 : 2;
422 #endif
423 },
424
425 /**
426 * Converts between network.cookie.cookieBehavior and the third-party cookie UI
427 */
428 readAcceptThirdPartyCookies: function ()
429 {
430 var pref = document.getElementById("network.cookie.cookieBehavior");
431 switch (pref.value)
432 {
433 case 0:
434 return "always";
435 case 1:
436 return "never";
437 case 2:
438 return "never";
439 case 3:
440 return "visited";
441 default:
442 return undefined;
443 }
444 },
445
446 writeAcceptThirdPartyCookies: function ()
447 {
448 var accept = document.getElementById("acceptThirdPartyMenu").selectedItem;
449 switch (accept.value)
450 {
451 case "always":
452 return 0;
453 case "visited":
454 return 3;
455 case "never":
456 return 1;
457 default:
458 return undefined;
459 }
460 },
461
462 /**
463 * Displays fine-grained, per-site preferences for cookies.
464 */
465 showCookieExceptions: function ()
466 {
467 var bundlePreferences = document.getElementById("bundlePreferences");
468 var params = { blockVisible : true,
469 sessionVisible : true,
470 allowVisible : true,
471 prefilledHost : "",
472 permissionType : "cookie",
473 windowTitle : bundlePreferences.getString("cookiepermissionstitle"),
474 introText : bundlePreferences.getString("cookiepermissionstext") };
475 document.documentElement.openWindow("Browser:Permissions",
476 "chrome://browser/content/preferences/permissions.xul",
477 "", params);
478 },
479
480 /**
481 * Displays all the user's cookies in a dialog.
482 */
483 showCookies: function (aCategory)
484 {
485 document.documentElement.openWindow("Browser:Cookies",
486 "chrome://browser/content/preferences/cookies.xul",
487 "", null);
488 },
489
490 // CLEAR PRIVATE DATA
491
492 /*
493 * Preferences:
494 *
495 * privacy.sanitize.sanitizeOnShutdown
496 * - true if the user's private data is cleared on startup according to the
497 * Clear Private Data settings, false otherwise
498 */
499
500 /**
501 * Displays the Clear Private Data settings dialog.
502 */
503 showClearPrivateDataSettings: function ()
504 {
505 document.documentElement.openSubDialog("chrome://browser/content/preferences/sanitize.xul",
506 "", null);
507 },
508
509
510 /**
511 * Displays a dialog from which individual parts of private data may be
512 * cleared.
513 */
514 clearPrivateDataNow: function (aClearEverything)
515 {
516 var ts = document.getElementById("privacy.sanitize.timeSpan");
517 var timeSpanOrig = ts.value;
518 if (aClearEverything)
519 ts.value = 0;
520
521 const Cc = Components.classes, Ci = Components.interfaces;
522 var glue = Cc["@mozilla.org/browser/browserglue;1"]
523 .getService(Ci.nsIBrowserGlue);
524 glue.sanitize(window);
525
526 // reset the timeSpan pref
527 if (aClearEverything)
528 ts.value = timeSpanOrig;
529 },
530
531 /**
532 * Enables or disables the "Settings..." button depending
533 * on the privacy.sanitize.sanitizeOnShutdown preference value
534 */
535 _updateSanitizeSettingsButton: function () {
536 var settingsButton = document.getElementById("clearDataSettings");
537 var sanitizeOnShutdownPref = document.getElementById("privacy.sanitize.sanitizeOnShutdown");
538
539 settingsButton.disabled = !sanitizeOnShutdownPref.value;
540 }
541
542 };

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial