LCOV - app.info - content/html/content/src/nsHTMLObjectElement.cpp

LCOV - code coverage report
| Current view: | directory - content/html/content/src - nsHTMLObjectElement.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 190 | 3 | 1.6 %
| Date: | 2012-06-02 | Functions: | 175 | 3 | 1.7 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : // vim:set et sw=2 sts=2 cin:
           3                 : /* ***** BEGIN LICENSE BLOCK *****
           4                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           5                 :  *
           6                 :  * The contents of this file are subject to the Mozilla Public License Version
           7                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           8                 :  * the License. You may obtain a copy of the License at
           9                 :  * http://www.mozilla.org/MPL/
          10                 :  *
          11                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          12                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          13                 :  * for the specific language governing rights and limitations under the
          14                 :  * License.
          15                 :  *
          16                 :  * The Original Code is Mozilla Communicator client code.
          17                 :  *
          18                 :  * The Initial Developer of the Original Code is
          19                 :  * Netscape Communications Corporation.
          20                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          21                 :  * the Initial Developer. All Rights Reserved.
          22                 :  *
          23                 :  * Contributor(s):
          24                 :  *
          25                 :  * Alternatively, the contents of this file may be used under the terms of
          26                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          27                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          29                 :  * of those above. If you wish to allow use of your version of this file only
          30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          31                 :  * use your version of this file under the terms of the MPL, indicate your
          32                 :  * decision by deleting the provisions above and replace them with the notice
          33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          34                 :  * the provisions above, a recipient may use your version of this file under
          35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          36                 :  *
          37                 :  * ***** END LICENSE BLOCK ***** */
          38                 :
          39                 : #include "mozilla/Util.h"
          40                 :
          41                 : #include "nsAutoPtr.h"
          42                 : #include "nsGenericHTMLElement.h"
          43                 : #include "nsObjectLoadingContent.h"
          44                 : #include "nsGkAtoms.h"
          45                 : #include "nsDOMError.h"
          46                 : #include "nsIDocument.h"
          47                 : #include "nsIDOMDocument.h"
          48                 : #include "nsIDOMSVGDocument.h"
          49                 : #include "nsIDOMGetSVGDocument.h"
          50                 : #include "nsIDOMHTMLObjectElement.h"
          51                 : #include "nsFormSubmission.h"
          52                 : #include "nsIObjectFrame.h"
          53                 : #include "nsNPAPIPluginInstance.h"
          54                 : #include "nsIConstraintValidation.h"
          55                 : #include "nsIWidget.h"
          56                 :
          57                 : using namespace mozilla;
          58                 : using namespace mozilla::dom;
          59                 :
          60                 : class nsHTMLObjectElement : public nsGenericHTMLFormElement
          61                 :                           , public nsObjectLoadingContent
          62                 :                           , public nsIDOMHTMLObjectElement
          63                 :                           , public nsIConstraintValidation
          64                 :                           , public nsIDOMGetSVGDocument
          65                 : {
          66                 : public:
          67                 :   using nsIConstraintValidation::GetValidationMessage;
          68                 :
          69                 :   nsHTMLObjectElement(already_AddRefed<nsINodeInfo> aNodeInfo,
          70                 :                       mozilla::dom::FromParser aFromParser = mozilla::dom::NOT_FROM_PARSER);
          71                 :   virtual ~nsHTMLObjectElement();
          72                 :
          73                 :   // nsISupports
          74                 :   NS_DECL_ISUPPORTS_INHERITED
          75                 :
          76                 :   // nsIDOMNode
          77               0 :   NS_FORWARD_NSIDOMNODE(nsGenericHTMLFormElement::)
          78                 :
          79                 :   // nsIDOMElement
          80               0 :   NS_FORWARD_NSIDOMELEMENT(nsGenericHTMLFormElement::)
          81                 :
          82                 :   // nsIDOMHTMLElement
          83               0 :   NS_FORWARD_NSIDOMHTMLELEMENT_BASIC(nsGenericHTMLFormElement::)
          84               0 :   NS_SCRIPTABLE NS_IMETHOD Click() {
          85               0 :     return nsGenericHTMLFormElement::Click();
          86                 :   }
          87                 :   NS_SCRIPTABLE NS_IMETHOD GetTabIndex(PRInt32* aTabIndex);
          88                 :   NS_SCRIPTABLE NS_IMETHOD SetTabIndex(PRInt32 aTabIndex);
          89               0 :   NS_SCRIPTABLE NS_IMETHOD Focus() {
          90               0 :     return nsGenericHTMLFormElement::Focus();
          91                 :   }
          92               0 :   NS_SCRIPTABLE NS_IMETHOD GetDraggable(bool* aDraggable) {
          93               0 :     return nsGenericHTMLFormElement::GetDraggable(aDraggable);
          94                 :   }
          95               0 :   NS_SCRIPTABLE NS_IMETHOD GetInnerHTML(nsAString& aInnerHTML) {
          96               0 :     return nsGenericHTMLFormElement::GetInnerHTML(aInnerHTML);
          97                 :   }
          98               0 :   NS_SCRIPTABLE NS_IMETHOD SetInnerHTML(const nsAString& aInnerHTML) {
          99               0 :     return nsGenericHTMLFormElement::SetInnerHTML(aInnerHTML);
         100                 :   }
         101                 :
         102                 :   // nsIDOMHTMLObjectElement
         103                 :   NS_DECL_NSIDOMHTMLOBJECTELEMENT
         104                 :
         105                 :   // nsIDOMGetSVGDocument
         106                 :   NS_DECL_NSIDOMGETSVGDOCUMENT
         107                 :
         108                 :   virtual nsresult BindToTree(nsIDocument *aDocument, nsIContent *aParent,
         109                 :                               nsIContent *aBindingParent,
         110                 :                               bool aCompileEventHandlers);
         111                 :   virtual void UnbindFromTree(bool aDeep = true,
         112                 :                               bool aNullParent = true);
         113                 :   virtual nsresult SetAttr(PRInt32 aNameSpaceID, nsIAtom *aName,
         114                 :                            nsIAtom *aPrefix, const nsAString &aValue,
         115                 :                            bool aNotify);
         116                 :   virtual nsresult UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
         117                 :                              bool aNotify);
         118                 :
         119                 :   virtual bool IsHTMLFocusable(bool aWithMouse, bool *aIsFocusable, PRInt32 *aTabIndex);
         120                 :   virtual IMEState GetDesiredIMEState();
         121                 :
         122                 :   // Overriden nsIFormControl methods
         123               0 :   NS_IMETHOD_(PRUint32) GetType() const
         124                 :   {
         125               0 :     return NS_FORM_OBJECT;
         126                 :   }
         127                 :
         128                 :   NS_IMETHOD Reset();
         129                 :   NS_IMETHOD SubmitNamesValues(nsFormSubmission *aFormSubmission);
         130                 :
         131               0 :   virtual bool IsDisabled() const { return false; }
         132                 :
         133                 :   virtual void DoneAddingChildren(bool aHaveNotified);
         134                 :   virtual bool IsDoneAddingChildren();
         135                 :
         136                 :   virtual bool ParseAttribute(PRInt32 aNamespaceID,
         137                 :                                 nsIAtom *aAttribute,
         138                 :                                 const nsAString &aValue,
         139                 :                                 nsAttrValue &aResult);
         140                 :   virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const;
         141                 :   NS_IMETHOD_(bool) IsAttributeMapped(const nsIAtom *aAttribute) const;
         142                 :   virtual nsEventStates IntrinsicState() const;
         143                 :   virtual void DestroyContent();
         144                 :
         145                 :   // nsObjectLoadingContent
         146                 :   virtual PRUint32 GetCapabilities() const;
         147                 :
         148                 :   virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const;
         149                 :
         150                 :   nsresult CopyInnerTo(nsGenericElement* aDest) const;
         151                 :
         152               0 :   void StartObjectLoad() { StartObjectLoad(true); }
         153                 :
         154            1464 :   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_NO_UNLINK(nsHTMLObjectElement,
         155                 :                                                      nsGenericHTMLFormElement)
         156                 :
         157                 :   virtual nsXPCClassInfo* GetClassInfo();
         158                 : private:
         159                 :   /**
         160                 :    * Calls LoadObject with the correct arguments to start the plugin load.
         161                 :    */
         162                 :   NS_HIDDEN_(void) StartObjectLoad(bool aNotify);
         163                 :
         164                 :   /**
         165                 :    * Returns if the element is currently focusable regardless of it's tabindex
         166                 :    * value. This is used to know the default tabindex value.
         167                 :    */
         168                 :   bool IsFocusableForTabIndex();
         169                 :
         170                 :   bool mIsDoneAddingChildren;
         171                 : };
         172                 :
         173                 :
         174               0 : NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(Object)
         175                 :
         176                 :
         177               0 : nsHTMLObjectElement::nsHTMLObjectElement(already_AddRefed<nsINodeInfo> aNodeInfo,
         178                 :                                          FromParser aFromParser)
         179                 :   : nsGenericHTMLFormElement(aNodeInfo),
         180               0 :     mIsDoneAddingChildren(!aFromParser)
         181                 : {
         182               0 :   RegisterFreezableElement();
         183               0 :   SetIsNetworkCreated(aFromParser == FROM_PARSER_NETWORK);
         184                 :
         185                 :   // <object> is always barred from constraint validation.
         186               0 :   SetBarredFromConstraintValidation(true);
         187                 :
         188                 :   // By default we're in the loading state
         189               0 :   AddStatesSilently(NS_EVENT_STATE_LOADING);
         190               0 : }
         191                 :
         192               0 : nsHTMLObjectElement::~nsHTMLObjectElement()
         193                 : {
         194               0 :   UnregisterFreezableElement();
         195               0 :   DestroyImageLoadingContent();
         196               0 : }
         197                 :
         198                 : bool
         199               0 : nsHTMLObjectElement::IsDoneAddingChildren()
         200                 : {
         201               0 :   return mIsDoneAddingChildren;
         202                 : }
         203                 :
         204                 : void
         205               0 : nsHTMLObjectElement::DoneAddingChildren(bool aHaveNotified)
         206                 : {
         207               0 :   mIsDoneAddingChildren = true;
         208                 :
         209                 :   // If we're already in a document, we need to trigger the load
         210                 :   // Otherwise, BindToTree takes care of that.
         211               0 :   if (IsInDoc()) {
         212               0 :     StartObjectLoad(aHaveNotified);
         213                 :   }
         214               0 : }
         215                 :
         216            1464 : NS_IMPL_CYCLE_COLLECTION_CLASS(nsHTMLObjectElement)
         217               0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsHTMLObjectElement,
         218                 :                                                   nsGenericHTMLFormElement)
         219               0 :   nsObjectLoadingContent::Traverse(tmp, cb);
         220               0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
         221                 :
         222               0 : NS_IMPL_ADDREF_INHERITED(nsHTMLObjectElement, nsGenericElement)
         223               0 : NS_IMPL_RELEASE_INHERITED(nsHTMLObjectElement, nsGenericElement)
         224                 :
         225               0 : DOMCI_NODE_DATA(HTMLObjectElement, nsHTMLObjectElement)
         226                 :
         227               0 : NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsHTMLObjectElement)
         228                 :   NS_HTML_CONTENT_INTERFACE_TABLE_BEGIN(nsHTMLObjectElement)
         229                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIDOMHTMLObjectElement)
         230                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, imgIDecoderObserver)
         231                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIRequestObserver)
         232                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIStreamListener)
         233                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIFrameLoaderOwner)
         234                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIObjectLoadingContent)
         235                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIImageLoadingContent)
         236                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, imgIContainerObserver)
         237                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIInterfaceRequestor)
         238                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIChannelEventSink)
         239                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIConstraintValidation)
         240                 :     NS_INTERFACE_TABLE_ENTRY(nsHTMLObjectElement, nsIDOMGetSVGDocument)
         241               0 :   NS_OFFSET_AND_INTERFACE_TABLE_END
         242               0 :   NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLObjectElement,
         243                 :                                                nsGenericHTMLFormElement)
         244               0 : NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLObjectElement)
         245                 :
         246               0 : NS_IMPL_ELEMENT_CLONE(nsHTMLObjectElement)
         247                 :
         248                 : // nsIConstraintValidation
         249               0 : NS_IMPL_NSICONSTRAINTVALIDATION(nsHTMLObjectElement)
         250                 :
         251                 : NS_IMETHODIMP
         252               0 : nsHTMLObjectElement::GetForm(nsIDOMHTMLFormElement **aForm)
         253                 : {
         254               0 :   return nsGenericHTMLFormElement::GetForm(aForm);
         255                 : }
         256                 :
         257                 : nsresult
         258               0 : nsHTMLObjectElement::BindToTree(nsIDocument *aDocument,
         259                 :                                 nsIContent *aParent,
         260                 :                                 nsIContent *aBindingParent,
         261                 :                                 bool aCompileEventHandlers)
         262                 : {
         263                 :   nsresult rv = nsGenericHTMLFormElement::BindToTree(aDocument, aParent,
         264                 :                                                      aBindingParent,
         265               0 :                                                      aCompileEventHandlers);
         266               0 :   NS_ENSURE_SUCCESS(rv, rv);
         267                 :
         268                 :   // If we already have all the children, start the load.
         269               0 :   if (mIsDoneAddingChildren) {
         270               0 :     void (nsHTMLObjectElement::*start)() = &nsHTMLObjectElement::StartObjectLoad;
         271               0 :     nsContentUtils::AddScriptRunner(NS_NewRunnableMethod(this, start));
         272                 :   }
         273                 :
         274               0 :   return NS_OK;
         275                 : }
         276                 :
         277                 : void
         278               0 : nsHTMLObjectElement::UnbindFromTree(bool aDeep,
         279                 :                                     bool aNullParent)
         280                 : {
         281               0 :   RemovedFromDocument();
         282               0 :   nsGenericHTMLFormElement::UnbindFromTree(aDeep, aNullParent);
         283               0 : }
         284                 :
         285                 :
         286                 :
         287                 : nsresult
         288               0 : nsHTMLObjectElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom *aName,
         289                 :                              nsIAtom *aPrefix, const nsAString &aValue,
         290                 :                              bool aNotify)
         291                 : {
         292                 :   // If we plan to call LoadObject, we want to do it first so that the
         293                 :   // object load kicks off _before_ the reflow triggered by the SetAttr.  But if
         294                 :   // aNotify is false, we are coming from the parser or some such place; we'll
         295                 :   // get bound after all the attributes have been set, so we'll do the
         296                 :   // object load from BindToTree/DoneAddingChildren.
         297                 :   // Skip the LoadObject call in that case.
         298                 :   // We also don't want to start loading the object when we're not yet in
         299                 :   // a document, just in case that the caller wants to set additional
         300                 :   // attributes before inserting the node into the document.
         301               0 :   if (aNotify && IsInDoc() && mIsDoneAddingChildren &&
         302                 :       aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::data) {
         303               0 :     nsAutoString type;
         304               0 :     GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
         305               0 :     LoadObject(aValue, aNotify, NS_ConvertUTF16toUTF8(type), true);
         306                 :   }
         307                 :
         308                 :   return nsGenericHTMLFormElement::SetAttr(aNameSpaceID, aName, aPrefix,
         309               0 :                                            aValue, aNotify);
         310                 : }
         311                 :
         312                 : nsresult
         313               0 : nsHTMLObjectElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,
         314                 :                                bool aNotify)
         315                 : {
         316               0 :   if (aNameSpaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::data) {
         317               0 :     Fallback(aNotify);
         318                 :   }
         319                 :
         320               0 :   return nsGenericHTMLFormElement::UnsetAttr(aNameSpaceID, aAttribute, aNotify);
         321                 : }
         322                 :
         323                 : bool
         324               0 : nsHTMLObjectElement::IsFocusableForTabIndex()
         325                 : {
         326               0 :   nsIDocument* doc = GetCurrentDoc();
         327               0 :   if (!doc || doc->HasFlag(NODE_IS_EDITABLE)) {
         328               0 :     return false;
         329                 :   }
         330                 :
         331               0 :   return IsEditableRoot() || (Type() == eType_Document &&
         332               0 :                               nsContentUtils::IsSubDocumentTabbable(this));
         333                 : }
         334                 :
         335                 : bool
         336               0 : nsHTMLObjectElement::IsHTMLFocusable(bool aWithMouse,
         337                 :                                      bool *aIsFocusable, PRInt32 *aTabIndex)
         338                 : {
         339                 :   // TODO: this should probably be managed directly by IsHTMLFocusable.
         340                 :   // See bug 597242.
         341               0 :   nsIDocument *doc = GetCurrentDoc();
         342               0 :   if (!doc || doc->HasFlag(NODE_IS_EDITABLE)) {
         343               0 :     if (aTabIndex) {
         344               0 :       GetTabIndex(aTabIndex);
         345                 :     }
         346                 :
         347               0 :     *aIsFocusable = false;
         348                 :
         349               0 :     return false;
         350                 :   }
         351                 :
         352                 :   // This method doesn't call nsGenericHTMLFormElement intentionally.
         353                 :   // TODO: It should probably be changed when bug 597242 will be fixed.
         354               0 :   if (Type() == eType_Plugin || IsEditableRoot() ||
         355               0 :       (Type() == eType_Document && nsContentUtils::IsSubDocumentTabbable(this))) {
         356                 :     // Has plugin content: let the plugin decide what to do in terms of
         357                 :     // internal focus from mouse clicks
         358               0 :     if (aTabIndex) {
         359               0 :       GetTabIndex(aTabIndex);
         360                 :     }
         361                 :
         362               0 :     *aIsFocusable = true;
         363                 :
         364               0 :     return false;
         365                 :   }
         366                 :
         367                 :   // TODO: this should probably be managed directly by IsHTMLFocusable.
         368                 :   // See bug 597242.
         369               0 :   const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsGkAtoms::tabindex);
         370                 :
         371               0 :   *aIsFocusable = attrVal && attrVal->Type() == nsAttrValue::eInteger;
         372                 :
         373               0 :   if (aTabIndex && *aIsFocusable) {
         374               0 :     *aTabIndex = attrVal->GetIntegerValue();
         375                 :   }
         376                 :
         377               0 :   return false;
         378                 : }
         379                 :
         380                 : nsIContent::IMEState
         381               0 : nsHTMLObjectElement::GetDesiredIMEState()
         382                 : {
         383               0 :   if (Type() == eType_Plugin) {
         384               0 :     return IMEState(IMEState::PLUGIN);
         385                 :   }
         386                 :
         387               0 :   return nsGenericHTMLFormElement::GetDesiredIMEState();
         388                 : }
         389                 :
         390                 : NS_IMETHODIMP
         391               0 : nsHTMLObjectElement::Reset()
         392                 : {
         393               0 :   return NS_OK;
         394                 : }
         395                 :
         396                 : NS_IMETHODIMP
         397               0 : nsHTMLObjectElement::SubmitNamesValues(nsFormSubmission *aFormSubmission)
         398                 : {
         399               0 :   nsAutoString name;
         400               0 :   if (!GetAttr(kNameSpaceID_None, nsGkAtoms::name, name)) {
         401                 :     // No name, don't submit.
         402                 :
         403               0 :     return NS_OK;
         404                 :   }
         405                 :
         406               0 :   nsIFrame* frame = GetPrimaryFrame();
         407                 :
         408               0 :   nsIObjectFrame *objFrame = do_QueryFrame(frame);
         409               0 :   if (!objFrame) {
         410                 :     // No frame, nothing to submit.
         411                 :
         412               0 :     return NS_OK;
         413                 :   }
         414                 :
         415               0 :   nsRefPtr<nsNPAPIPluginInstance> pi;
         416               0 :   objFrame->GetPluginInstance(getter_AddRefs(pi));
         417               0 :   if (!pi)
         418               0 :     return NS_OK;
         419                 :
         420               0 :   nsAutoString value;
         421               0 :   nsresult rv = pi->GetFormValue(value);
         422               0 :   NS_ENSURE_SUCCESS(rv, rv);
         423                 :
         424               0 :   return aFormSubmission->AddNameValuePair(name, value);
         425                 : }
         426                 :
         427               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Align, align)
         428               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Archive, archive)
         429               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Border, border)
         430               0 : NS_IMPL_URI_ATTR_WITH_BASE(nsHTMLObjectElement, Code, code, codebase)
         431               0 : NS_IMPL_URI_ATTR(nsHTMLObjectElement, CodeBase, codebase)
         432               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, CodeType, codetype)
         433               0 : NS_IMPL_URI_ATTR_WITH_BASE(nsHTMLObjectElement, Data, data, codebase)
         434               0 : NS_IMPL_BOOL_ATTR(nsHTMLObjectElement, Declare, declare)
         435               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Height, height)
         436               0 : NS_IMPL_INT_ATTR(nsHTMLObjectElement, Hspace, hspace)
         437               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Name, name)
         438               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Standby, standby)
         439               0 : NS_IMPL_INT_ATTR_DEFAULT_VALUE(nsHTMLObjectElement, TabIndex, tabindex,
         440                 :                                IsFocusableForTabIndex() ? 0 : -1)
         441               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Type, type)
         442               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, UseMap, usemap)
         443               0 : NS_IMPL_INT_ATTR(nsHTMLObjectElement, Vspace, vspace)
         444               0 : NS_IMPL_STRING_ATTR(nsHTMLObjectElement, Width, width)
         445                 :
         446                 : NS_IMETHODIMP
         447               0 : nsHTMLObjectElement::GetContentDocument(nsIDOMDocument **aContentDocument)
         448                 : {
         449               0 :   NS_ENSURE_ARG_POINTER(aContentDocument);
         450                 :
         451               0 :   *aContentDocument = nsnull;
         452                 :
         453               0 :   if (!IsInDoc()) {
         454               0 :     return NS_OK;
         455                 :   }
         456                 :
         457                 :   // XXXbz should this use GetCurrentDoc()?  sXBL/XBL2 issue!
         458               0 :   nsIDocument *sub_doc = OwnerDoc()->GetSubDocumentFor(this);
         459               0 :   if (!sub_doc) {
         460               0 :     return NS_OK;
         461                 :   }
         462                 :
         463               0 :   return CallQueryInterface(sub_doc, aContentDocument);
         464                 : }
         465                 :
         466                 : NS_IMETHODIMP
         467               0 : nsHTMLObjectElement::GetSVGDocument(nsIDOMDocument **aResult)
         468                 : {
         469               0 :   return GetContentDocument(aResult);
         470                 : }
         471                 :
         472                 : bool
         473               0 : nsHTMLObjectElement::ParseAttribute(PRInt32 aNamespaceID,
         474                 :                                     nsIAtom *aAttribute,
         475                 :                                     const nsAString &aValue,
         476                 :                                     nsAttrValue &aResult)
         477                 : {
         478               0 :   if (aNamespaceID == kNameSpaceID_None) {
         479               0 :     if (aAttribute == nsGkAtoms::align) {
         480               0 :       return ParseAlignValue(aValue, aResult);
         481                 :     }
         482               0 :     if (ParseImageAttribute(aAttribute, aValue, aResult)) {
         483               0 :       return true;
         484                 :     }
         485                 :   }
         486                 :
         487                 :   return nsGenericHTMLFormElement::ParseAttribute(aNamespaceID, aAttribute,
         488               0 :                                                   aValue, aResult);
         489                 : }
         490                 :
         491                 : static void
         492               0 : MapAttributesIntoRule(const nsMappedAttributes *aAttributes,
         493                 :                       nsRuleData *aData)
         494                 : {
         495               0 :   nsGenericHTMLFormElement::MapImageAlignAttributeInto(aAttributes, aData);
         496               0 :   nsGenericHTMLFormElement::MapImageBorderAttributeInto(aAttributes, aData);
         497               0 :   nsGenericHTMLFormElement::MapImageMarginAttributeInto(aAttributes, aData);
         498               0 :   nsGenericHTMLFormElement::MapImageSizeAttributesInto(aAttributes, aData);
         499               0 :   nsGenericHTMLFormElement::MapCommonAttributesInto(aAttributes, aData);
         500               0 : }
         501                 :
         502                 : NS_IMETHODIMP_(bool)
         503               0 : nsHTMLObjectElement::IsAttributeMapped(const nsIAtom *aAttribute) const
         504                 : {
         505                 :   static const MappedAttributeEntry* const map[] = {
         506                 :     sCommonAttributeMap,
         507                 :     sImageMarginSizeAttributeMap,
         508                 :     sImageBorderAttributeMap,
         509                 :     sImageAlignAttributeMap,
         510                 :   };
         511                 :
         512               0 :   return FindAttributeDependence(aAttribute, map);
         513                 : }
         514                 :
         515                 :
         516                 : nsMapRuleToAttributesFunc
         517               0 : nsHTMLObjectElement::GetAttributeMappingFunction() const
         518                 : {
         519               0 :   return &MapAttributesIntoRule;
         520                 : }
         521                 :
         522                 : void
         523               0 : nsHTMLObjectElement::StartObjectLoad(bool aNotify)
         524                 : {
         525               0 :   nsAutoString type;
         526               0 :   GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
         527               0 :   NS_ConvertUTF16toUTF8 ctype(type);
         528                 :
         529               0 :   nsAutoString uri;
         530               0 :   if (GetAttr(kNameSpaceID_None, nsGkAtoms::data, uri)) {
         531               0 :     LoadObject(uri, aNotify, ctype);
         532                 :   }
         533                 :   else {
         534                 :     // Be sure to call the nsIURI version if we have no attribute
         535                 :     // That handles the case where no URI is specified. An empty string would
         536                 :     // get interpreted as the page itself, instead of absence of URI.
         537               0 :     LoadObject(nsnull, aNotify, ctype);
         538                 :   }
         539               0 :   SetIsNetworkCreated(false);
         540               0 : }
         541                 :
         542                 : nsEventStates
         543               0 : nsHTMLObjectElement::IntrinsicState() const
         544                 : {
         545               0 :   return nsGenericHTMLFormElement::IntrinsicState() | ObjectState();
         546                 : }
         547                 :
         548                 : PRUint32
         549               0 : nsHTMLObjectElement::GetCapabilities() const
         550                 : {
         551               0 :   return nsObjectLoadingContent::GetCapabilities() | eSupportClassID;
         552                 : }
         553                 :
         554                 : void
         555               0 : nsHTMLObjectElement::DestroyContent()
         556                 : {
         557               0 :   RemovedFromDocument();
         558               0 :   nsGenericHTMLFormElement::DestroyContent();
         559               0 : }
         560                 :
         561                 : nsresult
         562               0 : nsHTMLObjectElement::CopyInnerTo(nsGenericElement* aDest) const
         563                 : {
         564               0 :   nsresult rv = nsGenericHTMLFormElement::CopyInnerTo(aDest);
         565               0 :   NS_ENSURE_SUCCESS(rv, rv);
         566                 :
         567               0 :   if (aDest->OwnerDoc()->IsStaticDocument()) {
         568               0 :     CreateStaticClone(static_cast<nsHTMLObjectElement*>(aDest));
         569                 :   }
         570                 :
         571               0 :   return rv;
         572            4392 : }

Generated by: LCOV version 1.7