Attachment #8409830 for bug #951457

Attachment #8409830: part_1_backend_stubs_v2.patch for bug #951457

View | Details | Raw Unified | Return to bug 951457
Collapse All | Expand All





/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsISerializable.idl"
#include "nsIContentPolicy.idl"

interface nsIURI;
interface nsIChannel;
interface nsIDocShell;
interface nsIPrincipal;

/**
 * nsIContentSecurityPolicy
 * Describes an XPCOM component used to model and enforce CSPs.  Instances of
 * this class may have multiple policies within them, but there should only be
 * one of these per document/principal.
 */

[scriptable, uuid(1ae83090-e1e1-4272-b0c4-0fbd751c1e27)]
interface nsIContentSecurityPolicy : nsISerializable
{

  /**
   * Set to true when the CSP has been read in and parsed and is ready to
   * enforce.  This is a barrier for the nsDocument so it doesn't load any
   * sub-content until either it knows that a CSP is ready or will not be used.
   */
  readonly attribute boolean isInitialized;

  /**
   * Accessor method for a read-only string version of the policy at a given
   * index.
   */
  AString getPolicy(in unsigned long index);

  /**
   * Returns the number of policies attached to this CSP instance.  Useful with
   * getPolicy().
   */
  readonly attribute unsigned long policyCount;

  /**
   * Remove a policy associated with this CSP context.
   * @throws NS_ERROR_FAILURE if the index is out of bounds or invalid.
   */
  void removePolicy(in unsigned long index);

  /**

  /**
   * Delegate method called by the service when sub-elements of the protected
   * document are being loaded.  Given a bit of information about the request,
   * decides whether or not the policy is satisfied.
   *
   * Calls to this may trigger violation reports when queried, so
   * this value should not be cached.
   */
  short shouldLoad(in nsContentPolicyType aContentType,
                   in nsIURI          aContentLocation,
                   in nsIURI          aRequestOrigin,
                   in nsISupports     aContext,
                   in ACString        aMimeTypeGuess,
                   in nsISupports     aExtra);

