Bug 1217320 - Remove more XPIDL signature comments in .cpp files. r=froydnj
authorBirunthan Mohanathas <birunthan@mohanathas.com>
Tue, 27 Oct 2015 06:54:25 +0200
changeset 269682 ef10857254a01368861d9c1cc0105de89be6d169
parent 269680 c0a884282954a8aaaee14d3c315c4b7d215f1fac
child 269683 cab34e0b0a7b02fa3b4e86e89c24d48cd96c1cbe
push id29588
push userkwierso@gmail.com
push dateTue, 27 Oct 2015 19:18:01 +0000
treeherdermozilla-central@5430b2dba98b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1217320
milestone44.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1217320 - Remove more XPIDL signature comments in .cpp files. r=froydnj Comment-only, DONTBUILD.
dom/audiochannel/AudioChannelAgent.cpp
dom/base/DOMException.cpp
dom/base/nsDocument.cpp
dom/canvas/CanvasRenderingContext2D.cpp
dom/gamepad/GamepadServiceTest.cpp
dom/html/nsHTMLDocument.cpp
dom/svg/DOMSVGPathSeg.cpp
dom/system/gonk/mozstumbler/MozStumbler.cpp
editor/txmgr/nsTransactionList.cpp
embedding/components/webbrowserpersist/nsWebBrowserPersist.cpp
image/RasterImage.cpp
image/SVGDocumentWrapper.cpp
image/VectorImage.cpp
image/encoders/jpeg/nsJPEGEncoder.cpp
image/encoders/png/nsPNGEncoder.cpp
image/imgLoader.cpp
image/imgRequest.cpp
intl/uconv/nsScriptableUConv.cpp
js/xpconnect/loader/mozJSComponentLoader.cpp
js/xpconnect/src/Sandbox.cpp
js/xpconnect/src/XPCComponents.cpp
js/xpconnect/src/XPCRuntimeService.cpp
js/xpconnect/tests/components/native/xpctest_params.cpp
layout/style/nsCSSRules.cpp
modules/libjar/zipwriter/nsDeflateConverter.cpp
modules/libjar/zipwriter/nsZipDataStream.cpp
modules/libjar/zipwriter/nsZipWriter.cpp
netwerk/base/LoadContextInfo.cpp
netwerk/cache/nsCacheService.cpp
security/manager/pki/nsNSSDialogs.cpp
security/manager/ssl/CertBlocklist.cpp
security/manager/ssl/nsCertTree.cpp
security/manager/ssl/nsNSSCertificateDB.cpp
security/manager/ssl/nsPK11TokenDB.cpp
security/manager/ssl/nsRandomGenerator.cpp
toolkit/components/perfmonitoring/nsPerformanceStats.cpp
xpcom/io/nsMultiplexInputStream.cpp
--- a/dom/audiochannel/AudioChannelAgent.cpp
+++ b/dom/audiochannel/AudioChannelAgent.cpp
@@ -55,28 +55,24 @@ AudioChannelAgent::Shutdown()
 }
 
 NS_IMETHODIMP AudioChannelAgent::GetAudioChannelType(int32_t *aAudioChannelType)
 {
   *aAudioChannelType = mAudioChannelType;
   return NS_OK;
 }
 
-/* boolean init (in nsIDOMWindow window, in long channelType,
- *               in nsIAudioChannelAgentCallback callback); */
 NS_IMETHODIMP
 AudioChannelAgent::Init(nsIDOMWindow* aWindow, int32_t aChannelType,
                         nsIAudioChannelAgentCallback *aCallback)
 {
   return InitInternal(aWindow, aChannelType, aCallback,
                       /* useWeakRef = */ false);
 }
 
-/* boolean initWithWeakCallback (in nsIDOMWindow window, in long channelType,
- *                               in nsIAudioChannelAgentCallback callback); */
 NS_IMETHODIMP
 AudioChannelAgent::InitWithWeakCallback(nsIDOMWindow* aWindow,
                                         int32_t aChannelType,
                                         nsIAudioChannelAgentCallback *aCallback)
 {
   return InitInternal(aWindow, aChannelType, aCallback,
                       /* useWeakRef = */ true);
 }
--- a/dom/base/DOMException.cpp
+++ b/dom/base/DOMException.cpp
@@ -443,19 +443,16 @@ Exception::ToString(nsACString& _retval)
   const char* data = mData ? "yes" : "no";
 
   _retval.Truncate();
   _retval.AppendPrintf(format, msg, mResult, resultName,
                        location.get(), data);
   return NS_OK;
 }
 
-/* void initialize (in AUTF8String aMessage, in nsresult aResult,
- *                  in AUTF8String aName, in nsIStackFrame aLocation,
- *                  in nsISupports aData, in nsIException aInner); */
 NS_IMETHODIMP
 Exception::Initialize(const nsACString& aMessage, nsresult aResult,
                       const nsACString& aName, nsIStackFrame *aLocation,
                       nsISupports *aData, nsIException *aInner)
 {
   NS_ENSURE_FALSE(mInitialized, NS_ERROR_ALREADY_INITIALIZED);
 
   mMessage = aMessage;
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -7593,17 +7593,16 @@ nsIDocument::GetDocumentURIObject() cons
   if (!mChromeXHRDocURI) {
     return GetDocumentURI();
   }
 
   return mChromeXHRDocURI;
 }
 
 
-// readonly attribute DOMString compatMode;
 // Returns "BackCompat" if we are in quirks mode, "CSS1Compat" if we are
 // in almost standards or full standards mode. See bug 105640.  This was
 // implemented to match MSIE's compatMode property.
 NS_IMETHODIMP
 nsDocument::GetCompatMode(nsAString& aCompatMode)
 {
   nsString temp;
   nsIDocument::GetCompatMode(temp);
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -5324,19 +5324,16 @@ CanvasRenderingContext2D::PutImageData(I
                                 imageData.Width(), imageData.Height(),
                                 &arr, true,
                                 JS::ToInt32(dirtyX),
                                 JS::ToInt32(dirtyY),
                                 JS::ToInt32(dirtyWidth),
                                 JS::ToInt32(dirtyHeight));
 }
 
-// void putImageData (in ImageData d, in float x, in float y);
-// void putImageData (in ImageData d, in double x, in double y, in double dirtyX, in double dirtyY, in double dirtyWidth, in double dirtyHeight);
-
 nsresult
 CanvasRenderingContext2D::PutImageData_explicit(int32_t x, int32_t y, uint32_t w, uint32_t h,
                                                 dom::Uint8ClampedArray* aArray,
                                                 bool hasDirtyRect, int32_t dirtyX, int32_t dirtyY,
                                                 int32_t dirtyWidth, int32_t dirtyHeight)
 {
   EnsureTarget();
   if (mDrawObserver) {
--- a/dom/gamepad/GamepadServiceTest.cpp
+++ b/dom/gamepad/GamepadServiceTest.cpp
@@ -54,39 +54,33 @@ GamepadServiceTest::AddGamepad(const cha
 }
 
 NS_IMETHODIMP GamepadServiceTest::RemoveGamepad(uint32_t aIndex)
 {
   GamepadFunctions::RemoveGamepad(aIndex);
   return NS_OK;
 }
 
-/* void newButtonEvent (in uint32_t index, in uint32_t button,
-   in boolean pressed); */
 NS_IMETHODIMP GamepadServiceTest::NewButtonEvent(uint32_t aIndex,
                                                  uint32_t aButton,
                                                  bool aPressed)
 {
   GamepadFunctions::NewButtonEvent(aIndex, aButton, aPressed);
   return NS_OK;
 }
 
-/* void newButtonEvent (in uint32_t index, in uint32_t button,
-   in boolean pressed, double value); */
 NS_IMETHODIMP GamepadServiceTest::NewButtonValueEvent(uint32_t aIndex,
                                                       uint32_t aButton,
                                                       bool aPressed,
                                                       double aValue)
 {
   GamepadFunctions::NewButtonEvent(aIndex, aButton, aPressed, aValue);
   return NS_OK;
 }
 
-/* void newAxisMoveEvent (in uint32_t index, in uint32_t axis,
-   in double value); */
 NS_IMETHODIMP GamepadServiceTest::NewAxisMoveEvent(uint32_t aIndex,
                                                    uint32_t aAxis,
                                                    double aValue)
 {
   GamepadFunctions::NewAxisMoveEvent(aIndex, aAxis, aValue);
   return NS_OK;
 }
 
--- a/dom/html/nsHTMLDocument.cpp
+++ b/dom/html/nsHTMLDocument.cpp
@@ -3189,18 +3189,16 @@ ConvertToMidasInternalCommand(const nsAS
   nsAutoString dummyString;
   bool dummyBool;
   return ConvertToMidasInternalCommandInner(inCommandID, dummyString,
                                             outCommandID, dummyCString,
                                             dummyBool, dummyBool, true);
 }
 
 /* TODO: don't let this call do anything if the page is not done loading */
-/* boolean execCommand(in DOMString commandID, in boolean doShowUI,
-                                               in DOMString value); */
 NS_IMETHODIMP
 nsHTMLDocument::ExecCommand(const nsAString& commandID,
                             bool doShowUI,
                             const nsAString& value,
                             bool* _retval)
 {
   ErrorResult rv;
   *_retval = ExecCommand(commandID, doShowUI, value, rv);
--- a/dom/svg/DOMSVGPathSeg.cpp
+++ b/dom/svg/DOMSVGPathSeg.cpp
@@ -151,17 +151,16 @@ DOMSVGPathSeg::IndexIsValid()
 }
 #endif
 
 
 ////////////////////////////////////////////////////////////////////////
 // Implementation of DOMSVGPathSeg sub-classes below this point
 
 #define IMPL_PROP_WITH_TYPE(segName, propName, index, type)                   \
-  /* attribute type propName; */                                              \
   type                                                                        \
   DOMSVGPathSeg##segName::propName()                                          \
   {                                                                           \
     if (mIsAnimValItem && HasOwner()) {                                       \
       Element()->FlushAnimations(); /* May make HasOwner() == false */        \
     }                                                                         \
     return type(HasOwner() ? InternalItem()[1+index] : mArgs[index]);         \
   }                                                                           \
--- a/dom/system/gonk/mozstumbler/MozStumbler.cpp
+++ b/dom/system/gonk/mozstumbler/MozStumbler.cpp
@@ -333,32 +333,30 @@ StumblerInfo::DumpStumblerInfo()
   STUMBLER_DBG("dispatch write event to thread\n");
   nsCOMPtr<nsIEventTarget> target = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
   MOZ_ASSERT(target);
 
   nsCOMPtr<nsIRunnable> event = new WriteStumbleOnThread(desc);
   target->Dispatch(event, NS_DISPATCH_NORMAL);
 }
 
-/* void notifyGetCellInfoList (in uint32_t count, [array, size_is (count)] in nsICellInfo result); */
 NS_IMETHODIMP
 StumblerInfo::NotifyGetCellInfoList(uint32_t count, nsICellInfo** aCellInfos)
 {
   MOZ_ASSERT(NS_IsMainThread());
   STUMBLER_DBG("There are %d cellinfo in the result\n", count);
 
   for (uint32_t i = 0; i < count; i++) {
     mCellInfo.AppendElement(aCellInfos[i]);
   }
   mCellInfoResponsesReceived++;
   DumpStumblerInfo();
   return NS_OK;
 }
 
-/* void notifyGetCellInfoListFailed (in DOMString error); */
 NS_IMETHODIMP StumblerInfo::NotifyGetCellInfoListFailed(const nsAString& error)
 {
   MOZ_ASSERT(NS_IsMainThread());
   mCellInfoResponsesReceived++;
   STUMBLER_ERR("NotifyGetCellInfoListFailedm CellInfoReadyNum=%d, mCellInfoResponsesExpected=%d, mIsWifiInfoResponseReceived=%d",
                 mCellInfoResponsesReceived, mCellInfoResponsesExpected, mIsWifiInfoResponseReceived);
   DumpStumblerInfo();
   return NS_OK;
--- a/editor/txmgr/nsTransactionList.cpp
+++ b/editor/txmgr/nsTransactionList.cpp
@@ -80,20 +80,16 @@ NS_IMETHODIMP nsTransactionList::ItemIsB
 
   NS_ENSURE_SUCCESS(result, result);
 
   NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);
 
   return item->GetIsBatch(aIsBatch);
 }
 
