LCOV - code coverage report
Current view: directory - content/html/content/src - nsHTMLMenuItemElement.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 210 0 0.0 %
Date: 2012-06-02 Functions: 57 0 0.0 %

       1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2                 : /* ***** BEGIN LICENSE BLOCK *****
       3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       4                 :  *
       5                 :  * The contents of this file are subject to the Mozilla Public License Version
       6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       7                 :  * the License. You may obtain a copy of the License at
       8                 :  * http://www.mozilla.org/MPL/
       9                 :  *
      10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      12                 :  * for the specific language governing rights and limitations under the
      13                 :  * License.
      14                 :  *
      15                 :  * The Original Code is Mozilla.
      16                 :  *
      17                 :  * The Initial Developer of the Original Code is Mozilla Foundation
      18                 :  * Portions created by the Initial Developer are Copyright (C) 2011
      19                 :  * the Initial Developer. All Rights Reserved.
      20                 :  *
      21                 :  * Contributor(s):
      22                 :  *
      23                 :  * Alternatively, the contents of this file may be used under the terms of
      24                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
      25                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      26                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      27                 :  * of those above. If you wish to allow use of your version of this file only
      28                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      29                 :  * use your version of this file under the terms of the MPL, indicate your
      30                 :  * decision by deleting the provisions above and replace them with the notice
      31                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      32                 :  * the provisions above, a recipient may use your version of this file under
      33                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      34                 :  *
      35                 :  * ***** END LICENSE BLOCK ***** */
      36                 : 
      37                 : #include "nsGUIEvent.h"
      38                 : #include "nsEventDispatcher.h"
      39                 : #include "nsHTMLMenuItemElement.h"
      40                 : #include "nsContentUtils.h"
      41                 : 
      42                 : using namespace mozilla::dom;
      43                 : 
      44                 : // First bits are needed for the menuitem type.
      45                 : #define NS_CHECKED_IS_TOGGLED (1 << 2)
      46                 : #define NS_ORIGINAL_CHECKED_VALUE (1 << 3)
      47                 : #define NS_MENUITEM_TYPE(bits) ((bits) & ~( \
      48                 :   NS_CHECKED_IS_TOGGLED | NS_ORIGINAL_CHECKED_VALUE))
      49                 : 
      50                 : enum CmdType                                                                 
      51                 : {                                                                            
      52                 :   CMD_TYPE_MENUITEM = 1,
      53                 :   CMD_TYPE_CHECKBOX,
      54                 :   CMD_TYPE_RADIO
      55                 : };
      56                 : 
      57                 : static const nsAttrValue::EnumTable kMenuItemTypeTable[] = {
      58                 :   { "menuitem", CMD_TYPE_MENUITEM },
      59                 :   { "checkbox", CMD_TYPE_CHECKBOX },
      60                 :   { "radio", CMD_TYPE_RADIO },
      61                 :   { 0 }
      62                 : };
      63                 : 
      64                 : static const nsAttrValue::EnumTable* kMenuItemDefaultType =
      65                 :   &kMenuItemTypeTable[0];
      66                 : 
      67                 : // A base class inherited by all radio visitors.
      68                 : class Visitor
      69                 : {
      70                 : public:
      71               0 :   Visitor() { }
      72               0 :   virtual ~Visitor() { }
      73                 : 
      74                 :   /**
      75                 :    * Visit a node in the tree. This is meant to be called on all radios in a
      76                 :    * group, sequentially. If the method returns false then the iteration is
      77                 :    * stopped.
      78                 :    */
      79                 :   virtual bool Visit(nsHTMLMenuItemElement* aMenuItem) = 0;
      80                 : };
      81                 : 
      82                 : // Find the selected radio, see GetSelectedRadio().
      83                 : class GetCheckedVisitor : public Visitor
      84               0 : {
      85                 : public:
      86               0 :   GetCheckedVisitor(nsHTMLMenuItemElement** aResult)
      87               0 :     : mResult(aResult)
      88               0 :     { }
      89               0 :   virtual bool Visit(nsHTMLMenuItemElement* aMenuItem)
      90                 :   {
      91               0 :     if (aMenuItem->IsChecked()) {
      92               0 :       *mResult = aMenuItem;
      93               0 :       return false;
      94                 :     }
      95               0 :     return true;
      96                 :   }
      97                 : protected:
      98                 :   nsHTMLMenuItemElement** mResult;
      99                 : };
     100                 : 
     101                 : // Deselect all radios except the one passed to the constructor.
     102                 : class ClearCheckedVisitor : public Visitor
     103               0 : {
     104                 : public:
     105               0 :   ClearCheckedVisitor(nsHTMLMenuItemElement* aExcludeMenuItem)
     106               0 :     : mExcludeMenuItem(aExcludeMenuItem)
     107               0 :     { }
     108               0 :   virtual bool Visit(nsHTMLMenuItemElement* aMenuItem)
     109                 :   {
     110               0 :     if (aMenuItem != mExcludeMenuItem && aMenuItem->IsChecked()) {
     111               0 :       aMenuItem->ClearChecked();
     112                 :     }
     113               0 :     return true;
     114                 :   }
     115                 : protected:
     116                 :   nsHTMLMenuItemElement* mExcludeMenuItem;
     117                 : };
     118                 : 
     119                 : // Get current value of the checked dirty flag. The same value is stored on all
     120                 : // radios in the group, so we need to check only the first one.
     121                 : class GetCheckedDirtyVisitor : public Visitor
     122               0 : {
     123                 : public:
     124               0 :   GetCheckedDirtyVisitor(bool* aCheckedDirty,
     125                 :                          nsHTMLMenuItemElement* aExcludeMenuItem)
     126                 :     : mCheckedDirty(aCheckedDirty),
     127               0 :       mExcludeMenuItem(aExcludeMenuItem)
     128               0 :     { }
     129               0 :   virtual bool Visit(nsHTMLMenuItemElement* aMenuItem)
     130                 :   {
     131               0 :     if (aMenuItem == mExcludeMenuItem) {
     132               0 :       return true;
     133                 :     }
     134               0 :     *mCheckedDirty = aMenuItem->IsCheckedDirty();
     135               0 :     return false;
     136                 :   }
     137                 : protected:
     138                 :   bool* mCheckedDirty;
     139                 :   nsHTMLMenuItemElement* mExcludeMenuItem;
     140                 : };
     141                 : 
     142                 : // Set checked dirty to true on all radios in the group.
     143                 : class SetCheckedDirtyVisitor : public Visitor
     144               0 : {
     145                 : public:
     146               0 :   SetCheckedDirtyVisitor()
     147               0 :     { }
     148               0 :   virtual bool Visit(nsHTMLMenuItemElement* aMenuItem)
     149                 :   {
     150               0 :     aMenuItem->SetCheckedDirty();
     151               0 :     return true;
     152                 :   }
     153                 : };
     154                 : 
     155                 : // A helper visitor that is used to combine two operations (visitors) to avoid
     156                 : // iterating over radios twice.
     157                 : class CombinedVisitor : public Visitor
     158               0 : {
     159                 : public:
     160               0 :   CombinedVisitor(Visitor* aVisitor1, Visitor* aVisitor2)
     161                 :     : mVisitor1(aVisitor1), mVisitor2(aVisitor2),
     162               0 :       mContinue1(true), mContinue2(true)
     163               0 :     { }
     164               0 :   virtual bool Visit(nsHTMLMenuItemElement* aMenuItem)
     165                 :   {
     166               0 :     if (mContinue1) {
     167               0 :       mContinue1 = mVisitor1->Visit(aMenuItem);
     168                 :     }
     169               0 :     if (mContinue2) {
     170               0 :       mContinue2 = mVisitor2->Visit(aMenuItem);
     171                 :     }
     172               0 :     return mContinue1 || mContinue2;
     173                 :   }
     174                 : protected:
     175                 :   Visitor* mVisitor1;
     176                 :   Visitor* mVisitor2;
     177                 :   bool mContinue1;
     178                 :   bool mContinue2;
     179                 : };
     180                 : 
     181                 : 
     182               0 : NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(MenuItem)
     183                 : 
     184               0 : nsHTMLMenuItemElement::nsHTMLMenuItemElement(
     185                 :   already_AddRefed<nsINodeInfo> aNodeInfo, FromParser aFromParser)
     186                 :   : nsGenericHTMLElement(aNodeInfo),
     187                 :     mType(kMenuItemDefaultType->value),
     188                 :     mParserCreating(false),
     189                 :     mShouldInitChecked(false),
     190                 :     mCheckedDirty(false),
     191               0 :     mChecked(false)
     192                 : {
     193               0 :   mParserCreating = aFromParser;
     194               0 : }
     195                 : 
     196               0 : nsHTMLMenuItemElement::~nsHTMLMenuItemElement()
     197                 : {
     198               0 : }
     199                 : 
     200                 : 
     201               0 : NS_IMPL_ADDREF_INHERITED(nsHTMLMenuItemElement, nsGenericElement)
     202               0 : NS_IMPL_RELEASE_INHERITED(nsHTMLMenuItemElement, nsGenericElement)
     203                 : 
     204                 : 
     205               0 : DOMCI_NODE_DATA(HTMLMenuItemElement, nsHTMLMenuItemElement)
     206                 : 
     207                 : // QueryInterface implementation for nsHTMLMenuItemElement
     208               0 : NS_INTERFACE_TABLE_HEAD(nsHTMLMenuItemElement)
     209               0 :   NS_HTML_CONTENT_INTERFACE_TABLE2(nsHTMLMenuItemElement,
     210                 :                                    nsIDOMHTMLCommandElement,
     211                 :                                    nsIDOMHTMLMenuItemElement)
     212               0 :   NS_HTML_CONTENT_INTERFACE_TABLE_TO_MAP_SEGUE(nsHTMLMenuItemElement,
     213                 :                                                nsGenericHTMLElement)
     214               0 : NS_HTML_CONTENT_INTERFACE_TABLE_TAIL_CLASSINFO(HTMLMenuItemElement)
     215                 : 
     216                 : //NS_IMPL_ELEMENT_CLONE(nsHTMLMenuItemElement)
     217                 : nsresult
     218               0 : nsHTMLMenuItemElement::Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const
     219                 : {
     220               0 :   *aResult = nsnull;
     221               0 :   nsCOMPtr<nsINodeInfo> ni = aNodeInfo;
     222                 :   nsRefPtr<nsHTMLMenuItemElement> it =
     223               0 :     new nsHTMLMenuItemElement(ni.forget(), NOT_FROM_PARSER);
     224               0 :   nsresult rv = CopyInnerTo(it);
     225               0 :   if (NS_SUCCEEDED(rv)) {
     226               0 :     switch (mType) {
     227                 :       case CMD_TYPE_CHECKBOX:
     228                 :       case CMD_TYPE_RADIO:
     229               0 :         if (mCheckedDirty) {
     230                 :           // We no longer have our original checked state.  Set our
     231                 :           // checked state on the clone.
     232               0 :           it->mCheckedDirty = true;
     233               0 :           it->mChecked = mChecked;
     234                 :         }
     235               0 :         break;
     236                 :     }
     237                 : 
     238               0 :     it.forget(aResult);
     239                 :   }
     240                 : 
     241               0 :   return rv;
     242                 : }
     243                 : 
     244                 : 
     245               0 : NS_IMPL_ENUM_ATTR_DEFAULT_VALUE(nsHTMLMenuItemElement, Type, type,
     246                 :                                 kMenuItemDefaultType->tag)
     247                 : // GetText returns a whitespace compressed .textContent value.
     248               0 : NS_IMPL_STRING_ATTR_WITH_FALLBACK(nsHTMLMenuItemElement, Label, label, GetText)
     249               0 : NS_IMPL_URI_ATTR(nsHTMLMenuItemElement, Icon, icon)
     250               0 : NS_IMPL_BOOL_ATTR(nsHTMLMenuItemElement, Disabled, disabled)
     251               0 : NS_IMPL_BOOL_ATTR(nsHTMLMenuItemElement, DefaultChecked, checked)
     252                 : //NS_IMPL_BOOL_ATTR(nsHTMLMenuItemElement, Checked, checked)
     253               0 : NS_IMPL_STRING_ATTR(nsHTMLMenuItemElement, Radiogroup, radiogroup)
     254                 : 
     255                 : NS_IMETHODIMP
     256               0 : nsHTMLMenuItemElement::GetChecked(bool* aChecked)
     257                 : {
     258               0 :   *aChecked = mChecked;
     259               0 :   return NS_OK;
     260                 : }
     261                 : 
     262                 : NS_IMETHODIMP
     263               0 : nsHTMLMenuItemElement::SetChecked(bool aChecked)
     264                 : {
     265               0 :   bool checkedChanged = mChecked != aChecked;
     266                 : 
     267               0 :   mChecked = aChecked;
     268                 : 
     269               0 :   if (mType == CMD_TYPE_RADIO) {
     270               0 :     if (checkedChanged) {
     271               0 :       if (mCheckedDirty) {
     272               0 :         ClearCheckedVisitor visitor(this);
     273               0 :         WalkRadioGroup(&visitor);
     274                 :       } else {
     275               0 :         ClearCheckedVisitor visitor1(this);
     276               0 :         SetCheckedDirtyVisitor visitor2;
     277               0 :         CombinedVisitor visitor(&visitor1, &visitor2);
     278               0 :         WalkRadioGroup(&visitor);
     279                 :       }
     280               0 :     } else if (!mCheckedDirty) {
     281               0 :       SetCheckedDirtyVisitor visitor;
     282               0 :       WalkRadioGroup(&visitor);
     283                 :     }
     284                 :   } else {
     285               0 :     mCheckedDirty = true;
     286                 :   }
     287                 : 
     288               0 :   return NS_OK;
     289                 : }
     290                 : 
     291                 : nsresult
     292               0 : nsHTMLMenuItemElement::PreHandleEvent(nsEventChainPreVisitor& aVisitor)
     293                 : {
     294               0 :   if (aVisitor.mEvent->message == NS_MOUSE_CLICK) {
     295                 : 
     296               0 :     bool originalCheckedValue = false;
     297               0 :     switch (mType) {
     298                 :       case CMD_TYPE_CHECKBOX:
     299               0 :         originalCheckedValue = mChecked;
     300               0 :         SetChecked(!originalCheckedValue);
     301               0 :         aVisitor.mItemFlags |= NS_CHECKED_IS_TOGGLED;
     302               0 :         break;
     303                 :       case CMD_TYPE_RADIO:
     304               0 :         nsCOMPtr<nsIDOMHTMLMenuItemElement> selectedRadio = GetSelectedRadio();
     305               0 :         aVisitor.mItemData = selectedRadio;
     306                 : 
     307               0 :         originalCheckedValue = mChecked;
     308               0 :         if (!originalCheckedValue) {
     309               0 :           SetChecked(true);
     310               0 :           aVisitor.mItemFlags |= NS_CHECKED_IS_TOGGLED;
     311                 :         }
     312                 :         break;
     313                 :     }
     314                 : 
     315               0 :     if (originalCheckedValue) {
     316               0 :       aVisitor.mItemFlags |= NS_ORIGINAL_CHECKED_VALUE;
     317                 :     }
     318                 : 
     319                 :     // We must cache type because mType may change during JS event.
     320               0 :     aVisitor.mItemFlags |= mType;
     321                 :   }
     322                 : 
     323               0 :   return nsGenericHTMLElement::PreHandleEvent(aVisitor);
     324                 : }
     325                 : 
     326                 : nsresult
     327               0 : nsHTMLMenuItemElement::PostHandleEvent(nsEventChainPostVisitor& aVisitor)
     328                 : {
     329                 :   // Check to see if the event was cancelled.
     330               0 :   if (aVisitor.mEvent->message == NS_MOUSE_CLICK &&
     331                 :       aVisitor.mItemFlags & NS_CHECKED_IS_TOGGLED &&
     332                 :       aVisitor.mEventStatus == nsEventStatus_eConsumeNoDefault) {
     333                 :     bool originalCheckedValue =
     334               0 :       !!(aVisitor.mItemFlags & NS_ORIGINAL_CHECKED_VALUE);
     335               0 :     PRUint8 oldType = NS_MENUITEM_TYPE(aVisitor.mItemFlags);
     336                 : 
     337                 :     nsCOMPtr<nsIDOMHTMLMenuItemElement> selectedRadio =
     338               0 :       do_QueryInterface(aVisitor.mItemData);
     339               0 :     if (selectedRadio) {
     340               0 :       selectedRadio->SetChecked(true);
     341               0 :       if (mType != CMD_TYPE_RADIO) {
     342               0 :         SetChecked(false);
     343                 :       }
     344               0 :     } else if (oldType == CMD_TYPE_CHECKBOX) {
     345               0 :       SetChecked(originalCheckedValue);
     346                 :     }
     347                 :   }
     348                 : 
     349               0 :   return NS_OK;
     350                 : }
     351                 : 
     352                 : nsresult
     353               0 : nsHTMLMenuItemElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
     354                 :                                   nsIContent* aBindingParent,
     355                 :                                   bool aCompileEventHandlers)
     356                 : {
     357                 :   nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,
     358                 :                                                  aBindingParent,
     359               0 :                                                  aCompileEventHandlers);
     360                 : 
     361               0 :   if (NS_SUCCEEDED(rv) && aDocument && mType == CMD_TYPE_RADIO) {
     362               0 :     AddedToRadioGroup();
     363                 :   }
     364                 : 
     365               0 :   return rv;
     366                 : }
     367                 : 
     368                 : bool
     369               0 : nsHTMLMenuItemElement::ParseAttribute(PRInt32 aNamespaceID,
     370                 :                                       nsIAtom* aAttribute,
     371                 :                                       const nsAString& aValue,
     372                 :                                       nsAttrValue& aResult)
     373                 : {
     374               0 :   if (aNamespaceID == kNameSpaceID_None) {
     375               0 :     if (aAttribute == nsGkAtoms::type) {
     376                 :       bool success = aResult.ParseEnumValue(aValue, kMenuItemTypeTable,
     377               0 :                                               false);
     378               0 :       if (success) {
     379               0 :         mType = aResult.GetEnumValue();
     380                 :       } else {
     381               0 :         mType = kMenuItemDefaultType->value;
     382                 :       }
     383                 : 
     384               0 :       return success;
     385                 :     }
     386                 : 
     387               0 :     if (aAttribute == nsGkAtoms::radiogroup) {
     388               0 :       aResult.ParseAtom(aValue);
     389               0 :       return true;
     390                 :     }
     391                 :   }
     392                 : 
     393                 :   return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
     394               0 :                                               aResult);
     395                 : }
     396                 : 
     397                 : void
     398               0 : nsHTMLMenuItemElement::DoneCreatingElement()
     399                 : {
     400               0 :   mParserCreating = false;
     401                 : 
     402               0 :   if (mShouldInitChecked) {
     403               0 :     InitChecked();
     404               0 :     mShouldInitChecked = false;
     405                 :   }
     406               0 : }
     407                 : 
     408                 : void
     409               0 : nsHTMLMenuItemElement::GetText(nsAString& aText)
     410                 : {
     411               0 :   nsAutoString text;
     412               0 :   nsContentUtils::GetNodeTextContent(this, false, text);
     413                 : 
     414               0 :   text.CompressWhitespace(true, true);
     415               0 :   aText = text;
     416               0 : }
     417                 : 
     418                 : nsresult
     419               0 : nsHTMLMenuItemElement::AfterSetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
     420                 :                                     const nsAttrValue* aValue, bool aNotify)
     421                 : {
     422               0 :   if (aNameSpaceID == kNameSpaceID_None) {
     423               0 :     if ((aName == nsGkAtoms::radiogroup || aName == nsGkAtoms::type) &&
     424                 :         mType == CMD_TYPE_RADIO &&
     425               0 :         !mParserCreating) {
     426               0 :       if (IsInDoc() && GetParent()) {
     427               0 :         AddedToRadioGroup();
     428                 :       }
     429                 :     }
     430                 : 
     431                 :     // Checked must be set no matter what type of menuitem it is, since
     432                 :     // GetChecked() must reflect the new value
     433               0 :     if (aName == nsGkAtoms::checked &&
     434               0 :         !mCheckedDirty) {
     435               0 :       if (mParserCreating) {
     436               0 :         mShouldInitChecked = true;
     437                 :       } else {
     438               0 :         InitChecked();
     439                 :       }
     440                 :     }
     441                 :   }
     442                 : 
     443                 :   return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName, aValue,
     444               0 :                                             aNotify);
     445                 : }
     446                 : 
     447                 : void
     448               0 : nsHTMLMenuItemElement::WalkRadioGroup(Visitor* aVisitor)
     449                 : {
     450               0 :   nsIContent* parent = GetParent();
     451               0 :   if (!parent) {
     452               0 :     aVisitor->Visit(this);
     453               0 :     return;
     454                 :   }
     455                 : 
     456                 :   nsAttrInfo info1(GetAttrInfo(kNameSpaceID_None,
     457               0 :                                nsGkAtoms::radiogroup));
     458               0 :   bool info1Empty = !info1.mValue || info1.mValue->IsEmptyString();
     459                 : 
     460               0 :   for (nsIContent* cur = parent->GetFirstChild();
     461                 :        cur;
     462               0 :        cur = cur->GetNextSibling()) {
     463               0 :     nsHTMLMenuItemElement* menuitem = nsHTMLMenuItemElement::FromContent(cur);
     464                 : 
     465               0 :     if (!menuitem || menuitem->GetType() != CMD_TYPE_RADIO) {
     466               0 :       continue;
     467                 :     }
     468                 : 
     469                 :     nsAttrInfo info2(menuitem->GetAttrInfo(kNameSpaceID_None,
     470               0 :                                            nsGkAtoms::radiogroup));
     471               0 :     bool info2Empty = !info2.mValue || info2.mValue->IsEmptyString();
     472                 : 
     473               0 :     if (info1Empty != info2Empty ||
     474               0 :         (info1.mValue && info2.mValue && !info1.mValue->Equals(*info2.mValue))) {
     475               0 :       continue;
     476                 :     }
     477                 : 
     478               0 :     if (!aVisitor->Visit(menuitem)) {
     479               0 :       break;
     480                 :     }
     481                 :   }
     482                 : }
     483                 : 
     484                 : nsHTMLMenuItemElement*
     485               0 : nsHTMLMenuItemElement::GetSelectedRadio()
     486                 : {
     487               0 :   nsHTMLMenuItemElement* result = nsnull;
     488                 : 
     489               0 :   GetCheckedVisitor visitor(&result);
     490               0 :   WalkRadioGroup(&visitor);
     491                 : 
     492               0 :   return result;
     493                 : }
     494                 : 
     495                 : void
     496               0 : nsHTMLMenuItemElement::AddedToRadioGroup()
     497                 : {
     498               0 :   bool checkedDirty = mCheckedDirty;
     499               0 :   if (mChecked) {
     500               0 :     ClearCheckedVisitor visitor1(this);
     501               0 :     GetCheckedDirtyVisitor visitor2(&checkedDirty, this);
     502               0 :     CombinedVisitor visitor(&visitor1, &visitor2);
     503               0 :     WalkRadioGroup(&visitor);
     504                 :   } else {
     505               0 :     GetCheckedDirtyVisitor visitor(&checkedDirty, this);
     506               0 :     WalkRadioGroup(&visitor);
     507                 :   }
     508               0 :   mCheckedDirty = checkedDirty;
     509               0 : }
     510                 : 
     511                 : void
     512               0 : nsHTMLMenuItemElement::InitChecked()
     513                 : {
     514                 :   bool defaultChecked;
     515               0 :   GetDefaultChecked(&defaultChecked);
     516               0 :   mChecked = defaultChecked;
     517               0 :   if (mType == CMD_TYPE_RADIO) {
     518               0 :     ClearCheckedVisitor visitor(this);
     519               0 :     WalkRadioGroup(&visitor);
     520                 :   }
     521               0 : }

Generated by: LCOV version 1.7