  /**
   * Delegate method called by the service when sub-elements of the protected
   * document are being processed.  Given a bit of information about the request,
   * decides whether or not the policy is satisfied.
   */
  short shouldProcess(in nsContentPolicyType   aContentType,
                      in nsIURI          aContentLocation,
                      in nsIURI          aRequestOrigin,
                      in nsISupports     aContext,
                      in ACString        aMimeType,
                      in nsISupports     aExtra);

%{ C++
// nsIObserver topic to fire when the policy encounters a violation.
#define CSP_VIOLATION_TOPIC "csp-on-violate-policy"
%}

};





    'nsChannelPolicy.cpp',
    'nsContentAreaDragDrop.cpp',
    'nsContentIterator.cpp',
    'nsContentList.cpp',
    'nsContentPolicy.cpp',
    'nsContentSink.cpp',
    'nsCopySupport.cpp',
    'nsCrossSiteListenerProxy.cpp',
    'nsCSPContext.cpp',
    'nsCSPParser.cpp',
    'nsCSPService.cpp',
    'nsCSPUtils.cpp',
    'nsDataDocumentContentPolicy.cpp',
    'nsDocumentEncoder.cpp',
    'nsDOMAttributeMap.cpp',
    'nsDOMBlobBuilder.cpp',
    'nsDOMCaretPosition.cpp',

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "mozilla/Preferences.h"
+#include "nsAsyncRedirectVerifyHelper.h"
+#include "nsChannelProperties.h"
+#include "nsCOMPtr.h"
+#include "nsContentPolicyUtils.h"
+#include "nsContentUtils.h"
+#include "nsCSPContext.h"
+#include "nsCSPParser.h"
+#include "nsCSPService.h"
+#include "nsError.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsIChannelEventSink.h"
+#include "nsIChannelPolicy.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIHttpChannel.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsIPrincipal.h"
+#include "nsIPropertyBag2.h"
+#include "nsIScriptError.h"
+#include "nsIWritablePropertyBag2.h"
+#include "nsString.h"
+#include "prlog.h"
+using namespace mozilla;
+/* =====  nsIContentSecurityPolicy impl ====== */
+NS_IMETHODIMP
+nsCSPContext::ShouldLoad(nsContentPolicyType aContentType,
+                         nsIURI*             aContentLocation,
+                         nsIURI*             aRequestOrigin,
+                         nsISupports*        aRequestContext,
+                         const nsACString&   aMimeTypeGuess,
+                         nsISupports*        aExtra,
+                         int16_t*            outDecision)
+{
+  *outDecision = nsIContentPolicy::ACCEPT;
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsCSPContext::ShouldProcess(nsContentPolicyType aContentType,
+                            nsIURI*             aContentLocation,
+                            nsIURI*             aRequestOrigin,
+                            nsISupports*        aRequestContext,
+                            const nsACString&   aMimeType,
+                            nsISupports*        aExtra,
+                            int16_t*            outDecision)
+{
+  *outDecision = nsIContentPolicy::ACCEPT;
+  return NS_OK;
+}
+/* ===== nsISupports implementation ========== */
+NS_IMPL_ISUPPORTS2(nsCSPContext,
+                   nsIContentSecurityPolicy,
+                   nsISerializable)
+nsCSPContext::nsCSPContext()
+{
+}
+nsCSPContext::~nsCSPContext()
+{
+  for (uint32_t i = 0; i < mPolicies.Length(); i++) {
+    if (mPolicies[i]) {
+      delete mPolicies[i];
+    }
+  }
+}
+NS_IMETHODIMP
+nsCSPContext::GetIsInitialized(bool *outIsInitialized)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::GetPolicy(uint32_t aIndex, nsAString& outStr)
+{
+  if (aIndex >= mPolicies.Length()) {
+    return NS_ERROR_FAILURE;
+  }
+  mPolicies[aIndex]->toString(outStr);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsCSPContext::GetPolicyCount(uint32_t *outPolicyCount)
+{
+  *outPolicyCount = mPolicies.Length();
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsCSPContext::RemovePolicy(uint32_t aIndex)
+{
+  if (aIndex >= mPolicies.Length()) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+  mPolicies.RemoveElementAt(aIndex);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsCSPContext::AppendPolicy(const nsAString& aPolicyString,
+                           nsIURI* aSelfURI,
+                           bool aReportOnly,
+                           bool aSpecCompliant)
+{
+  NS_ASSERTION(aSelfURI, "aSelfURI required for AppendPolicy");
+  nsCSPPolicy* policy = nsCSPParser::parseContentSecurityPolicy(aPolicyString, aSelfURI, aReportOnly, 0);
+  if (policy) {
+    mPolicies.AppendElement(policy);
+  }
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsCSPContext::GetAllowsInlineScript(bool* outShouldReportViolations,
+                                    bool* outAllowsInlineScript)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::GetAllowsEval(bool* outShouldReportViolations,
+                            bool* outAllowsEval)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::GetAllowsInlineStyle(bool* outShouldReportViolations,
+                                   bool* outAllowsInlineStyle)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::GetAllowsNonce(const nsAString& aNonce,
+                             uint32_t aContentType,
+                             bool* outShouldReportViolation,
+                             bool* outAllowsNonce)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::GetAllowsHash(const nsAString& aContent,
+                            uint16_t aContentType,
+                            bool* outShouldReportViolation,
+                            bool* outAllowsHash)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::LogViolationDetails(uint16_t aViolationType,
+                                  const nsAString& aSourceFile,
+                                  const nsAString& aScriptSample,
+                                  int32_t aLineNum,
+                                  const nsAString& aNonce,
+                                  const nsAString& aContent)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::SetRequestContext(nsIURI* aSelfURI,
+                                nsIURI* aReferrer,
+                                nsIPrincipal* aDocumentPrincipal,
+                                nsIChannel* aChannel)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::PermitsAncestry(nsIDocShell* aDocShell, bool* outPermitsAncestry)
+{
+  // For now, we allows permitsAncestry, this will be fixed in Bug 994320
+  *outPermitsAncestry = true;
+  return NS_OK;
+}
+/* ===== nsISerializable implementation ====== */
+NS_IMETHODIMP
+nsCSPContext::Read(nsIObjectInputStream* aStream)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+NS_IMETHODIMP
+nsCSPContext::Write(nsIObjectOutputStream* aStream)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef nsCSPContext_h___
+#define nsCSPContext_h___
+#include "nsCSPUtils.h"
+#include "nsIChannel.h"
+#include "nsIContentSecurityPolicy.h"
+#include "nsISerializable.h"
+#include "nsXPCOM.h"
+class nsIObjectInputStream;
+class nsIObjectOutputStream;
+#define NS_CSPCONTEXT_CONTRACTID "@mozilla.org/cspcontext;1"
+ // 09d9ed1a-e5d4-4004-bfe0-27ceb923d9ac
+#define NS_CSPCONTEXT_CID \
+{ 0x09d9ed1a, 0xe5d4, 0x4004, \
+  { 0xbf, 0xe0, 0x27, 0xce, 0xb9, 0x23, 0xd9, 0xac } }
+class nsCSPContext : public nsIContentSecurityPolicy
+{
+  public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSICONTENTSECURITYPOLICY
+    NS_DECL_NSISERIALIZABLE
+    nsCSPContext();
+    virtual ~nsCSPContext();
+  private:
+    nsTArray<nsCSPPolicy*> mPolicies;
+    nsCOMPtr<nsIURI>       mSelfURI;
+};
+#endif /* nsCSPContext_h___ */





#include "mozilla/Preferences.h"
#include "nsIScriptError.h"
#include "nsContentUtils.h"

using namespace mozilla;

/* Keeps track of whether or not CSP is enabled */
bool CSPService::sCSPEnabled = true;
bool CSPService::sNewBackendEnabled = true;

#ifdef PR_LOGGING
static PRLogModuleInfo* gCspPRLog;
#endif

CSPService::CSPService()
{
  Preferences::AddBoolVarCache(&sCSPEnabled, "security.csp.enable");
  Preferences::AddBoolVarCache(&sNewBackendEnabled, "security.csp.newbackend.enable");

#ifdef PR_LOGGING
  if (!gCspPRLog)
    gCspPRLog = PR_NewLogModule("CSP");
#endif
}

CSPService::~CSPService()

  nsCOMPtr<nsIContentSecurityPolicy> csp;
  if (node) {
    principal = node->NodePrincipal();
    principal->GetCsp(getter_AddRefs(csp));

    if (csp) {
#ifdef PR_LOGGING
      {
        uint32_t numPolicies = 0;
        nsresult rv = csp->GetPolicyCount(&numPolicies);
        if (NS_SUCCEEDED(rv)) {
          for (uint32_t i=0; i<numPolicies; i++) {
            nsAutoString policy;
            csp->GetPolicy(i, policy);
            PR_LOG(gCspPRLog, PR_LOG_DEBUG,
                   ("Document has CSP[%d]: %s", i,
                   NS_ConvertUTF16toUTF8(policy).get()));
          }
        }
      }

  nsCOMPtr<nsIContentSecurityPolicy> csp;
  if (node) {
    principal = node->NodePrincipal();
    principal->GetCsp(getter_AddRefs(csp));

    if (csp) {
#ifdef PR_LOGGING
      {
        uint32_t numPolicies = 0;
        nsresult rv = csp->GetPolicyCount(&numPolicies);
        if (NS_SUCCEEDED(rv)) {
          for (uint32_t i=0; i<numPolicies; i++) {
            nsAutoString policy;
            csp->GetPolicy(i, policy);
            PR_LOG(gCspPRLog, PR_LOG_DEBUG,
                   ("shouldProcess - document has policy[%d]: %s", i,
                   NS_ConvertUTF16toUTF8(policy).get()));
          }
        }
      }





/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsCSPService_h___
#define nsCSPService_h___

#include "nsXPCOM.h"
#include "nsIContentPolicy.h"
#include "nsIChannel.h"
#include "nsIChannelEventSink.h"

#define CSPSERVICE_CONTRACTID "@mozilla.org/cspservice;1"
#define CSPSERVICE_CID \
  { 0x8d2f40b2, 0x4875, 0x4c95, \

public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSICONTENTPOLICY
  NS_DECL_NSICHANNELEVENTSINK

  CSPService();
  virtual ~CSPService();
  static bool sCSPEnabled;
  static bool sNewBackendEnabled;
private:
  // Maps origins to app status.
  nsDataHashtable<nsCStringHashKey, uint16_t> mAppStatusCache;
};
#endif /* nsCSPService_h___ */





           "This document is sharing principal with another document.",
           "Since the document is an app, CSP was already set.",
           "Skipping attempt to set CSP."));
#endif
      return NS_OK;
    }
  }

  // Create new CSP object - if we're using the new CSP implementation and backend,
  // use the new contract ID (same interface, but use C++ implementation).
  if (CSPService::sNewBackendEnabled) {
    if (oldHeaderIsPresent && !newHeaderIsPresent) {
      // New CSP implementation doesn't support old header!  ABORT CSP INIT!
      // (Not a problem if newHeaderIsPresent because the old header will be
      // ignored).  This check will get removed when x- header support is
      // removed (see bug 949533)
#ifdef PR_LOGGING
      PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("%s %s %s",
           "This document has an old, x-content-security-policy",
           "header and the new parser doesn't support the non-standard",
           "CSP.  Skipping CSP initialization."));
#endif
      return NS_OK;
    }
    csp = do_CreateInstance("@mozilla.org/cspcontext;1", &rv);
  } else {
    csp = do_CreateInstance("@mozilla.org/contentsecuritypolicy;1", &rv);
  }

  if (NS_FAILED(rv)) {
#ifdef PR_LOGGING
    PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("Failed to create CSP object: %x", rv));
#endif
    return rv;
  }






static void Shutdown();

#include "nsGeolocation.h"
#include "nsDeviceSensors.h"
#ifdef MOZ_GAMEPAD
#include "mozilla/dom/GamepadService.h"
#endif
#include "nsCSPService.h"
#include "nsCSPContext.h"
#include "nsISmsService.h"
#include "nsIMmsService.h"
#include "nsIMobileMessageService.h"
#include "nsIMobileMessageDatabaseService.h"
#include "mozilla/dom/mobilemessage/MobileMessageService.h"
#include "mozilla/dom/mobilemessage/SmsServicesFactory.h"
#include "nsIPowerManagerService.h"
#include "nsIAlarmHalService.h"

NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsGeolocationService, nsGeolocationService::GetGeolocationService)

NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(AudioChannelService, AudioChannelService::GetAudioChannelService)

#ifdef MOZ_WEBSPEECH
NS_GENERIC_FACTORY_CONSTRUCTOR(FakeSpeechRecognitionService)
#endif

NS_GENERIC_FACTORY_CONSTRUCTOR(nsCSPContext)
NS_GENERIC_FACTORY_CONSTRUCTOR(CSPService)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsMixedContentBlocker)

NS_GENERIC_FACTORY_CONSTRUCTOR(nsPrincipal)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsSecurityNameSet)
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsSystemPrincipal,
    nsScriptSecurityManager::SystemPrincipalSingletonConstructor)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsNullPrincipal, Init)