-/* void getData (in long aIndex,
-                 [optional] out unsigned long aLength,
-                 [array, size_is (aLength), retval]
-                 out nsISupports aData); */
 NS_IMETHODIMP nsTransactionList::GetData(int32_t aIndex,
                                          uint32_t *aLength,
                                          nsISupports ***aData)
 {
   nsCOMPtr<nsITransactionManager> txMgr = do_QueryReferent(mTxnMgr);
 
   NS_ENSURE_TRUE(txMgr, NS_ERROR_FAILURE);
 
--- a/embedding/components/webbrowserpersist/nsWebBrowserPersist.cpp
+++ b/embedding/components/webbrowserpersist/nsWebBrowserPersist.cpp
@@ -410,19 +410,16 @@ NS_IMETHODIMP nsWebBrowserPersist::SetPr
     nsIWebProgressListener * aProgressListener)
 {
     mProgressListener = aProgressListener;
     mProgressListener2 = do_QueryInterface(aProgressListener);
     mEventSink = do_GetInterface(aProgressListener);
     return NS_OK;
 }
 
-/* void saveURI (in nsIURI aURI, in nsISupports aCacheKey, in nsIURI aReferrer,
-   in nsIInputStream aPostData, in wstring aExtraHeaders,
-   in nsISupports aFile, in nsILoadContext aPrivayContext); */
 NS_IMETHODIMP nsWebBrowserPersist::SaveURI(
     nsIURI *aURI, nsISupports *aCacheKey,
     nsIURI *aReferrer, uint32_t aReferrerPolicy,
     nsIInputStream *aPostData, const char *aExtraHeaders,
     nsISupports *aFile, nsILoadContext* aPrivacyContext)
 {
     return SavePrivacyAwareURI(aURI, aCacheKey, aReferrer, aReferrerPolicy,
                                aPostData, aExtraHeaders, aFile,
@@ -528,17 +525,16 @@ NS_IMETHODIMP nsWebBrowserPersist::SaveD
     }
     if (NS_FAILED(rv)) {
         SendErrorStatusChange(true, rv, nullptr, mURI);
         EndDownload(rv);
     }
     return rv;
 }
 
-/* void cancel(nsresult aReason); */
 NS_IMETHODIMP nsWebBrowserPersist::Cancel(nsresult aReason)
 {
     mCancel = true;
     EndDownload(aReason);
     return NS_OK;
 }
 
 
@@ -997,18 +993,16 @@ nsWebBrowserPersist::OnDataAvailable(
     return NS_OK;
 }
 
 
 //*****************************************************************************
 // nsWebBrowserPersist::nsIProgressEventSink
 //*****************************************************************************
 
-/* void onProgress (in nsIRequest request, in nsISupports ctxt,
-    in long long aProgress, in long long aProgressMax); */
 NS_IMETHODIMP nsWebBrowserPersist::OnProgress(
     nsIRequest *request, nsISupports *ctxt, int64_t aProgress,
     int64_t aProgressMax)
 {
     if (!mProgressListener)
     {
         return NS_OK;
     }
@@ -1050,18 +1044,16 @@ NS_IMETHODIMP nsWebBrowserPersist::OnPro
     if (mEventSink)
     {
         mEventSink->OnProgress(request, ctxt, aProgress, aProgressMax);
     }
 
     return NS_OK;
 }
 
-/* void onStatus (in nsIRequest request, in nsISupports ctxt,
-    in nsresult status, in wstring statusArg); */
 NS_IMETHODIMP nsWebBrowserPersist::OnStatus(
     nsIRequest *request, nsISupports *ctxt, nsresult status,
     const char16_t *statusArg)
 {
     if (mProgressListener)
     {
         // We need to filter out non-error error codes.
         // Is the only NS_SUCCEEDED value NS_OK?
--- a/image/RasterImage.cpp
+++ b/image/RasterImage.cpp
@@ -158,17 +158,16 @@ RasterImage::Init(const char* aMimeType,
 
   // Mark us as initialized
   mInitialized = true;
 
   return NS_OK;
 }
 
 //******************************************************************************
-// [notxpcom] void requestRefresh ([const] in TimeStamp aTime);
 NS_IMETHODIMP_(void)
 RasterImage::RequestRefresh(const TimeStamp& aTime)
 {
   if (HadRecentRefresh(aTime)) {
     return;
   }
 
   EvaluateAnimation();
@@ -538,18 +537,16 @@ RasterImage::CopyFrame(uint32_t aWhichFr
 
   target->Flush();
   surf->Unmap();
 
   return surf.forget();
 }
 
 //******************************************************************************
-/* [noscript] SourceSurface getFrame(in uint32_t aWhichFrame,
- *                                   in uint32_t aFlags); */
 NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
 RasterImage::GetFrame(uint32_t aWhichFrame,
                       uint32_t aFlags)
 {
   return GetFrameInternal(mSize, aWhichFrame, aFlags).second().forget();
 }
 
 NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
@@ -967,17 +964,16 @@ RasterImage::ResetAnimation()
   // Start the animation again. It may not have been running before, if
   // mAnimationFinished was true before entering this function.
   EvaluateAnimation();
 
   return NS_OK;
 }
 
 //******************************************************************************
-// [notxpcom] void setAnimationStartTime ([const] in TimeStamp aTime);
 NS_IMETHODIMP_(void)
 RasterImage::SetAnimationStartTime(const TimeStamp& aTime)
 {
   if (mError || mAnimationMode == kDontAnimMode || mAnimating || !mAnim) {
     return;
   }
 
   mAnim->SetAnimationFrameTime(aTime);
@@ -1473,25 +1469,16 @@ RasterImage::DrawInternal(DrawableFrameR
   }
   if (couldRedecodeForBetterFrame) {
     return DrawResult::WRONG_SIZE;
   }
   return DrawResult::SUCCESS;
 }
 
 //******************************************************************************
-/* [noscript] void draw(in gfxContext aContext,
- *                      in Filter aFilter,
- *                      [const] in gfxMatrix aUserSpaceToImageSpace,
- *                      [const] in gfxRect aFill,
- *                      [const] in IntRect aSubimage,
- *                      [const] in IntSize aViewportSize,
- *                      [const] in SVGImageContext aSVGContext,
- *                      in uint32_t aWhichFrame,
- *                      in uint32_t aFlags); */
 NS_IMETHODIMP_(DrawResult)
 RasterImage::Draw(gfxContext* aContext,
                   const IntSize& aSize,
                   const ImageRegion& aRegion,
                   uint32_t aWhichFrame,
                   Filter aFilter,
                   const Maybe<SVGImageContext>& /*aSVGContext - ignored*/,
                   uint32_t aFlags)
--- a/image/SVGDocumentWrapper.cpp
+++ b/image/SVGDocumentWrapper.cpp
@@ -195,19 +195,16 @@ SVGDocumentWrapper::TickRefreshDriver()
     if (presContext) {
       presContext->RefreshDriver()->DoTick();
     }
   }
 }
 
 /** nsIStreamListener methods **/
 
-/* void onDataAvailable (in nsIRequest request, in nsISupports ctxt,
-                         in nsIInputStream inStr, in unsigned long sourceOffset,
-                         in unsigned long count); */
 NS_IMETHODIMP
 SVGDocumentWrapper::OnDataAvailable(nsIRequest* aRequest, nsISupports* ctxt,
                                     nsIInputStream* inStr,
                                     uint64_t sourceOffset,
                                     uint32_t count)
 {
   return mListener->OnDataAvailable(aRequest, ctxt, inStr,
                                     sourceOffset, count);
@@ -231,18 +228,16 @@ SVGDocumentWrapper::OnStartRequest(nsIRe
     if (NS_SUCCEEDED(rv)) {
       rv = mViewer->Open(nullptr, nullptr);
     }
   }
   return rv;
 }
 
 
