Attachment #485584 for bug #605271

Attachment #485584: Patch for bug #605271

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





  }

  if (mClassList) {
    mClassList->DropReference();
  }
}

nsGenericElement::nsGenericElement(already_AddRefed<nsINodeInfo> aNodeInfo)
  : Element(aNodeInfo),
    mExtraInterfaceImplementor(this)
{
  // Set the default scriptID to JS - but skip SetScriptTypeID as it
  // does extra work we know isn't necessary here...
  SetFlags(NODE_IS_ELEMENT |
           (nsIProgrammingLanguage::JAVASCRIPT << NODE_SCRIPT_TYPE_OFFSET));
}

nsGenericElement::~nsGenericElement()

NS_IMPL_CYCLE_COLLECTING_ADDREF_AMBIGUOUS(nsGenericElement, nsIContent)
NS_IMPL_CYCLE_COLLECTING_RELEASE_AMBIGUOUS_WITH_DESTROY(nsGenericElement,
                                                        nsIContent,
                                                        nsNodeUtils::LastRelease(this))

nsresult
nsGenericElement::PostQueryInterface(REFNSIID aIID, void** aInstancePtr)
{
  if (aIID.Equals(NS_GET_IID(nsIExtraInterfaceImplementor))) {
    *aInstancePtr = &this->mExtraInterfaceImplementor;
    AddRef();
    return NS_OK;
  }

  nsIDocument *document = GetOwnerDoc();
  if (document) {
    return document->BindingManager()->GetBindingImplementation(this, aIID,
                                                                aInstancePtr);
  }

  *aInstancePtr = nsnull;
  return NS_ERROR_NO_INTERFACE;
}

// nsIExtraInterfaceImplementor
bool
nsGenericElement::nsExtraInterfaceImplementor::MightHaveExtraInterface(REFNSIID aIID)
{
  // Make this check a noop for trusted script.  Privileged callers can always try to
  // QI an element to whatever they want.
  if (nsContentUtils::IsCallerTrustedForCapability("UniversalXPConnect")) {
    return true; // We might not have it, but this is just to convince XPConnect
                 // to do the QI, at which point it'll discover the truth.
  }

  nsIDocument *document = mElement->GetOwnerDoc();
  if (!document)
    return false;

  nsXBLBinding* binding = document->BindingManager()->GetBinding(mElement);
  if (!binding)
    return false;

  return binding->ImplementsInterface(aIID);
}

//----------------------------------------------------------------------
nsresult
nsGenericElement::LeaveLink(nsPresContext* aPresContext)
{
  nsILinkHandler *handler = aPresContext->GetLinkHandler();
  if (!handler) {
    return NS_OK;
  }





#include "mozFlushType.h"
#include "nsDOMAttributeMap.h"
#include "nsIWeakReference.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIDocument.h"
#include "nsIDOMNodeSelector.h"
#include "nsIDOMXPathNSResolver.h"
#include "nsPresContext.h"
#include "nsIExtraInterfaceImplementor.h"

#ifdef MOZ_SMIL
#include "nsISMILAttr.h"
#endif // MOZ_SMIL

class nsIDOMAttr;
class nsIDOMEventListener;
class nsIFrame;

  virtual nsAttrInfo GetAttrInfo(PRInt32 aNamespaceID, nsIAtom* aName) const;

  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsGenericElement)

  virtual void NodeInfoChanged(nsINodeInfo* aOldNodeInfo)
  {
  }

  // nsIExtraInterfaceImplementor
  class nsExtraInterfaceImplementor : public nsIExtraInterfaceImplementor {
  public:
    nsExtraInterfaceImplementor(nsGenericElement* aElement)
      : mElement(aElement)
    {}
    NS_FORWARD_NSISUPPORTS(mElement->);
    virtual bool MightHaveExtraInterface(REFNSIID aIID);
  protected:
    nsGenericElement* mElement;
  };