NS_DEFINE_NAMED_CID(NS_EDITORCOMMANDTABLE_CID);
NS_DEFINE_NAMED_CID(NS_EDITINGCOMMANDTABLE_CID);
NS_DEFINE_NAMED_CID(NS_TEXTSERVICESDOCUMENT_CID);
NS_DEFINE_NAMED_CID(NS_GEOLOCATION_SERVICE_CID);
NS_DEFINE_NAMED_CID(NS_GEOLOCATION_CID);
NS_DEFINE_NAMED_CID(NS_AUDIOCHANNEL_SERVICE_CID);
NS_DEFINE_NAMED_CID(NS_FOCUSMANAGER_CID);
NS_DEFINE_NAMED_CID(CSPSERVICE_CID);
NS_DEFINE_NAMED_CID(NS_CSPCONTEXT_CID);
NS_DEFINE_NAMED_CID(NS_MIXEDCONTENTBLOCKER_CID);
NS_DEFINE_NAMED_CID(NS_EVENTLISTENERSERVICE_CID);
NS_DEFINE_NAMED_CID(NS_GLOBALMESSAGEMANAGER_CID);
NS_DEFINE_NAMED_CID(NS_PARENTPROCESSMESSAGEMANAGER_CID);
NS_DEFINE_NAMED_CID(NS_CHILDPROCESSMESSAGEMANAGER_CID);
NS_DEFINE_NAMED_CID(NSCHANNELPOLICY_CID);
NS_DEFINE_NAMED_CID(NS_SCRIPTSECURITYMANAGER_CID);
NS_DEFINE_NAMED_CID(NS_PRINCIPAL_CID);

  { &kNS_GEOLOCATION_CID, false, nullptr, GeolocationConstructor },
  { &kNS_AUDIOCHANNEL_SERVICE_CID, false, nullptr, AudioChannelServiceConstructor },
  { &kNS_FOCUSMANAGER_CID, false, nullptr, CreateFocusManager },