-/* void onStopRequest (in nsIRequest request, in nsISupports ctxt,
-                       in nsresult status); */
 NS_IMETHODIMP
 SVGDocumentWrapper::OnStopRequest(nsIRequest* aRequest, nsISupports* ctxt,
                                   nsresult status)
 {
   if (mListener) {
     mListener->OnStopRequest(aRequest, ctxt, status);
     mListener = nullptr;
   }
--- a/image/VectorImage.cpp
+++ b/image/VectorImage.cpp
@@ -678,18 +678,16 @@ VectorImage::GetFirstFrameDelay()
 
 NS_IMETHODIMP_(bool)
 VectorImage::IsOpaque()
 {
   return false; // In general, SVG content is not opaque.
 }
 
 //******************************************************************************
-/* [noscript] SourceSurface getFrame(in uint32_t aWhichFrame,
- *                                   in uint32_t aFlags; */
 NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
 VectorImage::GetFrame(uint32_t aWhichFrame, uint32_t aFlags)
 {
   // Look up height & width
   // ----------------------
   SVGSVGElement* svgElem = mSVGDocumentWrapper->GetRootSVGElem();
   MOZ_ASSERT(svgElem, "Should have a root SVG elem, since we finished "
                       "loading without errors");
@@ -788,23 +786,16 @@ struct SVGDrawingParameters
   const Maybe<SVGImageContext>& svgContext;
   nsIntSize                     viewportSize;
   float                         animationTime;
   uint32_t                      flags;
   gfxFloat                      opacity;
 };
 
 //******************************************************************************
-/* [noscript] void draw(in gfxContext aContext,
- *                      [const] in nsIntSize aSize,
- *                      [const] in ImageRegion aRegion,
- *                      in uint32_t aWhichFrame,
- *                      in Filter aFilter,
- *                      [const] in MaybeSVGImageContext aSVGContext,
- *                      in uint32_t aFlags); */
 NS_IMETHODIMP_(DrawResult)
 VectorImage::Draw(gfxContext* aContext,
                   const nsIntSize& aSize,
                   const ImageRegion& aRegion,
                   uint32_t aWhichFrame,
                   Filter aFilter,
                   const Maybe<SVGImageContext>& aSVGContext,
                   uint32_t aFlags)
@@ -1129,18 +1120,16 @@ VectorImage::OnStartRequest(nsIRequest* 
   nsIDocument* document = mSVGDocumentWrapper->GetDocument();
   mLoadEventListener = new SVGLoadEventListener(document, this);
   mParseCompleteListener = new SVGParseCompleteListener(document, this);
 
   return NS_OK;
 }
 
 //******************************************************************************
-/* void onStopRequest(in nsIRequest request, in nsISupports ctxt,
-                      in nsresult status); */
 NS_IMETHODIMP
 VectorImage::OnStopRequest(nsIRequest* aRequest, nsISupports* aCtxt,
                            nsresult aStatus)
 {
   if (mError) {
     return NS_ERROR_FAILURE;
   }
 
@@ -1236,19 +1225,16 @@ VectorImage::OnSVGDocumentError()
     mProgressTracker->SyncNotifyProgress(progress);
   }
 }
 
 //------------------------------------------------------------------------------
 // nsIStreamListener method
 
 //******************************************************************************
-/* void onDataAvailable(in nsIRequest request, in nsISupports ctxt,
-                        in nsIInputStream inStr, in unsigned long sourceOffset,
-                        in unsigned long count); */
 NS_IMETHODIMP
 VectorImage::OnDataAvailable(nsIRequest* aRequest, nsISupports* aCtxt,
                              nsIInputStream* aInStr, uint64_t aSourceOffset,
                              uint32_t aCount)
 {
   if (mError) {
     return NS_ERROR_FAILURE;
   }
--- a/image/encoders/jpeg/nsJPEGEncoder.cpp
+++ b/image/encoders/jpeg/nsJPEGEncoder.cpp
@@ -263,18 +263,16 @@ nsJPEGEncoder::Available(uint64_t* _retv
 }
 
 NS_IMETHODIMP
 nsJPEGEncoder::Read(char* aBuf, uint32_t aCount, uint32_t* _retval)
 {
   return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, _retval);
 }
 
-/* [noscript] unsigned long readSegments (in nsWriteSegmentFun aWriter, in
-   voidPtr aClosure, in unsigned long aCount); */
 NS_IMETHODIMP
 nsJPEGEncoder::ReadSegments(nsWriteSegmentFun aWriter,
                             void* aClosure, uint32_t aCount, uint32_t* _retval)
 {
   // Avoid another thread reallocing the buffer underneath us
   ReentrantMonitorAutoEnter autoEnter(mReentrantMonitor);
 
   uint32_t maxCount = mImageBufferUsed - mImageBufferReadPoint;
--- a/image/encoders/png/nsPNGEncoder.cpp
+++ b/image/encoders/png/nsPNGEncoder.cpp
@@ -543,27 +543,22 @@ nsPNGEncoder::Available(uint64_t* _retva
   if (!mImageBuffer) {
     return NS_BASE_STREAM_CLOSED;
     }
 
   *_retval = mImageBufferUsed - mImageBufferReadPoint;
   return NS_OK;
 }
 
-/* [noscript] unsigned long read (in charPtr aBuf,
-                                  in unsigned long aCount); */
 NS_IMETHODIMP
 nsPNGEncoder::Read(char* aBuf, uint32_t aCount, uint32_t* _retval)
 {
   return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, _retval);
 }
 
-/* [noscript] unsigned long readSegments (in nsWriteSegmentFun aWriter,
-                                          in voidPtr aClosure,
-                                          in unsigned long aCount); */
 NS_IMETHODIMP
 nsPNGEncoder::ReadSegments(nsWriteSegmentFun aWriter,
                            void* aClosure, uint32_t aCount,
                            uint32_t* _retval)
 {
   // Avoid another thread reallocing the buffer underneath us
   ReentrantMonitorAutoEnter autoEnter(mReentrantMonitor);
 
--- a/image/imgLoader.cpp
+++ b/image/imgLoader.cpp
@@ -2003,25 +2003,16 @@ imgLoader::LoadImageXPCOM(nsIURI* aURI,
                             aCacheKey,
                             aContentPolicyType,
                             EmptyString(),
                             &proxy);
     *_retval = proxy;
     return rv;
 }
 
-// imgIRequest loadImage(in nsIURI aURI,
-//                       in nsIURI aInitialDocumentURL,
-//                       in nsIURI aReferrerURI,
-//                       in nsIPrincipal aLoadingPrincipal,
-//                       in nsILoadGroup aLoadGroup,
-//                       in imgINotificationObserver aObserver,
-//                       in nsISupports aCX,
-//                       in nsLoadFlags aLoadFlags,
-//                       in nsISupports cacheKey);
 nsresult
 imgLoader::LoadImage(nsIURI* aURI,
                      nsIURI* aInitialDocumentURI,
                      nsIURI* aReferrerURI,
                      ReferrerPolicy aReferrerPolicy,
                      nsIPrincipal* aLoadingPrincipal,
                      nsILoadGroup* aLoadGroup,
                      imgINotificationObserver* aObserver,
@@ -2289,21 +2280,16 @@ imgLoader::LoadImage(nsIURI* aURI,
     return rv;
   }
 
   NS_ASSERTION(*_retval, "imgLoader::LoadImage -- no return value");
 
   return NS_OK;
 }
 
-/* imgIRequest
-loadImageWithChannelXPCOM(in nsIChannel channel,
-                          in imgINotificationObserver aObserver,
-                          in nsISupports cx,
-                          out nsIStreamListener); */
 NS_IMETHODIMP
 imgLoader::LoadImageWithChannelXPCOM(nsIChannel* channel,
                                      imgINotificationObserver* aObserver,
                                      nsISupports* aCX,
                                      nsIStreamListener** listener,
                                      imgIRequest** _retval)
 {
     nsresult result;
@@ -2630,36 +2616,30 @@ ProxyListener::OnStartRequest(nsIRequest
         }
       }
     }
   }
 
   return mDestListener->OnStartRequest(aRequest, ctxt);
 }
 
-/* void onStopRequest (in nsIRequest request, in nsISupports ctxt,
-                       in nsresult status); */
 NS_IMETHODIMP
 ProxyListener::OnStopRequest(nsIRequest* aRequest,
                              nsISupports* ctxt,
                              nsresult status)
 {
   if (!mDestListener) {
     return NS_ERROR_FAILURE;
   }
 
   return mDestListener->OnStopRequest(aRequest, ctxt, status);
 }
 
 /** nsIStreamListener methods **/
 
-/* void onDataAvailable (in nsIRequest request, in nsISupports ctxt,
-                         in nsIInputStream inStr,
-                         in unsigned long long sourceOffset,
-                         in unsigned long count); */
 NS_IMETHODIMP
 ProxyListener::OnDataAvailable(nsIRequest* aRequest, nsISupports* ctxt,
                                nsIInputStream* inStr, uint64_t sourceOffset,
                                uint32_t count)
 {
   if (!mDestListener) {
     return NS_ERROR_FAILURE;
   }
@@ -2848,18 +2828,16 @@ imgCacheValidator::OnStartRequest(nsIReq
   }
 
   mNewRequest = nullptr;
   mNewEntry = nullptr;
 
   return mDestListener->OnStartRequest(aRequest, ctxt);
 }
 
-/* void onStopRequest (in nsIRequest request, in nsISupports ctxt,
-                       in nsresult status); */
 NS_IMETHODIMP
 imgCacheValidator::OnStopRequest(nsIRequest* aRequest,
                                  nsISupports* ctxt,
                                  nsresult status)
 {
   // Be sure we've released the document that we may have been holding on to.
   mContext = nullptr;
 
@@ -2868,20 +2846,16 @@ imgCacheValidator::OnStopRequest(nsIRequ
   }
 
   return mDestListener->OnStopRequest(aRequest, ctxt, status);
 }
 
 /** nsIStreamListener methods **/
 
 
-/* void
-   onDataAvailable (in nsIRequest request, in nsISupports ctxt,
-   in nsIInputStream inStr, in unsigned long long sourceOffset,
-   in unsigned long count); */
 NS_IMETHODIMP
 imgCacheValidator::OnDataAvailable(nsIRequest* aRequest, nsISupports* ctxt,
                                    nsIInputStream* inStr,
                                    uint64_t sourceOffset, uint32_t count)
 {
   if (!mDestListener) {
     // XXX see bug 113959
     uint32_t _retval;
--- a/image/imgRequest.cpp
+++ b/image/imgRequest.cpp
@@ -799,18 +799,16 @@ imgRequest::OnStartRequest(nsIRequest* a
            ("[this=%p] imgRequest::OnStartRequest -- "
             "RetargetDeliveryTo rv %d=%s\n",
             this, rv, NS_SUCCEEDED(rv) ? "succeeded" : "failed"));
   }
 
   return NS_OK;
 }
 
-/* void onStopRequest (in nsIRequest request, in nsISupports ctxt,
-                       nsresult status); */
 NS_IMETHODIMP
 imgRequest::OnStopRequest(nsIRequest* aRequest,
                           nsISupports* ctxt, nsresult status)
 {
   LOG_FUNC(GetImgLog(), "imgRequest::OnStopRequest");
   MOZ_ASSERT(NS_IsMainThread(), "Can't send notifications off-main-thread");
 
   RefPtr<Image> image = GetImage();
--- a/intl/uconv/nsScriptableUConv.cpp
+++ b/intl/uconv/nsScriptableUConv.cpp
@@ -125,19 +125,16 @@ nsScriptableUnicodeConverter::ConvertToU
 {
   nsACString::const_iterator i;
   aSrc.BeginReading(i);
   return ConvertFromByteArray(reinterpret_cast<const uint8_t*>(i.get()),
                               aSrc.Length(),
                               _retval);
 }
 
-/* AString convertFromByteArray([const,array,size_is(aCount)] in octet aData,
-                                in unsigned long aCount);
- */
 NS_IMETHODIMP
 nsScriptableUnicodeConverter::ConvertFromByteArray(const uint8_t* aData,
                                                    uint32_t aCount,
                                                    nsAString& _retval)
 {
   if (!mDecoder)
     return NS_ERROR_FAILURE;
 
@@ -163,20 +160,16 @@ nsScriptableUnicodeConverter::ConvertFro
     }
     free(buf);
     return rv;
   }
   return NS_ERROR_FAILURE;
 
 }
 