protected:

  nsExtraInterfaceImplementor mExtraInterfaceImplementor;

  /**
   * Set attribute and (if needed) notify documentobservers and fire off
   * mutation events.  This will send the AttributeChanged notification.
   * Callers of this method are responsible for calling AttributeWillChange,
   * since that needs to happen before the new attr value has been set, and
   * in particular before it has been parsed.
   *
   * @param aNamespaceID  namespace of attribute





        data.value.QueryInterface(Components.interfaces.nsISupportsString).data,
      expected,
      mime + " value in the clipboard");
    return data.value;
  }
  function testPasteText(expected, test) {
    textarea.value="";
    textarea.focus();
    // To QI to non-ClassInfo interfaces we must assert privileges
    netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
    textarea.QueryInterface(Components.interfaces.nsIDOMNSEditableElement)
            .editor.paste(1);
    is(textarea.value, expected, test + ": textarea paste");
  }
  function testInnerHTML(id, expected) {
    var value = document.getElementById(id).innerHTML;
    is(value, expected, id + ".innerHTML");
  }





        data.value.QueryInterface(Components.interfaces.nsISupportsString).data,
      expected,
      mime + " value in the clipboard");
    return data.value;
  }
  function testPasteText(expected) {
    textarea.value="";
    textarea.focus();
    // To QI to non-ClassInfo interfaces we must assert privileges
    netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
    textarea.QueryInterface(Components.interfaces.nsIDOMNSEditableElement)
            .editor.paste(1);
    is(textarea.value, expected, "value of the textarea after the paste");
  }
  function testSelectionToString(expected) {
    is(window.getSelection().toString().replace(/\r\n/g,"\n"), expected, "Selection.toString");
  }
  function testInnerHTML(id, expected) {





<pre id="test">
<script class="testbody" type="text/javascript">

/** Test for Bug 388558 **/
var inputChange = 0;
var textareaChange = 0;