#ifdef MOZ_WEBSPEECH
  { &kNS_FAKE_SPEECH_RECOGNITION_SERVICE_CID, false, nullptr, FakeSpeechRecognitionServiceConstructor },
  { &kNS_SYNTHVOICEREGISTRY_CID, true, nullptr, nsSynthVoiceRegistryConstructor },
#endif
  { &kCSPSERVICE_CID, false, nullptr, CSPServiceConstructor },
  { &kNS_CSPCONTEXT_CID, false, nullptr, nsCSPContextConstructor },
  { &kNS_MIXEDCONTENTBLOCKER_CID, false, nullptr, nsMixedContentBlockerConstructor },
  { &kNS_EVENTLISTENERSERVICE_CID, false, nullptr, CreateEventListenerService },
  { &kNS_GLOBALMESSAGEMANAGER_CID, false, nullptr, CreateGlobalMessageManager },
  { &kNS_PARENTPROCESSMESSAGEMANAGER_CID, false, nullptr, CreateParentMessageManager },
  { &kNS_CHILDPROCESSMESSAGEMANAGER_CID, false, nullptr, CreateChildMessageManager },
  { &kNSCHANNELPOLICY_CID, false, nullptr, nsChannelPolicyConstructor },
  { &kNS_SCRIPTSECURITYMANAGER_CID, false, nullptr, Construct_nsIScriptSecurityManager },
  { &kNS_PRINCIPAL_CID, false, nullptr, nsPrincipalConstructor },

  { "@mozilla.org/geolocation;1", &kNS_GEOLOCATION_CID },
  { "@mozilla.org/audiochannel/service;1", &kNS_AUDIOCHANNEL_SERVICE_CID },
  { "@mozilla.org/focus-manager;1", &kNS_FOCUSMANAGER_CID },