-/* void convertToByteArray(in AString aString,
-                          [optional] out unsigned long aLen,
-                          [array, size_is(aLen),retval] out octet aData);
- */
 NS_IMETHODIMP
 nsScriptableUnicodeConverter::ConvertToByteArray(const nsAString& aString,
                                                  uint32_t* aLen,
                                                  uint8_t** _aData)
 {
   char* data;
   int32_t len;
   nsresult rv = ConvertFromUnicodeWithLength(aString, &len, &data);
--- a/js/xpconnect/loader/mozJSComponentLoader.cpp
+++ b/js/xpconnect/loader/mozJSComponentLoader.cpp
@@ -1054,18 +1054,16 @@ mozJSComponentLoader::Import(const nsACS
             return NS_ERROR_FAILURE;
         }
 
         retval.setObject(*global);
     }
     return rv;
 }
 
-/* [noscript] JSObjectPtr importInto(in AUTF8String registryLocation,
-                                     in JSObjectPtr targetObj); */
 NS_IMETHODIMP
 mozJSComponentLoader::ImportInto(const nsACString& aLocation,
                                  JSObject* aTargetObj,
                                  nsAXPCNativeCallContext* cc,
                                  JSObject** _retval)
 {
     JSContext* callercx;
     nsresult rv = cc->GetJSContext(&callercx);
--- a/js/xpconnect/src/Sandbox.cpp
+++ b/js/xpconnect/src/Sandbox.cpp
@@ -1147,38 +1147,24 @@ xpc::CreateSandboxObject(JSContext* cx, 
 
     xpc::SetSandboxMetadata(cx, sandbox, options.metadata);
 
     JS_FireOnNewGlobalObject(cx, sandbox);
 
     return NS_OK;
 }
 
-/* bool call(in nsIXPConnectWrappedNative wrapper,
- *           in JSContextPtr cx,
- *           in JSObjectPtr obj,
- *           in uint32_t argc,
- *           in JSValPtr argv,
- *           in JSValPtr vp);
- */
 NS_IMETHODIMP
 nsXPCComponents_utils_Sandbox::Call(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
                                     JSObject* objArg, const CallArgs& args, bool* _retval)
 {
     RootedObject obj(cx, objArg);
     return CallOrConstruct(wrapper, cx, obj, args, _retval);
 }
 
-/* bool construct(in nsIXPConnectWrappedNative wrapper,
- *                in JSContextPtr cx,
- *                in JSObjectPtr obj,
- *                in uint32_t argc,
- *                in JSValPtr argv,
- *                in JSValPtr vp);
- */
 NS_IMETHODIMP
 nsXPCComponents_utils_Sandbox::Construct(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
                                          JSObject* objArg, const CallArgs& args, bool* _retval)
 {
     RootedObject obj(cx, objArg);
     return CallOrConstruct(wrapper, cx, obj, args, _retval);
 }
 
--- a/js/xpconnect/src/XPCComponents.cpp
+++ b/js/xpconnect/src/XPCComponents.cpp
@@ -110,18 +110,16 @@ public:
     nsXPCComponents_Interfaces();
 
 private:
     virtual ~nsXPCComponents_Interfaces();
 
     nsCOMArray<nsIInterfaceInfo> mInterfaces;
 };
 
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_Interfaces::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -337,18 +335,16 @@ public:
 
 private:
     virtual ~nsXPCComponents_InterfacesByID();
 
     nsCOMArray<nsIInterfaceInfo> mInterfaces;
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_InterfacesByID::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -566,18 +562,16 @@ public:
 public:
     nsXPCComponents_Classes();
 
 private:
     virtual ~nsXPCComponents_Classes();
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_Classes::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -775,18 +769,16 @@ public:
 public:
     nsXPCComponents_ClassesByID();
 
 private:
     virtual ~nsXPCComponents_ClassesByID();
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_ClassesByID::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -1007,18 +999,16 @@ public:
 public:
     nsXPCComponents_Results();
 
 private:
     virtual ~nsXPCComponents_Results();
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_Results::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -1199,18 +1189,16 @@ public:
 private:
     virtual ~nsXPCComponents_ID();
     static nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
                                     JSContext* cx, HandleObject obj,
                                     const CallArgs& args, bool* _retval);
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_ID::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -1398,18 +1386,16 @@ public:
 private:
     virtual ~nsXPCComponents_Exception();
     static nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
                                     JSContext* cx, HandleObject obj,
                                     const CallArgs& args, bool* _retval);
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_Exception::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -1765,18 +1751,16 @@ private:
                              const CallArgs& args, bool* _retval);
 private:
     RefPtr<nsIJSCID> mClassID;
     RefPtr<nsIJSIID> mInterfaceID;
     char*              mInitializer;
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCConstructor::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -1992,18 +1976,16 @@ public:
 private:
     virtual ~nsXPCComponents_Constructor();
     static nsresult CallOrConstruct(nsIXPConnectWrappedNative* wrapper,
                                     JSContext* cx, HandleObject obj,
                                     const CallArgs& args, bool* _retval);
 };
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 nsXPCComponents_Constructor::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
@@ -2481,60 +2463,50 @@ nsXPCComponents_Utils::SetSandboxMetadat
         return NS_ERROR_INVALID_ARG;
 
     nsresult rv = xpc::SetSandboxMetadata(cx, sandbox, metadataVal);
     NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
 }
 
-/* JSObject import (in AUTF8String registryLocation,
- *                  [optional] in JSObject targetObj);
- */
 NS_IMETHODIMP
 nsXPCComponents_Utils::Import(const nsACString& registryLocation,
                               HandleValue targetObj,
                               JSContext* cx,
                               uint8_t optionalArgc,
                               MutableHandleValue retval)
 {
     nsCOMPtr<xpcIJSModuleLoader> moduleloader =
         do_GetService(MOZJSCOMPONENTLOADER_CONTRACTID);
     if (!moduleloader)
         return NS_ERROR_FAILURE;
     return moduleloader->Import(registryLocation, targetObj, cx, optionalArgc, retval);
 }
 
-/* boolean isModuleLoaded (in AUTF8String registryLocation);
- */
 NS_IMETHODIMP
 nsXPCComponents_Utils::IsModuleLoaded(const nsACString& registryLocation, bool* retval)
 {
     nsCOMPtr<xpcIJSModuleLoader> moduleloader =
         do_GetService(MOZJSCOMPONENTLOADER_CONTRACTID);
     if (!moduleloader)
         return NS_ERROR_FAILURE;
     return moduleloader->IsModuleLoaded(registryLocation, retval);
 }
 
-/* unload (in AUTF8String registryLocation);
- */
 NS_IMETHODIMP
 nsXPCComponents_Utils::Unload(const nsACString & registryLocation)
 {
     nsCOMPtr<xpcIJSModuleLoader> moduleloader =
         do_GetService(MOZJSCOMPONENTLOADER_CONTRACTID);
     if (!moduleloader)
         return NS_ERROR_FAILURE;
     return moduleloader->Unload(registryLocation);
 }
 