function testUserInput() {
  // To QI to non-ClassInfo interfaces we must assert privileges
  netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
  var input = document.getElementById("input");
  var textarea = document.getElementById("textarea");

  input.focus();
  input.QueryInterface(Components.interfaces.nsIDOMNSEditableElement).setUserInput("foo");
  input.blur();
  is(inputChange, 1, "Input element should have got one change event.");






<pre id="test">
<script class="testbody" type="text/javascript">

/** Test for Bug 389797 **/
var allTags = [];
var classInfos = {};
var interfaces = {};
var interfacesNonClassinfo = {};
var interfacesNonDOM = {};

function getClassName(tag) {
  return "HTML" + classInfos[tag] + "Element";
}

function HTML_TAG(aTagName, aImplClass) {
  allTags.push(aTagName);
  classInfos[aTagName] = aImplClass;

      "nsIDOMNSElement",
      "nsIDOMEventTarget",
      "nsIDOMNSEventTarget",
      "nsIDOMNSHTMLElement",
      "nsIDOMElementCSSInlineStyle",
      "nsIDOMNodeSelector" ];

  // Some interfaces don't appear in classinfo because other interfaces that
  // inherit from them do.  These are visible to unprivileged script.
  interfacesNonClassinfo[aTagName] =
    [ "nsIDOMNode",
      "nsIDOMElement" ];

  // Some interfaces don't appear in classinfo at all because they are
  // implementation details of the underlying XPCOM objects.  These are not
  // visible to unpriviliged script.
  interfacesNonDOM[aTagName] =
    [ "nsIDOM3EventTarget",
      "nsISupportsWeakReference" ];

  var interfaceName = "nsIDOM" + getClassName(aTagName);
  if (interfaceName in Components.interfaces) {  // no nsIDOMHTMLSpanElement
    interfaces[aTagName].push(interfaceName);
    interfacesNonClassinfo[aTagName].push("nsIDOMHTMLElement");
  } else if (aTagName != "ins" && aTagName != "del") {
    // Inherits directly from nsIDOMHTMLElement, unless it's "ins" or "del",

  if (arguments.length > 2) {
    for (var i = 0; i < arguments[2].length; ++i) {
      interfaces[aTagName].push(arguments[2][i]);
    }
  }

  if (arguments.length > 3) {
    for (i = 0; i < arguments[3].length; ++i) {
      interfacesNonDOM[aTagName].push(arguments[3][i]);
    }
  }
}

const objectIfaces = [
    "imgIDecoderObserver", "nsIRequestObserver", "nsIStreamListener",
    "nsIFrameLoaderOwner", "nsIObjectLoadingContent", "nsIInterfaceRequestor",
    "nsIChannelEventSink"

  // Check that each node QIs to all the things we expect it to QI to
  for each (var iface in interfaces[tag].concat(interfacesNonClassinfo[tag])) {
    is(iface in Components.interfaces, true,
       iface + " not in Components.interfaces");
    is(node instanceof Components.interfaces[iface], true,
       tagName(tag) + " does not QI to " + iface);
  }

  // Check that each node doesn't QI to non-DOM things 
  for each (var iface in interfacesNonDOM[tag]) {
    is(iface in Components.interfaces, true,
       iface + " not in Components.interfaces");
    is(node instanceof Components.interfaces[iface], false,
       tagName(tag) + " should not QI to " + iface);
  }
}

netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");

for each (var tag in allTags) {
  var node = document.createElement(tag);

  // Have to use the proto's toString(), since HTMLAnchorElement and company
  // override toString().
  var nodeString = HTMLElement.prototype.toString.apply(node);

  // Debug builds have extra info, so chop off after "Element" if it's followed
  // by ' ' or ']'
  nodeString = nodeString.replace(/Element[\] ].*/, "Element");

  // Check that each node doesn't QI to non-DOM things, except when we have privs
  for each (var iface in interfacesNonDOM[tag]) {
    is(iface in Components.interfaces, true,
       iface + " not in Components.interfaces");
    is(node instanceof Components.interfaces[iface], true,
       tagName(tag) + " should QI to " + iface + " from privileged script");
  }

  // Now see what classinfo reports
  netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
  var nodeClassInfo = node.QueryInterface(Components.interfaces.nsIClassInfo);
  var count = {};
  var classInfoInterfaces =
    nodeClassInfo.getInterfaces(count).
    map(function(id) { return Components.interfacesByID[id].toString(); });

  // Make sure that we know about all the things classinfo claims
  for each (var classInfoInterface in classInfoInterfaces) {

(-)a/content/xbl/public/Makefile.in (+1 lines)

Line	Link Here

Lines 40-52 topsrcdir = @top_srcdir@	Link Here

srcdir		= @srcdir@

srcdir		= @srcdir@

VPATH		= @srcdir@

VPATH		= @srcdir@

include $(DEPTH)/config/autoconf.mk

include $(DEPTH)/config/autoconf.mk

MODULE		= content

MODULE		= content

EXPORTS		= \

EXPORTS		= \

	nsIExtraInterfaceImplementor.h \

	nsIXBLService.h \

	nsIXBLService.h \

	$(NULL)

	$(NULL)

include $(topsrcdir)/config/rules.mk

include $(topsrcdir)/config/rules.mk

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ *   Kyle Huey <me@kylehuey.com>
+ * Portions created by the Initial Developer are Copyright (C) 2010
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+#ifndef nsIExtraInterfaceImplementor_h__
+#define nsIExtraInterfaceImplementor_h__
+#include "nsISupports.h"
+#define NS_IEXTRAINTERFACEIMPLEMENTOR_IID      \
+{ 0x0d7f5e4b, 0xa5ff, 0x403c, { 0x85, 0x1e, 0x43, 0xe7, 0x75, 0x90, 0x35, 0xcf } }
+// This class exposes extra interfaces through the DOM without using class info.
+class nsIExtraInterfaceImplementor : public nsISupports
+{
+public:
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IEXTRAINTERFACEIMPLEMENTOR_IID)
+  virtual bool MightHaveExtraInterface(REFNSIID aIID) = 0;
+};
+NS_DEFINE_STATIC_IID_ACCESSOR(nsIExtraInterfaceImplementor, NS_IEXTRAINTERFACEIMPLEMENTOR_IID)
+#endif // nsIExtraInterfaceImplementor_h__






#define NODE_SCRIPTABLE_FLAGS                                                 \
 ((DOM_DEFAULT_SCRIPTABLE_FLAGS |                                             \
   nsIXPCScriptable::WANT_GETPROPERTY |                                       \
   nsIXPCScriptable::WANT_ADDPROPERTY |                                       \
   nsIXPCScriptable::WANT_SETPROPERTY) &                                      \
  ~nsIXPCScriptable::USE_JSSTUB_FOR_ADDPROPERTY)

// We need to let JavaScript QI elements to interfaces that are not in
// the classinfo since XBL can be used to dynamically implement new
// unknown interfaces on elements, accessibility relies on this being
// possible.

#define ELEMENT_SCRIPTABLE_FLAGS                                              \
  (NODE_SCRIPTABLE_FLAGS |                                                    \
   nsIXPCScriptable::WANT_POSTCREATE |                                        \
   nsIXPCScriptable::WANT_ENUMERATE)

#define EXTERNAL_OBJ_SCRIPTABLE_FLAGS                                         \
  ((ELEMENT_SCRIPTABLE_FLAGS &                                                \
    ~nsIXPCScriptable::USE_JSSTUB_FOR_SETPROPERTY) |                          \
   nsIXPCScriptable::WANT_POSTCREATE |                                        \
   nsIXPCScriptable::WANT_GETPROPERTY |                                       \





  NS_IMETHOD GetFlags(PRUint32* aFlags)                                       \
    { return _to GetFlags(aFlags); }                                          \
  NS_IMETHOD GetClassIDNoAlloc(nsCID* aClassIDNoAlloc)                        \
    { return _to GetClassIDNoAlloc(aClassIDNoAlloc); }

#define NS_DECL_NSICLASSINFO_GETINTERFACES                                    \
  NS_IMETHOD GetInterfaces(PRUint32* aCount, nsIID*** aArray);

// Don't know why nsISupports.idl defines this out...
#define NS_FORWARD_NSISUPPORTS(_to)                                           \
  NS_IMETHOD QueryInterface(const nsIID& uuid, void** result) {               \
    return _to QueryInterface(uuid, result);                                  \
  }                                                                           \
  NS_IMETHOD_(nsrefcnt) AddRef(void) { return _to AddRef(); }                 \
  NS_IMETHOD_(nsrefcnt) Release(void) { return _to Release(); }

#define JSON_PRIMITIVE_PROPNAME                                               \
  "primitive"

#endif /* __NSDOMWORKERMACROS_H__ */





/** Test for Bug 596333 **/

SimpleTest.waitForExplicitFinish();
addLoadEvent(function() SimpleTest.executeSoon(runTest));

var gMisspeltWords;

function getEditor() {
  // To QI to non-ClassInfo interfaces we must assert privileges
  netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
  var Ci = Components.interfaces;
  return document.getElementById("edit")
                 .QueryInterface(Ci.nsIDOMNSEditableElement)
                 .editor;
}

function getSpellCheckSelection() {
  var editor = getEditor();





       getDesciption(aPreventedOnBubbling) + "prevented on bubbling phase");
  }

  var systemGroup =
    Components.classes["@mozilla.org/eventlistenerservice;1"].
      getService(Components.interfaces.nsIEventListenerService).
      systemEventGroup;
  var parentElement = document.getElementById("display");
  // To QI to non-ClassInfo interfaces we must assert privileges
  netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
  parentElement.QueryInterface(Components.interfaces.nsIDOM3EventTarget);
  parentElement.addGroupedEventListener("keypress", listener, true, systemGroup);
  parentElement.addGroupedEventListener("keypress", listener, false, systemGroup);

  function doTest(aElement, aDescription, aIsSingleLine, aIsReadonly,
                  aIsTabbable)
  {
    function reset(aText)





#include "nsWrapperCache.h"
#include "xpclog.h"
#include "jstl.h"
#include "nsINode.h"
#include "xpcquickstubs.h"
#include "jsproxy.h"
#include "AccessCheck.h"
#include "WrapperFactory.h"
#include "nsIExtraInterfaceImplementor.h"

/***************************************************************************/

NS_IMPL_CYCLE_COLLECTION_CLASS(XPCWrappedNative)

NS_IMETHODIMP
NS_CYCLE_COLLECTION_CLASSNAME(XPCWrappedNative)::RootAndUnlinkJSObjects(void *p)
{


return_result:

    if(pError)
        *pError = rv;
    return to;
}

bool MightHaveExtraInterface(nsISupports* aSupports, const nsIID* aIID)
{
  nsCOMPtr<nsIExtraInterfaceImplementor> eII = do_QueryInterface(aSupports);
  if (!eII)
    return false;

  return eII->MightHaveExtraInterface(*aIID);
}

nsresult
XPCWrappedNative::InitTearOff(XPCCallContext& ccx,
                              XPCWrappedNativeTearOff* aTearOff,
                              XPCNativeInterface* aInterface,
                              JSBool needJSObject)
{
    // This is only called while locked (during XPCWrappedNative::FindTearOff).


    nsISupports* identity = GetIdentityObject();
    nsISupports* obj;

    // If the scriptable helper forbids us from reflecting additional
    // interfaces, then don't even try the QI, just fail.
    if(mScriptableInfo &&
       mScriptableInfo->GetFlags().ClassInfoInterfacesOnly() &&
       !mSet->HasInterface(aInterface) &&
       !mSet->HasInterfaceWithAncestor(aInterface) &&
       !MightHaveExtraInterface(identity, iid))
    {
        return NS_ERROR_NO_INTERFACE;
    }

    // We are about to call out to unlock and other code.
    // So protect our intended tearoff.

    aTearOff->SetReserved();





   */
  NS_IMETHOD_(nsrefcnt) Release(void) = 0;

  //@}
};

NS_DEFINE_STATIC_IID_ACCESSOR(nsISupports, NS_ISUPPORTS_IID)

#define NS_FORWARD_NSISUPPORTS(_to)                                           \
  NS_IMETHOD QueryInterface(const nsIID& uuid, void** result) {               \
    return _to QueryInterface(uuid, result);                                  \
  }                                                                           \
  NS_IMETHOD_(nsrefcnt) AddRef(void) { return _to AddRef(); }                 \
  NS_IMETHOD_(nsrefcnt) Release(void) { return _to Release(); }

/*@}*/

#endif

Return to bug 605271