#ifdef MOZ_WEBSPEECH
  { NS_SPEECH_RECOGNITION_SERVICE_CONTRACTID_PREFIX "fake", &kNS_FAKE_SPEECH_RECOGNITION_SERVICE_CID },
  { NS_SYNTHVOICEREGISTRY_CONTRACTID, &kNS_SYNTHVOICEREGISTRY_CID },
#endif
  { CSPSERVICE_CONTRACTID, &kCSPSERVICE_CID },
  { NS_CSPCONTEXT_CONTRACTID, &kNS_CSPCONTEXT_CID },
  { NS_MIXEDCONTENTBLOCKER_CONTRACTID, &kNS_MIXEDCONTENTBLOCKER_CID },
  { NS_EVENTLISTENERSERVICE_CONTRACTID, &kNS_EVENTLISTENERSERVICE_CID },
  { NS_GLOBALMESSAGEMANAGER_CONTRACTID, &kNS_GLOBALMESSAGEMANAGER_CID },
  { NS_PARENTPROCESSMESSAGEMANAGER_CONTRACTID, &kNS_PARENTPROCESSMESSAGEMANAGER_CID },
  { NS_CHILDPROCESSMESSAGEMANAGER_CONTRACTID, &kNS_CHILDPROCESSMESSAGEMANAGER_CID },
  { NSCHANNELPOLICY_CONTRACTID, &kNSCHANNELPOLICY_CID },
  { NS_SCRIPTSECURITYMANAGER_CONTRACTID, &kNS_SCRIPTSECURITYMANAGER_CID },
  { NS_GLOBAL_CHANNELEVENTSINK_CONTRACTID, &kNS_SCRIPTSECURITYMANAGER_CID },





pref("security.xpconnect.plugin.unrestricted", true);
// security-sensitive dialogs should delay button enabling. In milliseconds.
pref("security.dialog_enable_delay", 1000);
pref("security.notification_enable_delay", 500);

pref("security.csp.enable", true);
pref("security.csp.debug", false);
pref("security.csp.experimentalEnabled", false);
pref("security.csp.newbackend.enable", true);

// Mixed content blocking
pref("security.mixed_content.block_active_content", false);
pref("security.mixed_content.block_display_content", false);

// Modifier key prefs: default to Windows settings,
// menu access key = alt, accelerator key = control.
// Use 17 for Ctrl, 18 for Alt, 224 for Meta, 91 for Win, 0 for none. Mac settings in macprefs.js

Return to bug 951457