-/*
- * JSObject importGlobalProperties (in jsval aPropertyList);
- */
 NS_IMETHODIMP
 nsXPCComponents_Utils::ImportGlobalProperties(HandleValue aPropertyList,
                                               JSContext* cx)
 {
     RootedObject global(cx, CurrentGlobalOrNull(cx));
     MOZ_ASSERT(global);
 
     // Don't allow doing this if the global is a Window
@@ -2709,18 +2681,16 @@ nsXPCComponents_Utils::GetJSTestingFunct
 {
     JSObject* obj = js::GetTestingFunctions(cx);
     if (!obj)
         return NS_ERROR_XPC_JAVASCRIPT_ERROR;
     retval.setObject(*obj);
     return NS_OK;
 }
 
-/* jsval callFunctionWithStack(in jsval function, in nsIStackFrame stack,
-                               in AString asyncCause); */
 NS_IMETHODIMP
 nsXPCComponents_Utils::CallFunctionWithAsyncStack(HandleValue function,
                                                   nsIStackFrame* stack,
                                                   const nsAString& asyncCause,
                                                   JSContext* cx,
                                                   MutableHandleValue retval)
 {
     nsresult rv;
--- a/js/xpconnect/src/XPCRuntimeService.cpp
+++ b/js/xpconnect/src/XPCRuntimeService.cpp
@@ -74,18 +74,16 @@ BackstagePass::Enumerate(nsIXPConnectWra
                          JSObject* objArg, bool* _retval)
 {
     JS::RootedObject obj(cx, objArg);
     *_retval = mozilla::dom::SystemGlobalEnumerate(cx, obj);
     return *_retval ? NS_OK : NS_ERROR_FAILURE;
 }
 
 /***************************************************************************/
-/* void getInterfaces (out uint32_t count, [array, size_is (count), retval]
-                       out nsIIDPtr array); */
 NS_IMETHODIMP
 BackstagePass::GetInterfaces(uint32_t* aCount, nsIID * **aArray)
 {
     const uint32_t count = 2;
     *aCount = count;
     nsIID** array;
     *aArray = array = static_cast<nsIID**>(moz_xmalloc(count * sizeof(nsIID*)));
     if (!array)
--- a/js/xpconnect/tests/components/native/xpctest_params.cpp
+++ b/js/xpconnect/tests/components/native/xpctest_params.cpp
@@ -183,89 +183,65 @@ NS_IMETHODIMP nsXPCTestParams::TestJsval
                                          JS::MutableHandle<JS::Value> b,
                                          JS::MutableHandle<JS::Value> _retval)
 {
     _retval.set(b);
     b.set(a);
     return NS_OK;
 }
 
-/* void testShortArray (in unsigned long aLength, [array, size_is (aLength)] in short a,
- *                      inout unsigned long bLength, [array, size_is (bLength)] inout short b,
- *                      out unsigned long rvLength, [array, size_is (rvLength), retval] out short rv); */
 NS_IMETHODIMP nsXPCTestParams::TestShortArray(uint32_t aLength, int16_t* a,
                                               uint32_t* bLength, int16_t** b,
                                               uint32_t* rvLength, int16_t** rv)
 {
     BUFFER_METHOD_IMPL(int16_t, 0, TAKE_OWNERSHIP_NOOP);
 }
 
-/* void testDoubleArray (in unsigned long aLength, [array, size_is (aLength)] in double a,
- *                       inout unsigned long bLength, [array, size_is (bLength)] inout double b,
- *                       out unsigned long rvLength, [array, size_is (rvLength), retval] out double rv); */
 NS_IMETHODIMP nsXPCTestParams::TestDoubleArray(uint32_t aLength, double* a,
                                                uint32_t* bLength, double** b,
                                                uint32_t* rvLength,  double** rv)
 {
     BUFFER_METHOD_IMPL(double, 0, TAKE_OWNERSHIP_NOOP);
 }
 
-/* void testStringArray (in unsigned long aLength, [array, size_is (aLength)] in string a,
- *                       inout unsigned long bLength, [array, size_is (bLength)] inout string b,
- *                       out unsigned long rvLength, [array, size_is (rvLength), retval] out string rv); */
 NS_IMETHODIMP nsXPCTestParams::TestStringArray(uint32_t aLength, const char * *a,
                                                uint32_t* bLength, char * **b,
                                                uint32_t* rvLength, char * **rv)
 {
     BUFFER_METHOD_IMPL(char*, 0, TAKE_OWNERSHIP_STRING);
 }
 
-/* void testWstringArray (in unsigned long aLength, [array, size_is (aLength)] in wstring a,
- *                        inout unsigned long bLength, [array, size_is (bLength)] inout wstring b,
- *                        out unsigned long rvLength, [array, size_is (rvLength), retval] out wstring rv); */
 NS_IMETHODIMP nsXPCTestParams::TestWstringArray(uint32_t aLength, const char16_t * *a,
                                                 uint32_t* bLength, char16_t * **b,
                                                 uint32_t* rvLength, char16_t * **rv)
 {
     BUFFER_METHOD_IMPL(char16_t*, 0, TAKE_OWNERSHIP_WSTRING);
 }
 
-/* void testInterfaceArray (in unsigned long aLength, [array, size_is (aLength)] in nsIXPCTestInterfaceA a,
- *                          inout unsigned long bLength, [array, size_is (bLength)] inout nsIXPCTestInterfaceA b,
- *                          out unsigned long rvLength, [array, size_is (rvLength), retval] out nsIXPCTestInterfaceA rv); */
 NS_IMETHODIMP nsXPCTestParams::TestInterfaceArray(uint32_t aLength, nsIXPCTestInterfaceA** a,
                                                   uint32_t* bLength, nsIXPCTestInterfaceA * **b,
                                                   uint32_t* rvLength, nsIXPCTestInterfaceA * **rv)
 {
     BUFFER_METHOD_IMPL(nsIXPCTestInterfaceA*, 0, TAKE_OWNERSHIP_INTERFACE);
 }
 
-/* void testSizedString (in unsigned long aLength, [size_is (aLength)] in string a,
- *                       inout unsigned long bLength, [size_is (bLength)] inout string b,
- *                       out unsigned long rvLength, [size_is (rvLength), retval] out string rv); */
 NS_IMETHODIMP nsXPCTestParams::TestSizedString(uint32_t aLength, const char * a,
                                                uint32_t* bLength, char * *b,
                                                uint32_t* rvLength, char * *rv)
 {
     BUFFER_METHOD_IMPL(char, 1, TAKE_OWNERSHIP_NOOP);
 }
 
-/* void testSizedWstring (in unsigned long aLength, [size_is (aLength)] in wstring a,
- *                        inout unsigned long bLength, [size_is (bLength)] inout wstring b,
- *                        out unsigned long rvLength, [size_is (rvLength), retval] out wstring rv); */
 NS_IMETHODIMP nsXPCTestParams::TestSizedWstring(uint32_t aLength, const char16_t * a,
                                                 uint32_t* bLength, char16_t * *b,
                                                 uint32_t* rvLength, char16_t * *rv)
 {
     BUFFER_METHOD_IMPL(char16_t, 1, TAKE_OWNERSHIP_NOOP);
 }
 
-/* void testInterfaceIs (in nsIIDPtr aIID, [iid_is (aIID)] in nsQIResult a,
- *                       inout nsIIDPtr bIID, [iid_is (bIID)] inout nsQIResult b,
- *                       out nsIIDPtr rvIID, [iid_is (rvIID), retval] out nsQIResult rv); */
 NS_IMETHODIMP nsXPCTestParams::TestInterfaceIs(const nsIID* aIID, void* a,
                                                nsIID** bIID, void** b,
                                                nsIID** rvIID, void** rv)
 {
     //
     // Getting the buffers and ownership right here can be a little tricky.
     //
 
@@ -289,22 +265,16 @@ NS_IMETHODIMP nsXPCTestParams::TestInter
     static_cast<nsISupports*>(*b)->AddRef();
 
     // We already had a buffer allocated for b's IID, so we can re-use it.
     **bIID = *aIID;
 
     return NS_OK;
 }
 
-/* void testInterfaceIsArray (in unsigned long aLength, in nsIIDPtr aIID,
- *                            [array, size_is (aLength), iid_is (aIID)] in nsQIResult a,
- *                            inout unsigned long bLength, inout nsIIDPtr bIID,
- *                            [array, size_is (bLength), iid_is (bIID)] inout nsQIResult b,
- *                            out unsigned long rvLength, out nsIIDPtr rvIID,
- *                            [retval, array, size_is (rvLength), iid_is (rvIID)] out nsQIResult rv); */
 NS_IMETHODIMP nsXPCTestParams::TestInterfaceIsArray(uint32_t aLength, const nsIID* aIID,
                                                     void** a,
                                                     uint32_t* bLength, nsIID** bIID,
                                                     void*** b,
                                                     uint32_t* rvLength, nsIID** rvIID,
                                                     void*** rv)
 {
     // Transfer the IIDs. See the comments in TestInterfaceIs (above) for an
@@ -322,19 +292,16 @@ NS_IMETHODIMP nsXPCTestParams::TestInter
 }
 
 NS_IMETHODIMP nsXPCTestParams::TestOutAString(nsAString & o)
 {
     o.AssignLiteral("out");
     return NS_OK;
 }
 
-/*
- * ACString testStringArrayOptionalSize([array, size_is(aLength)] in string a, [optional] in unsigned long aLength);
- */
 NS_IMETHODIMP nsXPCTestParams::TestStringArrayOptionalSize(const char * *a, uint32_t length, nsACString& out)
 {
   out.Truncate();
   for (uint32_t i = 0; i < length; ++i) {
     out.Append(a[i]);
   }
 
   return NS_OK;
--- a/layout/style/nsCSSRules.cpp
+++ b/layout/style/nsCSSRules.cpp
@@ -1368,17 +1368,16 @@ nsCSSFontFaceStyleDecl::GetPropertyValue
     ;
   }
   NS_NOTREACHED("nsCSSFontFaceStyleDecl::GetPropertyValue: "
                 "out-of-range value got to the switch");
   return NS_ERROR_INVALID_ARG;
 }
 
 
-// attribute DOMString cssText;
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::GetCssText(nsAString & aCssText)
 {
   nsAutoString descStr;
 
   aCssText.Truncate();
   for (nsCSSFontDesc id = nsCSSFontDesc(eCSSFontDesc_UNKNOWN + 1);
        id < eCSSFontDesc_COUNT;
@@ -1398,44 +1397,41 @@ nsCSSFontFaceStyleDecl::GetCssText(nsASt
 }
 
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::SetCssText(const nsAString & aCssText)
 {
   return NS_ERROR_NOT_IMPLEMENTED; // bug 443978
 }
 
-// DOMString getPropertyValue (in DOMString propertyName);
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::GetPropertyValue(const nsAString & propertyName,
                                          nsAString & aResult)
 {
   return GetPropertyValue(nsCSSProps::LookupFontDesc(propertyName), aResult);
 }
 
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::GetAuthoredPropertyValue(const nsAString& propertyName,
                                                  nsAString& aResult)
 {
   // We don't return any authored property values different from
   // GetPropertyValue, currently.
   return GetPropertyValue(nsCSSProps::LookupFontDesc(propertyName), aResult);
 }
 
-// nsIDOMCSSValue getPropertyCSSValue (in DOMString propertyName);
 already_AddRefed<dom::CSSValue>
 nsCSSFontFaceStyleDecl::GetPropertyCSSValue(const nsAString & propertyName,
                                             ErrorResult& aRv)
 {
   // ??? nsDOMCSSDeclaration returns null/NS_OK, but that seems wrong.
   aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
   return nullptr;
 }
 
-// DOMString removeProperty (in DOMString propertyName) raises (DOMException);
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::RemoveProperty(const nsAString & propertyName,
                                        nsAString & aResult)
 {
   nsCSSFontDesc descID = nsCSSProps::LookupFontDesc(propertyName);
   NS_ASSERTION(descID >= eCSSFontDesc_UNKNOWN &&
                descID < eCSSFontDesc_COUNT,
                "LookupFontDesc returned value out of range");
@@ -1445,52 +1441,47 @@ nsCSSFontFaceStyleDecl::RemoveProperty(c
   } else {
     nsresult rv = GetPropertyValue(descID, aResult);
     NS_ENSURE_SUCCESS(rv, rv);
     mDescriptors.Get(descID).Reset();
   }
   return NS_OK;
 }
 
-// DOMString getPropertyPriority (in DOMString propertyName);
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::GetPropertyPriority(const nsAString & propertyName,
                                             nsAString & aResult)
 {
   // font descriptors do not have priorities at present
   aResult.Truncate();
   return NS_OK;
 }
 
-// void setProperty (in DOMString propertyName, in DOMString value,
-//                   in DOMString priority)  raises (DOMException);
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::SetProperty(const nsAString & propertyName,
                                     const nsAString & value,
                                     const nsAString & priority)
 {
   return NS_ERROR_NOT_IMPLEMENTED; // bug 443978
 }
 
-// readonly attribute unsigned long length;
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::GetLength(uint32_t *aLength)
 {
   uint32_t len = 0;
   for (nsCSSFontDesc id = nsCSSFontDesc(eCSSFontDesc_UNKNOWN + 1);
        id < eCSSFontDesc_COUNT;
        id = nsCSSFontDesc(id + 1))
     if (mDescriptors.Get(id).GetUnit() != eCSSUnit_Null)
       len++;
 
   *aLength = len;
   return NS_OK;
 }
 
-// DOMString item (in unsigned long index);
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::Item(uint32_t aIndex, nsAString& aReturn)
 {
   bool found;
   IndexedGetter(aIndex, found, aReturn);
   if (!found) {
     aReturn.Truncate();
   }
@@ -1511,17 +1502,16 @@ nsCSSFontFaceStyleDecl::IndexedGetter(ui
         aResult.AssignASCII(nsCSSProps::GetStringValue(id).get());
         return;
       }
     }
   }
   aFound = false;
 }
 
-// readonly attribute nsIDOMCSSRule parentRule;
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::GetParentRule(nsIDOMCSSRule** aParentRule)
 {
   NS_IF_ADDREF(*aParentRule = ContainingRule()->GetDOMRule());
   return NS_OK;
 }
 
 NS_IMETHODIMP
--- a/modules/libjar/zipwriter/nsDeflateConverter.cpp
+++ b/modules/libjar/zipwriter/nsDeflateConverter.cpp
@@ -55,30 +55,25 @@ nsresult nsDeflateConverter::Init()
 
     // mark the input buffer as empty.
     mZstream.avail_in = 0;
     mZstream.next_in = Z_NULL;
 
     return NS_OK;
 }
 
-/* nsIInputStream convert (in nsIInputStream aFromStream, in string aFromType
- *                         in string aToType, in nsISupports aCtxt); */
 NS_IMETHODIMP nsDeflateConverter::Convert(nsIInputStream *aFromStream,
                                           const char *aFromType,
                                           const char *aToType,
                                           nsISupports *aCtxt,
                                           nsIInputStream **_retval)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-/* void asyncConvertData (in string aFromType, in string aToType,
- *                        in nsIStreamListener aListener,
- *                        in nsISupports aCtxt); */
 NS_IMETHODIMP nsDeflateConverter::AsyncConvertData(const char *aFromType,
                                                    const char *aToType,
                                                    nsIStreamListener *aListener,
                                                    nsISupports *aCtxt)
 {
     if (mListener)
         return NS_ERROR_ALREADY_INITIALIZED;
 
@@ -95,20 +90,16 @@ NS_IMETHODIMP nsDeflateConverter::AsyncC
     nsresult rv = Init();
     NS_ENSURE_SUCCESS(rv, rv);
 
     mListener = aListener;
     mContext = aCtxt;
     return rv;
 }
 
-/* void onDataAvailable (in nsIRequest aRequest, in nsISupports aContext,
- *                       in nsIInputStream aInputStream,
- *                       in unsigned long long aOffset,
- *                       in unsigned long aCount); */
 NS_IMETHODIMP nsDeflateConverter::OnDataAvailable(nsIRequest *aRequest,
                                                   nsISupports *aContext,
                                                   nsIInputStream *aInputStream,
                                                   uint64_t aOffset,
                                                   uint32_t aCount)
 {
     if (!mListener)
         return NS_ERROR_NOT_INITIALIZED;
@@ -143,18 +134,16 @@ NS_IMETHODIMP nsDeflateConverter::OnStar
                                                  nsISupports *aContext)
 {
     if (!mListener)
         return NS_ERROR_NOT_INITIALIZED;
 
     return mListener->OnStartRequest(aRequest, mContext);
 }
 
-/* void onStopRequest (in nsIRequest aRequest, in nsISupports aContext,
- *                     in nsresult aStatusCode); */
 NS_IMETHODIMP nsDeflateConverter::OnStopRequest(nsIRequest *aRequest,
                                                 nsISupports *aContext,
                                                 nsresult aStatusCode)
 {
     if (!mListener)
         return NS_ERROR_NOT_INITIALIZED;
 
     nsresult rv;
--- a/modules/libjar/zipwriter/nsZipDataStream.cpp
+++ b/modules/libjar/zipwriter/nsZipDataStream.cpp
@@ -54,19 +54,16 @@ nsresult nsZipDataStream::Init(nsZipWrit
     }
     else {
         mHeader->mMethod = ZIP_METHOD_STORE;
     }
 
     return NS_OK;
 }
 
-/* void onDataAvailable (in nsIRequest aRequest, in nsISupports aContext,
- *                       in nsIInputStream aInputStream,
- *                       in unsigned long long aOffset, in unsigned long aCount); */
 NS_IMETHODIMP nsZipDataStream::OnDataAvailable(nsIRequest *aRequest,
                                                nsISupports *aContext,
                                                nsIInputStream *aInputStream,
                                                uint64_t aOffset,
                                                uint32_t aCount)
 {
     if (!mOutput)
         return NS_ERROR_NOT_INITIALIZED;
@@ -84,18 +81,16 @@ NS_IMETHODIMP nsZipDataStream::OnStartRe
                                               nsISupports *aContext)
 {
     if (!mOutput)
         return NS_ERROR_NOT_INITIALIZED;
 
     return mOutput->OnStartRequest(aRequest, aContext);
 }
 
-/* void onStopRequest (in nsIRequest aRequest, in nsISupports aContext,
- *                     in nsresult aStatusCode); */
 NS_IMETHODIMP nsZipDataStream::OnStopRequest(nsIRequest *aRequest,
                                              nsISupports *aContext,
                                              nsresult aStatusCode)
 {
     if (!mOutput)
         return NS_ERROR_NOT_INITIALIZED;
 
     nsresult rv = mOutput->OnStopRequest(aRequest, aContext, aStatusCode);
--- a/modules/libjar/zipwriter/nsZipWriter.cpp
+++ b/modules/libjar/zipwriter/nsZipWriter.cpp
@@ -298,18 +298,16 @@ NS_IMETHODIMP nsZipWriter::GetEntry(cons
 NS_IMETHODIMP nsZipWriter::HasEntry(const nsACString & aZipEntry,
                                     bool *_retval)
 {
     *_retval = mEntryHash.Get(aZipEntry, nullptr);
 
     return NS_OK;
 }
 
-/* void addEntryDirectory (in AUTF8String aZipEntry, in PRTime aModTime,
- *                         in boolean aQueue); */
 NS_IMETHODIMP nsZipWriter::AddEntryDirectory(const nsACString & aZipEntry,
                                              PRTime aModTime, bool aQueue)
 {
     if (!mStream)
         return NS_ERROR_NOT_INITIALIZED;
 
     if (aQueue) {
         nsZipQueueItem item;
@@ -322,18 +320,16 @@ NS_IMETHODIMP nsZipWriter::AddEntryDirec
         return NS_OK;
     }
 
     if (mInQueue)
         return NS_ERROR_IN_PROGRESS;
     return InternalAddEntryDirectory(aZipEntry, aModTime, PERMISSIONS_DIR);
 }
 
-/* void addEntryFile (in AUTF8String aZipEntry, in int32_t aCompression,
- *                    in nsIFile aFile, in boolean aQueue); */
 NS_IMETHODIMP nsZipWriter::AddEntryFile(const nsACString & aZipEntry,
                                         int32_t aCompression, nsIFile *aFile,
                                         bool aQueue)
 {
     NS_ENSURE_ARG_POINTER(aFile);
     if (!mStream)
         return NS_ERROR_NOT_INITIALIZED;
 
@@ -385,19 +381,16 @@ NS_IMETHODIMP nsZipWriter::AddEntryFile(
 
     rv = AddEntryStream(aZipEntry, modtime, aCompression, inputStream,
                         false, permissions);
     NS_ENSURE_SUCCESS(rv, rv);
 
     return inputStream->Close();
 }
 
-/* void addEntryChannel (in AUTF8String aZipEntry, in PRTime aModTime,
- *                       in int32_t aCompression, in nsIChannel aChannel,
- *                       in boolean aQueue); */
 NS_IMETHODIMP nsZipWriter::AddEntryChannel(const nsACString & aZipEntry,
                                            PRTime aModTime,
                                            int32_t aCompression,
                                            nsIChannel *aChannel,
                                            bool aQueue)
 {
     NS_ENSURE_ARG_POINTER(aChannel);
     if (!mStream)
@@ -434,32 +427,26 @@ NS_IMETHODIMP nsZipWriter::AddEntryChann
 
     rv = AddEntryStream(aZipEntry, aModTime, aCompression, inputStream,
                         false, PERMISSIONS_FILE);
     NS_ENSURE_SUCCESS(rv, rv);
 
     return inputStream->Close();
 }
 
-/* void addEntryStream (in AUTF8String aZipEntry, in PRTime aModTime,
- *                      in int32_t aCompression, in nsIInputStream aStream,
- *                      in boolean aQueue); */
 NS_IMETHODIMP nsZipWriter::AddEntryStream(const nsACString & aZipEntry,
                                           PRTime aModTime,
                                           int32_t aCompression,
                                           nsIInputStream *aStream,
                                           bool aQueue)
 {
     return AddEntryStream(aZipEntry, aModTime, aCompression, aStream, aQueue,
                           PERMISSIONS_FILE);
 }
 
-/* void addEntryStream (in AUTF8String aZipEntry, in PRTime aModTime,
- *                      in int32_t aCompression, in nsIInputStream aStream,
- *                      in boolean aQueue, in unsigned long aPermissions); */
 nsresult nsZipWriter::AddEntryStream(const nsACString & aZipEntry,
                                      PRTime aModTime,
                                      int32_t aCompression,
                                      nsIInputStream *aStream,
                                      bool aQueue,
                                      uint32_t aPermissions)
 {
     NS_ENSURE_ARG_POINTER(aStream);
@@ -600,18 +587,16 @@ NS_IMETHODIMP nsZipWriter::RemoveEntry(c
         mCDSDirty = true;
 
         return NS_OK;
     }
 
     return NS_ERROR_FILE_NOT_FOUND;
 }
 
-/* void processQueue (in nsIRequestObserver aObserver,
- *                    in nsISupports aContext); */
 NS_IMETHODIMP nsZipWriter::ProcessQueue(nsIRequestObserver *aObserver,
                                         nsISupports *aContext)
 {
     if (!mStream)
         return NS_ERROR_NOT_INITIALIZED;
     if (mInQueue)
         return NS_ERROR_IN_PROGRESS;
 
@@ -705,18 +690,16 @@ NS_IMETHODIMP nsZipWriter::Close()
 
 // Our nsIRequestObserver monitors removal operations performed on the queue
 NS_IMETHODIMP nsZipWriter::OnStartRequest(nsIRequest *aRequest,
                                           nsISupports *aContext)
 {
     return NS_OK;
 }
 
-/* void onStopRequest (in nsIRequest aRequest, in nsISupports aContext,
- *                                             in nsresult aStatusCode); */
 NS_IMETHODIMP nsZipWriter::OnStopRequest(nsIRequest *aRequest,
                                          nsISupports *aContext,
                                          nsresult aStatusCode)
 {
     if (NS_FAILED(aStatusCode)) {
         FinishQueue(aStatusCode);
         Cleanup();
     }
--- a/netwerk/base/LoadContextInfo.cpp
+++ b/netwerk/base/LoadContextInfo.cpp
@@ -51,64 +51,58 @@ NS_IMETHODIMP LoadContextInfo::GetOrigin
   }
   return NS_OK;
 }
 
 // LoadContextInfoFactory
 
 NS_IMPL_ISUPPORTS(LoadContextInfoFactory, nsILoadContextInfoFactory)
 
-/* readonly attribute nsILoadContextInfo default; */
 NS_IMETHODIMP LoadContextInfoFactory::GetDefault(nsILoadContextInfo * *aDefault)
 {
   nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(false, false, OriginAttributes());
   info.forget(aDefault);
   return NS_OK;
 }
 
-/* readonly attribute nsILoadContextInfo private; */
 NS_IMETHODIMP LoadContextInfoFactory::GetPrivate(nsILoadContextInfo * *aPrivate)
 {
   nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(true, false, OriginAttributes());
   info.forget(aPrivate);
   return NS_OK;
 }
 
-/* readonly attribute nsILoadContextInfo anonymous; */
 NS_IMETHODIMP LoadContextInfoFactory::GetAnonymous(nsILoadContextInfo * *aAnonymous)
 {
   nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(false, true, OriginAttributes());
   info.forget(aAnonymous);
   return NS_OK;
 }
 
-/* nsILoadContextInfo custom (in boolean aPrivate, in boolean aAnonymous, in jsval aOriginAttributes); */
 NS_IMETHODIMP LoadContextInfoFactory::Custom(bool aPrivate, bool aAnonymous,
                                              JS::HandleValue aOriginAttributes, JSContext *cx,
                                              nsILoadContextInfo * *_retval)
 {
   OriginAttributes attrs;
   bool status = attrs.Init(cx, aOriginAttributes);
   NS_ENSURE_TRUE(status, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(aPrivate, aAnonymous, attrs);
   info.forget(_retval);
   return NS_OK;
 }
 
-/* nsILoadContextInfo fromLoadContext (in nsILoadContext aLoadContext, in boolean aAnonymous); */
 NS_IMETHODIMP LoadContextInfoFactory::FromLoadContext(nsILoadContext *aLoadContext, bool aAnonymous,
                                                       nsILoadContextInfo * *_retval)
 {
   nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(aLoadContext, aAnonymous);
   info.forget(_retval);
   return NS_OK;
 }
 
-/* nsILoadContextInfo fromWindow (in nsIDOMWindow aWindow, in boolean aAnonymous); */
 NS_IMETHODIMP LoadContextInfoFactory::FromWindow(nsIDOMWindow *aWindow, bool aAnonymous,
                                                  nsILoadContextInfo * *_retval)
 {
   nsCOMPtr<nsILoadContextInfo> info = GetLoadContextInfo(aWindow, aAnonymous);
   info.forget(_retval);
   return NS_OK;
 }
 
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -1566,19 +1566,16 @@ NS_IMETHODIMP nsCacheService::GetCacheIO
 
     if (!NS_IsMainThread()) {
         Unlock();
     }
 
     return rv;
 }
 
-/* nsICacheServiceInternal
- * readonly attribute double lockHeldTime;
-*/
 NS_IMETHODIMP nsCacheService::GetLockHeldTime(double *aLockHeldTime)
 {
     MutexAutoLock lock(mTimeStampLock);
 
     if (mLockAcquiredTimeStamp.IsNull()) {
         *aLockHeldTime = 0.0;
     }
     else {
--- a/security/manager/pki/nsNSSDialogs.cpp
+++ b/security/manager/pki/nsNSSDialogs.cpp
@@ -77,17 +77,16 @@ nsNSSDialogs::SetPassword(nsIInterfaceRe
 
   // Get the parent window for the dialog
   nsCOMPtr<nsIDOMWindow> parent = do_GetInterface(ctx);
 
   nsCOMPtr<nsIDialogParamBlock> block =
            do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID);
   if (!block) return NS_ERROR_FAILURE;
 
-  // void ChangePassword(in wstring tokenName, out int status);
   rv = block->SetString(1, tokenName);
   if (NS_FAILED(rv)) return rv;
 
   rv = nsNSSDialogHelper::openDialog(parent,
                                 "chrome://pippki/content/changepassword.xul",
                                 block);
 
   if (NS_FAILED(rv)) return rv;
--- a/security/manager/ssl/CertBlocklist.cpp
+++ b/security/manager/ssl/CertBlocklist.cpp
@@ -283,33 +283,31 @@ CertBlocklist::EnsureBackingFileInitiali
              ("CertBlocklist::EnsureBackingFileInitialized adding revoked cert "
               "failed"));
     }
   } while (more);
   mBackingFileIsInitialized = true;
   return NS_OK;
 }
 
-// void revokeCertBySubjectAndPubKey(in string subject, in string pubKeyHash);
 NS_IMETHODIMP
 CertBlocklist::RevokeCertBySubjectAndPubKey(const char* aSubject,
                                             const char* aPubKeyHash)
 {
   MOZ_LOG(gCertBlockPRLog, LogLevel::Debug,
          ("CertBlocklist::RevokeCertBySubjectAndPubKey - subject is: %s and pubKeyHash: %s",
           aSubject, aPubKeyHash));
   MutexAutoLock lock(mMutex);
 
   return AddRevokedCertInternal(nsDependentCString(aSubject),
                                 nsDependentCString(aPubKeyHash),
                                 BlockBySubjectAndPubKey,
                                 CertNewFromBlocklist, lock);
 }
 
-// void revokeCertByIssuerAndSerial(in string issuer, in string serialNumber);
 NS_IMETHODIMP
 CertBlocklist::RevokeCertByIssuerAndSerial(const char* aIssuer,
                                            const char* aSerialNumber)
 {
   MOZ_LOG(gCertBlockPRLog, LogLevel::Debug,
          ("CertBlocklist::RevokeCertByIssuerAndSerial - issuer is: %s and serial: %s",
           aIssuer, aSerialNumber));
   MutexAutoLock lock(mMutex);
@@ -503,24 +501,16 @@ CertBlocklist::SaveEntries()
     MOZ_LOG(gCertBlockPRLog, LogLevel::Warning,
            ("CertBlocklist::SaveEntries saving revocation data failed"));
     return rv;
   }
   mModified = false;
   return NS_OK;
 }
 
-// boolean isCertRevoked([const, array, size_is(issuerLength)] in octet issuer,
-//                       in unsigned long issuerLength,
-//                       [const, array, size_is(serialLength)] in octet serial,
-//                       in unsigned long serialLength),
-//                       [const, array, size_is(subject_length)] in octet subject,
-//                       in unsigned long subject_length,
-//                       [const, array, size_is(pubkey_length)] in octet pubkey,
-//                       in unsigned long pubkey_length);
 NS_IMETHODIMP
 CertBlocklist::IsCertRevoked(const uint8_t* aIssuer,
                              uint32_t aIssuerLength,
                              const uint8_t* aSerial,
                              uint32_t aSerialLength,
                              const uint8_t* aSubject,
                              uint32_t aSubjectLength,
                              const uint8_t* aPubKey,
--- a/security/manager/ssl/nsCertTree.cpp
+++ b/security/manager/ssl/nsCertTree.cpp
@@ -1306,19 +1306,16 @@ nsCertTree::PerformAction(const char16_t
 }
 
 NS_IMETHODIMP 
 nsCertTree::PerformActionOnRow(const char16_t *action, int32_t row)
 {
   return NS_OK;
 }
 
-/* void performActionOnCell (in wstring action, in long row, 
- *                           in wstring colID); 
- */
 NS_IMETHODIMP 
 nsCertTree::PerformActionOnCell(const char16_t *action, int32_t row, 
                                 nsITreeColumn* col)
 {
   return NS_OK;
 }
 
 #ifdef DEBUG_CERT_TREE
--- a/security/manager/ssl/nsNSSCertificateDB.cpp
+++ b/security/manager/ssl/nsNSSCertificateDB.cpp
@@ -432,21 +432,16 @@ nsNSSCertificateDB::handleCACertDownload
     }
     
     CERT_AddCertToListTail(certList.get(), tmpCert2);
   }
 
   return ImportValidCACertsInList(certList.get(), ctx, proofOfLock);
 }
 
-/*
- *  [noscript] void importCertificates(in charPtr data, in unsigned long length,
- *                                     in unsigned long type, 
- *                                     in nsIInterfaceRequestor ctx);
- */
 NS_IMETHODIMP 
 nsNSSCertificateDB::ImportCertificates(uint8_t * data, uint32_t length, 
                                        uint32_t type, 
                                        nsIInterfaceRequestor *ctx)
 
 {
   nsNSSShutDownPreventionLock locker;
   if (isAlreadyShutDown()) {
@@ -526,20 +521,16 @@ ImportCertsIntoPermanentStorage(
   SECStatus srv = CERT_ImportCerts(certdb, usage, chainLen, rawArray,
                                    nullptr, true, caOnly, nullptr);
 
   PORT_Free(rawArray);
   return srv;
 } 
 
 
-/*
- *  [noscript] void importEmailCertificates(in charPtr data, in unsigned long length,
- *                                     in nsIInterfaceRequestor ctx);
- */
 NS_IMETHODIMP
 nsNSSCertificateDB::ImportEmailCertificate(uint8_t * data, uint32_t length, 
                                        nsIInterfaceRequestor *ctx)
 
 {
   nsNSSShutDownPreventionLock locker;
   if (isAlreadyShutDown()) {
     return NS_ERROR_NOT_AVAILABLE;
@@ -925,19 +916,16 @@ nsNSSCertificateDB::ImportUserCertificat
   
 loser:
   if (arena) {
     PORT_FreeArena(arena, false);
   }
   return rv;
 }
 
-/*
- * void deleteCertificate(in nsIX509Cert aCert);
- */
 NS_IMETHODIMP 
 nsNSSCertificateDB::DeleteCertificate(nsIX509Cert *aCert)
 {
   NS_ENSURE_ARG_POINTER(aCert);
   nsNSSShutDownPreventionLock locker;
   if (isAlreadyShutDown()) {
     return NS_ERROR_NOT_AVAILABLE;
   }
@@ -965,21 +953,16 @@ nsNSSCertificateDB::DeleteCertificate(ns
     nsNSSCertTrust trust(0, 0, 0);
     srv = CERT_ChangeCertTrust(CERT_GetDefaultCertDB(), 
                                cert.get(), trust.GetTrust());
   }
   MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("cert deleted: %d", srv));
   return (srv) ? NS_ERROR_FAILURE : NS_OK;
 }
 
-/*
- * void setCertTrust(in nsIX509Cert cert,
- *                   in unsigned long type,
- *                   in unsigned long trust);
- */
 NS_IMETHODIMP 
 nsNSSCertificateDB::SetCertTrust(nsIX509Cert *cert, 
                                  uint32_t type,
                                  uint32_t trusted)
 {
   NS_ENSURE_ARG_POINTER(cert);
   nsNSSShutDownPreventionLock locker;
   if (isAlreadyShutDown()) {
--- a/security/manager/ssl/nsPK11TokenDB.cpp
+++ b/security/manager/ssl/nsPK11TokenDB.cpp
@@ -324,19 +324,16 @@ nsPK11Token::GetAskPasswordTimeout(int32
     return NS_ERROR_NOT_AVAILABLE;
 
     int askTimes, askTimeout;
     PK11_GetSlotPWValues(mSlot, &askTimes, &askTimeout);
     *rvAskTimeout = askTimeout;
     return NS_OK;
 }
 
-/* void setAskPasswordDefaults(in unsigned long askTimes,
- *                             in unsigned long timeout);
- */
 NS_IMETHODIMP 
 nsPK11Token::SetAskPasswordDefaults(const int32_t askTimes,
                                     const int32_t askTimeout)
 {
   nsNSSShutDownPreventionLock locker;
   if (isAlreadyShutDown())
     return NS_ERROR_NOT_AVAILABLE;
 
--- a/security/manager/ssl/nsRandomGenerator.cpp
+++ b/security/manager/ssl/nsRandomGenerator.cpp
@@ -6,18 +6,16 @@
 
 #include "nsNSSComponent.h"
 #include "pk11pub.h"
 #include "prerror.h"
 #include "secerr.h"
 
 NS_IMPL_ISUPPORTS(nsRandomGenerator, nsIRandomGenerator)
 
-// void generateRandomBytes(in unsigned long aLength,
-//                          [retval, array, size_is(aLength)] out octet aBuffer)
 NS_IMETHODIMP
 nsRandomGenerator::GenerateRandomBytes(uint32_t aLength,
                                        uint8_t** aBuffer)
 {
   NS_ENSURE_ARG_POINTER(aBuffer);
   *aBuffer = nullptr;
 
   nsNSSShutDownPreventionLock locker;
--- a/toolkit/components/perfmonitoring/nsPerformanceStats.cpp
+++ b/toolkit/components/perfmonitoring/nsPerformanceStats.cpp
@@ -226,86 +226,73 @@ public:
                      const PerformanceData& aPerformanceData)
     : nsPerformanceGroupDetails(item)
     , mPerformanceData(aPerformanceData)
   {
   }
 
   NS_DECL_ISUPPORTS
 
-  /* readonly attribute AString name; */
   NS_IMETHOD GetName(nsAString& aName) override {
     aName.Assign(nsPerformanceGroupDetails::Name());
     return NS_OK;
   };
 
-  /* readonly attribute AString groupId; */
   NS_IMETHOD GetGroupId(nsAString& aGroupId) override {
     aGroupId.Assign(nsPerformanceGroupDetails::GroupId());
     return NS_OK;
   };
 
-  /* readonly attribute AString addonId; */
   NS_IMETHOD GetAddonId(nsAString& aAddonId) override {
     aAddonId.Assign(nsPerformanceGroupDetails::AddonId());
     return NS_OK;
   };
 
-  /* readonly attribute uint64_t windowId; */
   NS_IMETHOD GetWindowId(uint64_t *aWindowId) override {
     *aWindowId = nsPerformanceGroupDetails::WindowId();
     return NS_OK;
   }
 
-  /* readonly attribute bool isSystem; */
   NS_IMETHOD GetIsSystem(bool *_retval) override {
     *_retval = nsPerformanceGroupDetails::IsSystem();
     return NS_OK;
   }
 
-  /* readonly attribute unsigned long long totalUserTime; */
   NS_IMETHOD GetTotalUserTime(uint64_t *aTotalUserTime) override {
     *aTotalUserTime = mPerformanceData.mTotalUserTime;
     return NS_OK;
   };
 
-  /* readonly attribute unsigned long long totalSystemTime; */
   NS_IMETHOD GetTotalSystemTime(uint64_t *aTotalSystemTime) override {
     *aTotalSystemTime = mPerformanceData.mTotalSystemTime;
     return NS_OK;
   };
 
-  /* readonly attribute unsigned long long totalCPOWTime; */
   NS_IMETHOD GetTotalCPOWTime(uint64_t *aCpowTime) override {
     *aCpowTime = mPerformanceData.mTotalCPOWTime;
     return NS_OK;
   };
 
-  /* readonly attribute unsigned long long ticks; */
   NS_IMETHOD GetTicks(uint64_t *aTicks) override {
     *aTicks = mPerformanceData.mTicks;
     return NS_OK;
   };
 
-  /* void getDurations (out unsigned long aCount, [array, size_is (aCount), retval] out unsigned long long aNumberOfOccurrences); */
   NS_IMETHOD GetDurations(uint32_t *aCount, uint64_t **aNumberOfOccurrences) override {
     const size_t length = mozilla::ArrayLength(mPerformanceData.mDurations);
     if (aCount) {
       *aCount = length;
     }
     *aNumberOfOccurrences = new uint64_t[length];
     for (size_t i = 0; i < length; ++i) {
       (*aNumberOfOccurrences)[i] = mPerformanceData.mDurations[i];
     }
     return NS_OK;
   };
 
-  /*
-    readonly attribute unsigned long long processId;
-  */
   NS_IMETHODIMP GetProcessId(uint64_t* processId) override {
     *processId = nsPerformanceGroupDetails::ProcessId();
     return NS_OK;
   }
 
 private:
   PerformanceData mPerformanceData;
 
@@ -352,32 +339,30 @@ private:
    * The data for the process.
    */
   nsCOMPtr<nsIPerformanceStats> mProcessData;
 };
 
 NS_IMPL_ISUPPORTS(nsPerformanceSnapshot, nsIPerformanceSnapshot)
 
 
-/* nsIArray getComponentsData (); */
 NS_IMETHODIMP
 nsPerformanceSnapshot::GetComponentsData(nsIArray * *aComponents)
 {
   const size_t length = mComponentsData.Length();
   nsCOMPtr<nsIMutableArray> components = do_CreateInstance(NS_ARRAY_CONTRACTID);
   for (size_t i = 0; i < length; ++i) {
     nsCOMPtr<nsIPerformanceStats> stats = mComponentsData[i];
     mozilla::DebugOnly<nsresult> rv = components->AppendElement(stats, false);
     MOZ_ASSERT(NS_SUCCEEDED(rv));
   }
   components.forget(aComponents);
   return NS_OK;
 }
 
-/* nsIPerformanceStats getProcessData (); */
 NS_IMETHODIMP
 nsPerformanceSnapshot::GetProcessData(nsIPerformanceStats * *aProcess)
 {
   NS_IF_ADDREF(*aProcess = mProcessData);
   return NS_OK;
 }
 
 void
@@ -529,17 +514,16 @@ nsPerformanceStatsService::Observe(nsISu
              || strcmp(aTopic, "quit-application") == 0
              || strcmp(aTopic, "quit-application-granted") == 0
              || strcmp(aTopic, "content-child-shutdown") == 0);
 
   Dispose();
   return NS_OK;
 }
 
-/* [implicit_jscontext] attribute bool isMonitoringCPOW; */
 NS_IMETHODIMP
 nsPerformanceStatsService::GetIsMonitoringCPOW(JSContext* cx, bool *aIsStopwatchActive)
 {
   JSRuntime *runtime = JS_GetRuntime(cx);
   *aIsStopwatchActive = js::GetStopwatchIsMonitoringCPOW(runtime);
   return NS_OK;
 }
 NS_IMETHODIMP
@@ -547,17 +531,16 @@ nsPerformanceStatsService::SetIsMonitori
 {
   JSRuntime *runtime = JS_GetRuntime(cx);
   if (!js::SetStopwatchIsMonitoringCPOW(runtime, aIsStopwatchActive)) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   return NS_OK;
 }
 
-/* [implicit_jscontext] attribute bool isMonitoringJank; */
 NS_IMETHODIMP
 nsPerformanceStatsService::GetIsMonitoringJank(JSContext* cx, bool *aIsStopwatchActive)
 {
   JSRuntime *runtime = JS_GetRuntime(cx);
   *aIsStopwatchActive = js::GetStopwatchIsMonitoringJank(runtime);
   return NS_OK;
 }
 NS_IMETHODIMP
@@ -565,17 +548,16 @@ nsPerformanceStatsService::SetIsMonitori
 {
   JSRuntime *runtime = JS_GetRuntime(cx);
   if (!js::SetStopwatchIsMonitoringJank(runtime, aIsStopwatchActive)) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   return NS_OK;
 }
 
-/* [implicit_jscontext] attribute bool isMonitoringPerCompartment; */
 NS_IMETHODIMP
 nsPerformanceStatsService::GetIsMonitoringPerCompartment(JSContext*, bool *aIsMonitoringPerCompartment)
 {
   *aIsMonitoringPerCompartment = mIsMonitoringPerCompartment;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsPerformanceStatsService::SetIsMonitoringPerCompartment(JSContext*, bool aIsMonitoringPerCompartment)
@@ -634,17 +616,16 @@ nsPerformanceStatsService::GetStatsForGr
 }
 
 /* static */ nsIPerformanceStats*
 nsPerformanceStatsService::GetStatsForGroup(const nsPerformanceGroup* group)
 {
   return new nsPerformanceStats(*group, group->data);
 }
 
-/* [implicit_jscontext] nsIPerformanceSnapshot getSnapshot (); */
 NS_IMETHODIMP
 nsPerformanceStatsService::GetSnapshot(JSContext* cx, nsIPerformanceSnapshot * *aSnapshot)
 {
   RefPtr<nsPerformanceSnapshot> snapshot = new nsPerformanceSnapshot();
   snapshot->SetProcessStats(GetStatsForGroup(mTopGroup));
 
   for (auto iter = mGroups.Iter(); !iter.Done(); iter.Next()) {
     auto* entry = iter.Get();
--- a/xpcom/io/nsMultiplexInputStream.cpp
+++ b/xpcom/io/nsMultiplexInputStream.cpp
@@ -290,19 +290,16 @@ nsMultiplexInputStream::Read(char* aBuf,
       aCount -= read;
       aBuf += read;
       mStartedReadingCurrent = true;
     }
   }
   return *aResult ? NS_OK : rv;
 }
 
-/* [noscript] unsigned long readSegments (in nsWriteSegmentFun writer,
- *                                        in voidPtr closure,
- *                                        in unsigned long count); */
 NS_IMETHODIMP
 nsMultiplexInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure,
                                      uint32_t aCount, uint32_t* aResult)
 {
   MutexAutoLock lock(mLock);
 
   if (mStatus == NS_BASE_STREAM_CLOSED) {
     *aResult = 0;