--- a/accessible/src/windows/sdn/sdnTextAccessible.h
+++ b/accessible/src/windows/sdn/sdnTextAccessible.h
@@ -8,17 +8,17 @@
 #define mozilla_a11y_sdnTextAccessible_h_
 
 #include "ISimpleDOMText.h"
 #include "IUnknownImpl.h"
 
 #include "AccessibleWrap.h"
 
 class nsIFrame;
-class nsPoint;
+struct nsPoint;
 
 namespace mozilla {
 namespace a11y {
  
 class sdnTextAccessible MOZ_FINAL : public ISimpleDOMText
 {
 public:
   sdnTextAccessible(AccessibleWrap* aAccessible) : mAccessible(aAccessible) {};

--- a/content/base/public/nsIDocument.h
+++ b/content/base/public/nsIDocument.h
@@ -75,17 +75,17 @@ class nsScriptLoader;
 class nsSMILAnimationController;
 class nsStyleSet;
 class nsTextNode;
 class nsWindowSizes;
 class nsSmallVoidArray;
 class nsDOMCaretPosition;
 class nsViewportInfo;
 class nsIGlobalObject;
-class nsCSSSelectorList;
+struct nsCSSSelectorList;
 
 namespace mozilla {
 class ErrorResult;
 class EventStates;
 
 namespace css {
 class Loader;
 class ImageLoader;

--- a/content/base/public/nsINode.h
+++ b/content/base/public/nsINode.h
@@ -26,17 +26,17 @@
 #ifdef XP_WIN
 #ifdef GetClassInfo
 #undef GetClassInfo
 #endif
 #endif
 
 class nsAttrAndChildArray;
 class nsChildContentList;
-class nsCSSSelectorList;
+struct nsCSSSelectorList;
 class nsDOMAttributeMap;
 class nsIContent;
 class nsIDocument;
 class nsIDOMElement;
 class nsIDOMNodeList;
 class nsIDOMUserDataHandler;
 class nsIEditor;
 class nsIFrame;

--- a/content/base/src/DOMPoint.h
+++ b/content/base/src/DOMPoint.h
@@ -13,17 +13,17 @@
 #include "mozilla/ErrorResult.h"
 #include "nsCOMPtr.h"
 #include "mozilla/dom/BindingDeclarations.h"
 
 namespace mozilla {
 namespace dom {
 
 class GlobalObject;
-class DOMPointInit;
+struct DOMPointInit;
 
 class DOMPointReadOnly : public nsWrapperCache
 {
 public:
   DOMPointReadOnly(nsISupports* aParent, double aX, double aY,
                    double aZ, double aW)
     : mParent(aParent)
     , mX(aX)

--- a/content/base/src/nsDocument.h
+++ b/content/base/src/nsDocument.h
@@ -97,17 +97,17 @@ class nsHtml5TreeOpExecutor;
 class nsDocumentOnStack;
 class nsPointerLockPermissionRequest;
 class nsISecurityConsoleMessage;
 
 namespace mozilla {
 class EventChainPreVisitor;
 namespace dom {
 class UndoManager;
-class LifecycleCallbacks;
+struct LifecycleCallbacks;
 class CallbackFunction;
 }
 }
 
 /**
  * Right now our identifier map entries contain information for 'name'
  * and 'id' mappings of a given string. This is so that
  * nsHTMLDocument::ResolveName only has to do one hash lookup instead

--- a/content/canvas/src/WebGLContext.h
+++ b/content/canvas/src/WebGLContext.h
@@ -60,17 +60,17 @@ class nsIDocShell;
 
 namespace mozilla {
 
 class WebGLMemoryPressureObserver;
 class WebGLContextBoundObject;
 class WebGLActiveInfo;
 class WebGLExtensionBase;
 class WebGLBuffer;
-class WebGLVertexAttribData;
+struct WebGLVertexAttribData;
 class WebGLShader;
 class WebGLProgram;
 class WebGLQuery;
 class WebGLUniformLocation;
 class WebGLFramebuffer;
 class WebGLRenderbuffer;
 class WebGLShaderPrecisionFormat;
 class WebGLTexture;

--- a/content/canvas/src/WebGLProgram.h
+++ b/content/canvas/src/WebGLProgram.h
@@ -14,17 +14,17 @@
 #include "mozilla/LinkedList.h"
 #include "nsWrapperCache.h"
 #include "WebGLShader.h"
 #include "WebGLUniformInfo.h"
 
 namespace mozilla {
 
 class WebGLShader;
-class WebGLUniformInfo;
+struct WebGLUniformInfo;
 
 typedef nsDataHashtable<nsCStringHashKey, nsCString> CStringMap;
 typedef nsDataHashtable<nsCStringHashKey, WebGLUniformInfo> CStringToUniformInfoMap;
 
 class WebGLProgram MOZ_FINAL
     : public nsWrapperCache
     , public WebGLRefCountedObject<WebGLProgram>
     , public LinkedListElement<WebGLProgram>

--- a/content/html/content/src/HTMLContentElement.h
+++ b/content/html/content/src/HTMLContentElement.h
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_HTMLContentElement_h__
 #define mozilla_dom_HTMLContentElement_h__
 
 #include "nsINodeList.h"
 #include "nsGenericHTMLElement.h"
 
-class nsCSSSelectorList;
+struct nsCSSSelectorList;
 
 namespace mozilla {
 namespace dom {
 
 class DistributedContentList;
 
 class HTMLContentElement MOZ_FINAL : public nsGenericHTMLElement
 {

--- a/content/media/directshow/DirectShowReader.h
+++ b/content/media/directshow/DirectShowReader.h
@@ -7,20 +7,20 @@
 #if !defined(DirectShowReader_h_)
 #define DirectShowReader_h_
 
 #include "windows.h" // HRESULT, DWORD
 #include "MediaDecoderReader.h"
 #include "mozilla/RefPtr.h"
 #include "MP3FrameParser.h"
 
-class IGraphBuilder;
-class IMediaControl;
-class IMediaSeeking;
-class IMediaEventEx;
+struct IGraphBuilder;
+struct IMediaControl;
+struct IMediaSeeking;
+struct IMediaEventEx;
 
 namespace mozilla {
 
 class AudioSinkFilter;
 class SourceFilter;
 
 namespace dom {
 class TimeRanges;

--- a/content/media/eme/MediaKeyMessageEvent.h
+++ b/content/media/eme/MediaKeyMessageEvent.h
@@ -15,17 +15,17 @@
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/TypedArray.h"
 #include "js/TypeDecls.h"
 #include "mozilla/dom/MediaKeyMessageEventBinding.h"
 
 namespace mozilla {
 namespace dom {
 
-class MediaKeyMessageEventInit;
+struct MediaKeyMessageEventInit;
 
 class MediaKeyMessageEvent MOZ_FINAL : public Event
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(MediaKeyMessageEvent, Event)
   virtual ~MediaKeyMessageEvent();
 protected:

--- a/content/media/fmp4/PlatformDecoderModule.h
+++ b/content/media/fmp4/PlatformDecoderModule.h
@@ -11,17 +11,17 @@
 #include "mozilla/layers/LayersTypes.h"
 #include "nsTArray.h"
 #include "mozilla/RefPtr.h"
 #include <queue>
 
 namespace mp4_demuxer {
 class VideoDecoderConfig;
 class AudioDecoderConfig;
-struct MP4Sample;
+class MP4Sample;
 }
 
 class nsIThreadPool;
 
 namespace mozilla {
 
 namespace layers {
 class ImageContainer;

--- a/content/media/webrtc/MediaEngine.h
+++ b/content/media/webrtc/MediaEngine.h
@@ -7,29 +7,29 @@
 
 #include "mozilla/RefPtr.h"
 #include "nsIDOMFile.h"
 #include "DOMMediaStream.h"
 #include "MediaStreamGraph.h"
 
 namespace mozilla {
 
-class VideoTrackConstraintsN;
-class AudioTrackConstraintsN;
+struct VideoTrackConstraintsN;
+struct AudioTrackConstraintsN;
 
 /**
  * Abstract interface for managing audio and video devices. Each platform
  * must implement a concrete class that will map these classes and methods
  * to the appropriate backend. For example, on Desktop platforms, these will
  * correspond to equivalent webrtc (GIPS) calls, and on B2G they will map to
  * a Gonk interface.
  */
 class MediaEngineVideoSource;
 class MediaEngineAudioSource;
-struct MediaEnginePrefs;
+class MediaEnginePrefs;
 
 enum MediaEngineState {
   kAllocated,
   kStarted,
   kStopped,
   kReleased
 };
 

--- a/content/svg/content/src/SVGMotionSMILType.h
+++ b/content/svg/content/src/SVGMotionSMILType.h
@@ -12,17 +12,17 @@
 #include "mozilla/Attributes.h"
 #include "nsISMILType.h"
 
 class nsSMILValue;
 
 namespace mozilla {
 
 namespace gfx {
-struct Matrix;
+class Matrix;
 }
 
 /**
  * MotionRotateType: Enum to indicate the type of our "rotate" attribute.
  */
 enum RotateType {
   eRotateType_Explicit,     // for e.g. rotate="45"/"45deg"/"0.785rad"
   eRotateType_Auto,         // for rotate="auto"

--- a/content/svg/content/src/SVGTransformableElement.h
+++ b/content/svg/content/src/SVGTransformableElement.h
@@ -14,17 +14,17 @@
 
 namespace mozilla {
 namespace dom {
 
 class SVGAnimatedTransformList;
 class SVGGraphicsElement;
 class SVGMatrix;
 class SVGIRect;
-class SVGBoundingBoxOptions;
+struct SVGBoundingBoxOptions;
 
 class SVGTransformableElement : public nsSVGElement
 {
 public:
   SVGTransformableElement(already_AddRefed<nsINodeInfo>& aNodeInfo)
     : nsSVGElement(aNodeInfo) {}
   virtual ~SVGTransformableElement() {}
 

--- a/dom/archivereader/ArchiveReader.h
+++ b/dom/archivereader/ArchiveReader.h
@@ -13,17 +13,17 @@
 
 #include "nsCOMArray.h"
 #include "nsIChannel.h"
 #include "nsIDOMFile.h"
 #include "mozilla/Attributes.h"
 
 namespace mozilla {
 namespace dom {
-class ArchiveReaderOptions;
+struct ArchiveReaderOptions;
 class GlobalObject;
 } // namespace dom
 } // namespace mozilla
 
 BEGIN_ARCHIVEREADER_NAMESPACE
 
 class ArchiveRequest;
 

--- a/dom/base/Console.h
+++ b/dom/base/Console.h
@@ -17,17 +17,17 @@
 #include "nsWrapperCache.h"
 
 class nsIConsoleAPIStorage;
 
 namespace mozilla {
 namespace dom {
 
 class ConsoleCallData;
-class ConsoleStackEntry;
+struct ConsoleStackEntry;
 
 class Console MOZ_FINAL : public nsITimerCallback
                         , public nsIObserver
                         , public nsWrapperCache
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(Console,

--- a/dom/base/Navigator.h
+++ b/dom/base/Navigator.h
@@ -28,17 +28,17 @@ class nsDOMCameraManager;
 class nsDOMDeviceStorage;
 class nsIDOMBlob;
 class nsIPrincipal;
 
 namespace mozilla {
 namespace dom {
 class Geolocation;
 class systemMessageCallback;
-class MediaStreamConstraints;
+struct MediaStreamConstraints;
 class WakeLock;
 class ArrayBufferViewOrBlobOrStringOrFormData;
 }
 }
 
 #ifdef MOZ_B2G_RIL
 class nsIDOMMozIccManager;
 #endif // MOZ_B2G_RIL

--- a/dom/base/nsDOMWindowUtils.h
+++ b/dom/base/nsDOMWindowUtils.h
@@ -11,18 +11,18 @@
 #include "nsIDOMWindowUtils.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/BasicEvents.h"
 
 class nsGlobalWindow;
 class nsIPresShell;
 class nsIWidget;
 class nsPresContext;
-class nsPoint;
 class nsIDocument;
+struct nsPoint;
 
 namespace mozilla {
   namespace layers {
     class LayerTransactionChild;
   }
 }
 
 class nsTranslationNodeList MOZ_FINAL : public nsITranslationNodeList

--- a/dom/bindings/Codegen.py
+++ b/dom/bindings/Codegen.py
@@ -11251,17 +11251,17 @@ class CGForwardDeclarations(CGWrapper):
             # Don't need to do anything for void, primitive, string, any or object.
             # There may be some other cases we are missing.
 
         # Needed for at least Wrap.
         for d in descriptors:
             builder.add(d.nativeType)
 
         # We just about always need NativePropertyHooks
-        builder.addInMozillaDom("NativePropertyHooks")
+        builder.addInMozillaDom("NativePropertyHooks", isStruct=True)
         builder.addInMozillaDom("ProtoAndIfaceCache")
         # Add the atoms cache type, even if we don't need it.
         for d in descriptors:
             builder.add(d.nativeType + "Atoms", isStruct=True)
 
         for callback in mainCallbacks:
             forwardDeclareForType(callback)
             for t in getTypesFromCallback(callback):

--- a/dom/camera/DOMCameraControl.h
+++ b/dom/camera/DOMCameraControl.h
@@ -21,20 +21,20 @@
 class nsDOMDeviceStorage;
 class nsPIDOMWindow;
 class nsIDOMBlob;
 
 namespace mozilla {
 
 namespace dom {
   class CameraCapabilities;
-  class CameraPictureOptions;
-  class CameraStartRecordingOptions;
-  class CameraRegion;
-  class CameraSize;
+  struct CameraPictureOptions;
+  struct CameraStartRecordingOptions;
+  struct CameraRegion;
+  struct CameraSize;
   template<typename T> class Optional;
 }
 class ErrorResult;
 class StartRecordingHelper;
 
 // Main camera control.
 class nsDOMCameraControl MOZ_FINAL : public DOMMediaStream
 {

--- a/dom/camera/DOMCameraManager.h
+++ b/dom/camera/DOMCameraManager.h
@@ -19,17 +19,17 @@
 #include "mozilla/Attributes.h"
 
 class nsPIDOMWindow;
 
 namespace mozilla {
   class ErrorResult;
   class nsDOMCameraControl;
   namespace dom {
-    class CameraConfiguration;
+    struct CameraConfiguration;
     class GetCameraCallback;
     class CameraErrorCallback;
   }
 }
 
 typedef nsTArray<nsRefPtr<mozilla::nsDOMCameraControl> > CameraControls;
 typedef nsClassHashtable<nsUint64HashKey, CameraControls> WindowTable;
 typedef mozilla::dom::Optional<mozilla::dom::OwningNonNull<mozilla::dom::CameraErrorCallback>>

--- a/dom/devicestorage/DeviceStorage.h
+++ b/dom/devicestorage/DeviceStorage.h
@@ -25,17 +25,17 @@
 
 class DeviceStorageFile;
 class nsIInputStream;
 class nsIOutputStream;
 
 namespace mozilla {
 class EventListenerManager;
 namespace dom {
-class DeviceStorageEnumerationParameters;
+struct DeviceStorageEnumerationParameters;
 class DOMCursor;
 class DOMRequest;
 class Promise;
 class DeviceStorageFileSystem;
 } // namespace dom
 namespace ipc {
 class FileDescriptor;
 }

--- a/dom/events/DOMEventTargetHelper.h
+++ b/dom/events/DOMEventTargetHelper.h
@@ -12,17 +12,17 @@
 #include "nsPIDOMWindow.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsIScriptContext.h"
 #include "MainThreadUtils.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/dom/EventTarget.h"
 
-class JSCompartment;
+struct JSCompartment;
 
 namespace mozilla {
 
 class ErrorResult;
 
 #define NS_DOMEVENTTARGETHELPER_IID \
 { 0xa28385c6, 0x9451, 0x4d7e, \
   { 0xa3, 0xdd, 0xf4, 0xb6, 0x87, 0x2f, 0xa4, 0x76 } }

--- a/dom/events/MessageEvent.h
+++ b/dom/events/MessageEvent.h
@@ -9,17 +9,17 @@
 #include "mozilla/dom/Event.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsIDOMMessageEvent.h"
 #include "mozilla/dom/MessagePortList.h"
 
 namespace mozilla {
 namespace dom {
 
-class MessageEventInit;
+struct MessageEventInit;
 class MessagePort;
 class MessagePortBase;
 class MessagePortList;
 class OwningWindowProxyOrMessagePort;
 
 /**
  * Implements the MessageEvent event, used for cross-document messaging and
  * server-sent events.

--- a/dom/filehandle/FileHandle.h
+++ b/dom/filehandle/FileHandle.h
@@ -29,17 +29,17 @@ class nsIDOMBlob;
 class nsPIDOMWindow;
 
 namespace mozilla {
 
 class EventChainPreVisitor;
 
 namespace dom {
 
-class DOMFileMetadataParameters;
+struct DOMFileMetadataParameters;
 class FileHelper;
 class FileRequest;
 class FileService;
 class FinishHelper;
 class MetadataHelper;
 class MutableFile;
 
 class FileHandle : public DOMEventTargetHelper,

--- a/dom/filesystem/Directory.h
+++ b/dom/filesystem/Directory.h
@@ -25,17 +25,17 @@
 // by Directory#CreateFileW.
 #ifdef CreateFile
 #undef CreateFile
 #endif
 
 namespace mozilla {
 namespace dom {
 
-class CreateFileOptions;
+struct CreateFileOptions;
 class FileSystemBase;
 class Promise;
 class StringOrFileOrDirectory;
 
 class Directory MOZ_FINAL
   : public nsISupports
   , public nsWrapperCache
 {

--- a/dom/indexedDB/IDBFactory.h
+++ b/dom/indexedDB/IDBFactory.h
@@ -22,17 +22,17 @@ class nsIPrincipal;
 class nsPIDOMWindow;
 template<typename> class nsRefPtr;
 
 namespace mozilla {
 class ErrorResult;
 
 namespace dom {
 class nsIContentParent;
-class IDBOpenDBOptions;
+struct IDBOpenDBOptions;
 
 namespace indexedDB {
 
 struct DatabaseInfo;
 class IDBDatabase;
 class IDBOpenDBRequest;
 class IndexedDBChild;
 class IndexedDBParent;

--- a/dom/indexedDB/IDBRequest.h
+++ b/dom/indexedDB/IDBRequest.h
@@ -22,17 +22,17 @@
 class nsIScriptContext;
 class nsPIDOMWindow;
 
 namespace mozilla {
 class EventChainPostVisitor;
 class EventChainPreVisitor;
 namespace dom {
 class OwningIDBObjectStoreOrIDBIndexOrIDBCursor;
-class ErrorEventInit;
+struct ErrorEventInit;
 }
 }
 
 BEGIN_INDEXEDDB_NAMESPACE
 
 class HelperBase;
 class IDBCursor;
 class IDBFactory;

--- a/dom/interfaces/base/nsIDOMWindowUtils.idl
+++ b/dom/interfaces/base/nsIDOMWindowUtils.idl
@@ -16,17 +16,17 @@
  *          SpecialPowers, which is used to access nsIDOMWindowUtils
  *          in plain mochitests, does not know how to handle them.
  *          (Use 'jsval' return values instead.)
  */
 
 %{C++
 #include "nsColor.h"
 class gfxContext;
-class nsRect;
+struct nsRect;
 %}
 
 [ref] native nsConstRect(const nsRect);
 native nscolor(nscolor);
 [ptr] native gfxContext(gfxContext);
 typedef unsigned long long nsViewID;
 
 interface nsICycleCollectorListener;

--- a/dom/interfaces/geolocation/nsIDOMGeoGeolocation.idl
+++ b/dom/interfaces/geolocation/nsIDOMGeoGeolocation.idl
@@ -5,17 +5,17 @@
 #include "domstubs.idl"
 
 interface nsIDOMGeoPositionCallback;
 interface nsIDOMGeoPositionErrorCallback;
 
 %{C++
 namespace mozilla {
 namespace dom {
-class PositionOptions;
+struct PositionOptions;
 }
 }
 %}
 
 [ptr] native NamespacedPositionOptions(mozilla::dom::PositionOptions);
 
 [builtinclass, uuid(9142ab45-0ab5-418c-9bab-338a6d271d4f)]
 interface nsIDOMGeoGeolocation : nsISupports

--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -17,17 +17,17 @@ include protocol POfflineCacheUpdate;
 include protocol PIndexedDB;
 include DOMTypes;
 include JavaScriptTypes;
 include URIParams;
 include PContentPermission;
 
 
 using class IPC::Principal from "mozilla/dom/PermissionMessageUtils.h";
-using struct mozilla::gfx::Matrix from "mozilla/gfx/Matrix.h";
+using class mozilla::gfx::Matrix from "mozilla/gfx/Matrix.h";
 using struct gfxSize from "gfxPoint.h";
 using CSSRect from "Units.h";
 using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
 using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
 using struct mozilla::layers::ZoomConstraints from "FrameMetrics.h";
 using FrameMetrics::ViewID from "FrameMetrics.h";
 using mozilla::layout::ScrollingBehavior from "mozilla/layout/RenderFrameUtils.h";
 using struct mozilla::void_t from "ipc/IPCMessageUtils.h";

--- a/dom/ipc/TabContext.h
+++ b/dom/ipc/TabContext.h
@@ -9,17 +9,17 @@
 
 #include "mozilla/layout/RenderFrameUtils.h"
 #include "mozIApplication.h"
 #include "nsCOMPtr.h"
 
 namespace mozilla {
 namespace dom {
 
-struct IPCTabContext;
+class IPCTabContext;
 
 /**
  * TabContext encapsulates information about an iframe that may be a mozbrowser
  * or mozapp.  You can ask whether a TabContext corresponds to a mozbrowser or
  * mozapp, get the app that contains the browser, and so on.
  *
  * TabParent and TabChild both inherit from TabContext, and you can also have
  * standalone TabContext objects.

--- a/dom/ipc/nsIContentChild.h
+++ b/dom/ipc/nsIContentChild.h
@@ -25,17 +25,17 @@ namespace mozilla {
 
 namespace jsipc {
 class PJavaScriptChild;
 class JavaScriptChild;
 class CpowEntry;
 } // jsipc
 
 namespace dom {
-struct IPCTabContext;
+class IPCTabContext;
 
 class nsIContentChild : public nsISupports
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICONTENTCHILD_IID)
 
   BlobChild* GetOrCreateActorForBlob(nsIDOMBlob* aBlob);
 

--- a/dom/ipc/nsIContentParent.h
+++ b/dom/ipc/nsIContentParent.h
@@ -26,17 +26,17 @@ namespace mozilla {
 
 namespace jsipc {
 class PJavaScriptParent;
 class JavaScriptParent;
 class CpowEntry;
 } // namespace jsipc
 
 namespace dom {
-struct IPCTabContext;
+class IPCTabContext;
 class ContentParent;
 
 class nsIContentParent : public nsISupports
                        , public mozilla::dom::ipc::MessageManagerCallback
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICONTENTPARENT_IID)
 

--- a/dom/media/GetUserMediaRequest.h
+++ b/dom/media/GetUserMediaRequest.h
@@ -9,17 +9,18 @@
 #include "nsISupportsImpl.h"
 #include "nsAutoPtr.h"
 #include "nsWrapperCache.h"
 #include "mozilla/dom/BindingUtils.h"
 #include "nsPIDOMWindow.h"
 
 namespace mozilla {
 namespace dom {
-class MediaStreamConstraints;
+
+struct MediaStreamConstraints;
 
 class GetUserMediaRequest : public nsISupports, public nsWrapperCache
 {
 public:
   GetUserMediaRequest(nsPIDOMWindow* aInnerWindow,
                       const nsAString& aCallID,
                       const MediaStreamConstraints& aConstraints,
                       bool aIsSecure);

--- a/dom/media/MediaManager.h
+++ b/dom/media/MediaManager.h
@@ -31,17 +31,17 @@
 #endif
 
 #ifdef MOZ_WIDGET_GONK
 #include "DOMCameraManager.h"
 #endif
 
 namespace mozilla {
 namespace dom {
-class MediaStreamConstraints;
+struct MediaStreamConstraints;
 class NavigatorUserMediaSuccessCallback;
 class NavigatorUserMediaErrorCallback;
 }
 
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* GetMediaManagerLog();
 #define MM_LOG(msg) PR_LOG(GetMediaManagerLog(), PR_LOG_DEBUG, msg)
 #else

--- a/dom/telephony/ipc/TelephonyIPCService.h
+++ b/dom/telephony/ipc/TelephonyIPCService.h
@@ -8,17 +8,17 @@
 
 #include "mozilla/dom/telephony/TelephonyCommon.h"
 #include "mozilla/Attributes.h"
 #include "nsIObserver.h"
 #include "nsITelephonyService.h"
 
 BEGIN_TELEPHONY_NAMESPACE
 
-struct IPCTelephonyRequest;
+class IPCTelephonyRequest;
 class PTelephonyChild;
 
 class TelephonyIPCService MOZ_FINAL : public nsITelephonyService
                                      , public nsITelephonyListener
                                      , public nsIObserver
 {
 public:
   NS_DECL_ISUPPORTS

--- a/dom/workers/WorkerPrivate.h
+++ b/dom/workers/WorkerPrivate.h
@@ -34,17 +34,17 @@ class nsIEventTarget;
 class nsIPrincipal;
 class nsIScriptContext;
 class nsIThread;
 class nsIThreadInternal;
 class nsITimer;
 class nsIURI;
 
 namespace JS {
-class RuntimeStats;
+struct RuntimeStats;
 }
 
 namespace mozilla {
 namespace dom {
 class Function;
 }
 }
 

--- a/dom/workers/WorkerRunnable.h
+++ b/dom/workers/WorkerRunnable.h
@@ -9,17 +9,17 @@
 #include "Workers.h"
 
 #include "nsICancelableRunnable.h"
 
 #include "mozilla/Atomics.h"
 #include "nsISupportsImpl.h"
 #include "nsThreadUtils.h" /* nsRunnable */
 
-class JSContext;
+struct JSContext;
 class nsIEventTarget;
 
 BEGIN_WORKERS_NAMESPACE
 
 class WorkerPrivate;
 
 // Use this runnable to communicate from the worker to its parent or vice-versa.
 // The busy count must be taken into consideration and declared at construction

--- a/dom/xbl/nsXBLMaybeCompiled.h
+++ b/dom/xbl/nsXBLMaybeCompiled.h
@@ -73,17 +73,17 @@ private:
     // An pointer that represents the function before being compiled, with
     // BIT_UNCOMPILED set.
     uintptr_t mUncompiled;
 
     // The JS object for the compiled result.
     JSObject* mCompiled;
   };
 
-  friend class js::GCMethods<nsXBLMaybeCompiled<UncompiledT> >;
+  friend struct js::GCMethods<nsXBLMaybeCompiled<UncompiledT>>;
 };
 
 /* Add support for JS::Heap<nsXBLMaybeCompiled>. */
 namespace js {
 
 template <class UncompiledT>
 struct GCMethods<nsXBLMaybeCompiled<UncompiledT> >
 {

--- a/gfx/layers/apz/src/AsyncPanZoomController.h
+++ b/gfx/layers/apz/src/AsyncPanZoomController.h
@@ -33,17 +33,17 @@ class SharedMemoryBasic;
 
 namespace layers {
 
 struct ScrollableLayerGuid;
 class CompositorParent;
 class GestureEventListener;
 class ContainerLayer;
 class PCompositorParent;
-class ViewTransform;
+struct ViewTransform;
 class AsyncPanZoomAnimation;
 class FlingAnimation;
 
 /**
  * Controller for all panning and zooming logic. Any time a user input is
  * detected and it must be processed in some way to affect what the user sees,
  * it goes through here. Listens for any input event from InputData and can
  * optionally handle WidgetGUIEvent-derived touch events, but this must be done

--- a/gfx/layers/apz/src/Axis.h
+++ b/gfx/layers/apz/src/Axis.h
@@ -20,17 +20,17 @@ const float EPSILON = 0.0001f;
 // Epsilon to be used when comparing 'float' coordinate values
 // with FuzzyEqualsAdditive. The rationale is that 'float' has 7 decimal
 // digits of precision, and coordinate values should be no larger than in the
 // ten thousands. Note also that the smallest legitimate difference in page
 // coordinates is 1 app unit, which is 1/60 of a (CSS pixel), so this epsilon
 // isn't too large.
 const float COORDINATE_EPSILON = 0.01f;
 
-class FrameMetrics;
+struct FrameMetrics;
 class AsyncPanZoomController;
 
 /**
  * Helper class to maintain each axis of movement (X,Y) for panning and zooming.
  * Note that everything here is specific to one axis; that is, the X axis knows
  * nothing about the Y axis and vice versa.
  */
 class Axis {

--- a/gfx/layers/apz/testutil/APZTestData.h
+++ b/gfx/layers/apz/testutil/APZTestData.h
@@ -34,17 +34,17 @@ typedef uint32_t SequenceNumber;
  */
 // TODO(botond):
 //  - Improve warnings/asserts.
 //  - Add ability to associate a repaint request triggered during a layers update
 //    with the sequence number of the paint that caused the layers update.
 class APZTestData {
   typedef FrameMetrics::ViewID ViewID;
   friend struct IPC::ParamTraits<APZTestData>;
-  friend class APZTestDataToJSConverter;
+  friend struct APZTestDataToJSConverter;
 public:
   void StartNewPaint(SequenceNumber aSequenceNumber) {
     mPaints.insert(DataStore::value_type(aSequenceNumber, Bucket()));
     // TODO(botond): MOZ_ASSERT() that we didn't already have a paint with this
     // sequence number once we get rid ofAPZCTreeManager::UpdatePanZoomControllerTree()
     // calls for repeat transactions (bug 1007728).
   }
   void LogTestDataForPaint(SequenceNumber aSequenceNumber,

--- a/gfx/layers/client/SimpleTiledContentClient.h
+++ b/gfx/layers/client/SimpleTiledContentClient.h
@@ -12,17 +12,17 @@
 
 #include "SharedBuffer.h"
 
 namespace mozilla {
 namespace layers {
 
 class ClientTiledThebesLayer;
 
-class SimpleTiledLayerTile;
+struct SimpleTiledLayerTile;
 class SimpleTiledLayerBuffer;
 class SimpleClientTiledThebesLayer;
 class SimpleTiledLayerBuffer;
 
 #define GFX_SIMP_TILEDLAYER_DEBUG_OVERLAY
 
 struct SimpleTiledLayerTile
 {

--- a/gfx/layers/client/TextureClient.h
+++ b/gfx/layers/client/TextureClient.h
@@ -42,17 +42,17 @@ class GLContext;
 namespace layers {
 
 class AsyncTransactionTracker;
 class ContentClient;
 class CompositableForwarder;
 class ISurfaceAllocator;
 class CompositableClient;
 class PlanarYCbCrImage;
-class PlanarYCbCrData;
+struct PlanarYCbCrData;
 class Image;
 class PTextureChild;
 class TextureChild;
 class BufferTextureClient;
 class TextureClient;
 
 /**
  * TextureClient is the abstraction that allows us to share data between the

--- a/gfx/layers/composite/LayerManagerComposite.h
+++ b/gfx/layers/composite/LayerManagerComposite.h
@@ -49,17 +49,17 @@ class TextureImage;
 
 namespace layers {
 
 class CanvasLayerComposite;
 class ColorLayerComposite;
 class CompositableHost;
 class Compositor;
 class ContainerLayerComposite;
-class EffectChain;
+struct EffectChain;
 class ImageLayer;
 class ImageLayerComposite;
 class LayerComposite;
 class RefLayerComposite;
 class SurfaceDescriptor;
 class ThebesLayerComposite;
 class TiledLayerComposer;
 class TextRenderer;

--- a/gfx/layers/ipc/CompositableForwarder.h
+++ b/gfx/layers/ipc/CompositableForwarder.h
@@ -19,17 +19,17 @@
 struct nsIntPoint;
 struct nsIntRect;
 
 namespace mozilla {
 namespace layers {
 
 class CompositableClient;
 class AsyncTransactionTracker;
-class TextureFactoryIdentifier;
+struct TextureFactoryIdentifier;
 class SurfaceDescriptor;
 class SurfaceDescriptorTiles;
 class ThebesBufferData;
 class ClientTiledLayerBuffer;
 class PTextureChild;
 
 /**
  * A transaction is a set of changes that happenned on the content side, that

--- a/gfx/layers/ipc/CompositorChild.h
+++ b/gfx/layers/ipc/CompositorChild.h
@@ -20,17 +20,17 @@
 
 class nsIObserver;
 
 namespace mozilla {
 namespace layers {
 
 class ClientLayerManager;
 class CompositorParent;
-class FrameMetrics;
+struct FrameMetrics;
 
 class CompositorChild MOZ_FINAL : public PCompositorChild
 {
   NS_INLINE_DECL_REFCOUNTING(CompositorChild)
 public:
   CompositorChild(ClientLayerManager *aLayerManager);
 
   void Destroy();

--- a/gfx/layers/ipc/ImageBridgeChild.h
+++ b/gfx/layers/ipc/ImageBridgeChild.h
@@ -33,17 +33,17 @@ class Shmem;
 namespace layers {
 
 class ClientTiledLayerBuffer;
 class AsyncTransactionTracker;
 class ImageClient;
 class ImageContainer;
 class ImageBridgeParent;
 class CompositableClient;
-class CompositableTransaction;
+struct CompositableTransaction;
 class Image;
 class TextureClient;
 
 /**
  * Returns true if the current thread is the ImageBrdigeChild's thread.
  *
  * Can be called from any thread.
  */

--- a/gfx/layers/opengl/Composer2D.h
+++ b/gfx/layers/opengl/Composer2D.h
@@ -24,17 +24,17 @@
  * path.  If the given layer tree requires more generality than the
  * hardware provides, the implementation should bail and have the
  * layer manager fall back on full GPU composition.
  */
 
 namespace mozilla {
 
 namespace gfx {
-struct Matrix;
+class Matrix;
 }
 
 namespace layers {
 
 class Layer;
 
 class Composer2D {
   NS_INLINE_DECL_REFCOUNTING(Composer2D)

--- a/gfx/src/nsDeviceContext.h
+++ b/gfx/src/nsDeviceContext.h
@@ -17,25 +17,25 @@
 #include "nsISupports.h"                // for NS_INLINE_DECL_REFCOUNTING
 #include "nsMathUtils.h"                // for NS_round
 #include "nscore.h"                     // for char16_t, nsAString
 #include "mozilla/AppUnits.h"           // for AppUnits
 
 class gfxASurface;
 class gfxTextPerfMetrics;
 class gfxUserFontSet;
-class nsFont;
+struct nsFont;
 class nsFontCache;
 class nsFontMetrics;
 class nsIAtom;
 class nsIDeviceContextSpec;
 class nsIScreen;
 class nsIScreenManager;
 class nsIWidget;
-class nsRect;
+struct nsRect;
 class nsRenderingContext;
 
 class nsDeviceContext MOZ_FINAL
 {
 public:
     nsDeviceContext();
 
     NS_INLINE_DECL_REFCOUNTING(nsDeviceContext)

--- a/gfx/thebes/gfxBlur.h
+++ b/gfx/thebes/gfxBlur.h
@@ -10,18 +10,18 @@
 #include "nsSize.h"
 #include "nsAutoPtr.h"
 #include "gfxPoint.h"
 #include "mozilla/RefPtr.h"
 
 class gfxContext;
 struct gfxRect;
 struct gfxRGBA;
-class gfxCornerSizes;
-class gfxMatrix;
+struct gfxCornerSizes;
+struct gfxMatrix;
 
 namespace mozilla {
   namespace gfx {
     class AlphaBoxBlur;
     class SourceSurface;
     class DrawTarget;
   }
 }

--- a/gfx/thebes/gfxUtils.h
+++ b/gfx/thebes/gfxUtils.h
@@ -13,17 +13,17 @@
 #include "mozilla/RefPtr.h"
 
 class gfxDrawable;
 class nsIntRegion;
 struct nsIntRect;
 
 namespace mozilla {
 namespace layers {
-class PlanarYCbCrData;
+struct PlanarYCbCrData;
 }
 }
 
 class gfxUtils {
 public:
     typedef mozilla::gfx::DataSourceSurface DataSourceSurface;
     typedef mozilla::gfx::IntPoint IntPoint;
     typedef mozilla::gfx::Matrix Matrix;

--- a/gfx/thebes/gfxWindowsPlatform.h
+++ b/gfx/thebes/gfxWindowsPlatform.h
@@ -43,19 +43,19 @@
 #define D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION 4096
 #endif
 
 namespace mozilla {
 namespace layers {
 class DeviceManagerD3D9;
 }
 }
-class IDirect3DDevice9;
-class ID3D11Device;
-class IDXGIAdapter1;
+struct IDirect3DDevice9;
+struct ID3D11Device;
+struct IDXGIAdapter1;
 
 class nsIMemoryReporter;
 
 // Utility to get a Windows HDC from a thebes context,
 // used by both GDI and Uniscribe font shapers
 struct DCFromContext {
     DCFromContext(gfxContext *aContext) {
         dc = nullptr;

--- a/hal/HalScreenConfiguration.h
+++ b/hal/HalScreenConfiguration.h
@@ -6,15 +6,15 @@
 
 #ifndef mozilla_HalScreenConfiguration_h
 #define mozilla_HalScreenConfiguration_h
 
 #include "mozilla/Observer.h"
 
 namespace mozilla {
 namespace hal {
-struct ScreenConfiguration;
+class ScreenConfiguration;
 typedef Observer<ScreenConfiguration> ScreenConfigurationObserver;
 } // namespace hal
 } // namespace mozilla
 
 #endif  // mozilla_HalScreenConfiguration_h
 

--- a/image/decoders/nsJPEGDecoder.h
+++ b/image/decoders/nsJPEGDecoder.h
@@ -42,17 +42,17 @@ typedef enum {
     JPEG_DECOMPRESS_SEQUENTIAL,           /* Output sequential pixels */
     JPEG_DONE,
     JPEG_SINK_NON_JPEG_TRAILER,          /* Some image files have a */
                                          /* non-JPEG trailer */
     JPEG_ERROR    
 } jstate;
 
 class RasterImage;
-class Orientation;
+struct Orientation;
 
 class nsJPEGDecoder : public Decoder
 {
 public:
   nsJPEGDecoder(RasterImage &aImage, Decoder::DecodeStyle aDecodeStyle);
   virtual ~nsJPEGDecoder();
 
   virtual void InitInternal();

--- a/image/public/imgIContainer.idl
+++ b/image/public/imgIContainer.idl
@@ -28,17 +28,17 @@ class nsIFrame;
 
 namespace mozilla {
 class TimeStamp;
 class SVGImageContext;
 }
 
 namespace mozilla {
 namespace image {
-class Orientation;
+struct Orientation;
 }
 }
 
 %}
 
 [ptr] native gfxContext(gfxContext);
 [ref] native gfxMatrix(gfxMatrix);
 [ref] native gfxRect(gfxRect);

--- a/image/src/ImageOps.h
+++ b/image/src/ImageOps.h
@@ -11,17 +11,17 @@
 
 class imgIContainer;
 struct nsIntRect;
 
 namespace mozilla {
 namespace image {
 
 class Image;
-class Orientation;
+struct Orientation;
 
 class ImageOps
 {
 public:
   /**
    * Creates a version of an existing image which does not animate and is frozen
    * at the first frame.
    *

--- a/image/src/imgRequestProxy.h
+++ b/image/src/imgRequestProxy.h
@@ -27,17 +27,17 @@
      0x1dd2,                                         \
      0x11b2,                                         \
     {0x8f, 0x65, 0x9c, 0x46, 0x2e, 0xe2, 0xbc, 0x95} \
 }
 
 class imgINotificationObserver;
 class imgRequestNotifyRunnable;
 class imgStatusNotifyRunnable;
-class nsIntRect;
+struct nsIntRect;
 class ProxyBehaviour;
 
 namespace mozilla {
 namespace image {
 class Image;
 class ImageURL;
 } // namespace image
 } // namespace mozilla

--- a/js/public/Class.h
+++ b/js/public/Class.h
@@ -19,22 +19,22 @@
 
 /*
  * A JSClass acts as a vtable for JS objects that allows JSAPI clients to
  * control various aspects of the behavior of an object like property lookup.
  * js::Class is an engine-private extension that allows more control over
  * object behavior and, e.g., allows custom slow layout.
  */
 
-class JSFreeOp;
+struct JSFreeOp;
 struct JSFunctionSpec;
 
 namespace js {
 
-class Class;
+struct Class;
 class FreeOp;
 class PropertyName;
 class Shape;
 
 // This is equal to JSFunction::class_.  Use it in places where you don't want
 // to #include jsfun.h.
 extern JS_FRIEND_DATA(const js::Class* const) FunctionClassPtr;
 

--- a/js/public/OldDebugAPI.h
+++ b/js/public/OldDebugAPI.h
@@ -15,17 +15,17 @@
 
 #include "jsapi.h"
 #include "jsbytecode.h"
 
 #include "js/CallArgs.h"
 #include "js/TypeDecls.h"
 
 class JSAtom;
-class JSFreeOp;
+struct JSFreeOp;
 
 namespace js {
 class InterpreterFrame;
 class FrameIter;
 class ScriptSource;
 }
 
 // Raw JSScript* because this needs to be callable from a signal handler.

--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -1087,17 +1087,17 @@ MutableHandle<T>::MutableHandle(Persiste
  * containing Heap<T> or TenuredHeap<T> members to make sure their referents get
  * marked when the object itself is marked.
  */
 template<typename T>
 class PersistentRooted : private mozilla::LinkedListElement<PersistentRooted<T> > {
     friend class mozilla::LinkedList<PersistentRooted>;
     friend class mozilla::LinkedListElement<PersistentRooted>;
 
-    friend class js::gc::PersistentRootedMarker<T>;
+    friend struct js::gc::PersistentRootedMarker<T>;
 
     void registerWithRuntime(JSRuntime *rt) {
         JS::shadow::Runtime *srt = JS::shadow::Runtime::asShadowRuntime(rt);
         srt->getPersistentRootedList<T>().insertBack(this);
     }
 
   public:
     explicit PersistentRooted(JSContext *cx) : ptr(js::GCMethods<T>::initial())

--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -26,17 +26,17 @@
 
 namespace js {
 
 namespace gc {
 
 typedef Vector<JS::Zone *, 4, SystemAllocPolicy> ZoneVector;
 
 class MarkingValidator;
-class AutoPrepareForTracing;
+struct AutoPrepareForTracing;
 class AutoTraceSession;
 
 struct ConservativeGCData
 {
     /*
      * The GC scans conservatively between ThreadData::nativeStackBase and
      * nativeStackTop unless the latter is nullptr.
      */

--- a/js/src/gc/Heap.h
+++ b/js/src/gc/Heap.h
@@ -22,17 +22,17 @@
 #include "js/HeapAPI.h"
 
 struct JSCompartment;
 
 struct JSRuntime;
 
 namespace JS {
 namespace shadow {
-class Runtime;
+struct Runtime;
 }
 }
 
 namespace js {
 
 class FreeOp;
 
 namespace gc {

--- a/js/src/gc/Marking.h
+++ b/js/src/gc/Marking.h
@@ -15,29 +15,29 @@ class JSLinearString;
 namespace js {
 
 class ArgumentsObject;
 class ArrayBufferObject;
 class ArrayBufferViewObject;
 class SharedArrayBufferObject;
 class BaseShape;
 class DebugScopeObject;
-struct GCMarker;
+class GCMarker;
 class GlobalObject;
 class LazyScript;
 class ScopeObject;
 class Shape;
 class UnownedBaseShape;
 
 template<class> class HeapPtr;
 
 namespace jit {
 class JitCode;
-class IonScript;
-class VMFunction;
+struct IonScript;
+struct VMFunction;
 }
 
 namespace types {
 class Type;
 }
 
 namespace gc {
 

--- a/js/src/gc/Nursery.h
+++ b/js/src/gc/Nursery.h
@@ -28,17 +28,17 @@ struct Zone;
 
 namespace js {
 
 class ObjectElements;
 class HeapSlot;
 void SetGCZeal(JSRuntime *, uint8_t, uint32_t);
 
 namespace gc {
-class Cell;
+struct Cell;
 class Collector;
 class MinorCollectionTracer;
 class ForkJoinNursery;
 } /* namespace gc */
 
 namespace types {
 struct TypeObject;
 }

--- a/js/src/gc/StoreBuffer.cpp
+++ b/js/src/gc/StoreBuffer.cpp
@@ -371,16 +371,16 @@ JS::HeapValueRelocate(JS::Value *valuep)
     JS_ASSERT(valuep);
     JS_ASSERT(valuep->isMarkable());
     if (valuep->isString() && valuep->toString()->isPermanentAtom())
         return;
     JSRuntime *runtime = static_cast<js::gc::Cell *>(valuep->toGCThing())->runtimeFromMainThread();
     runtime->gc.storeBuffer.removeRelocatableValueFromAnyThread(valuep);
 }
 
-template class StoreBuffer::MonoTypeBuffer<StoreBuffer::ValueEdge>;
-template class StoreBuffer::MonoTypeBuffer<StoreBuffer::CellPtrEdge>;
-template class StoreBuffer::MonoTypeBuffer<StoreBuffer::SlotsEdge>;
-template class StoreBuffer::MonoTypeBuffer<StoreBuffer::WholeCellEdges>;
-template class StoreBuffer::RelocatableMonoTypeBuffer<StoreBuffer::ValueEdge>;
-template class StoreBuffer::RelocatableMonoTypeBuffer<StoreBuffer::CellPtrEdge>;
+template struct StoreBuffer::MonoTypeBuffer<StoreBuffer::ValueEdge>;
+template struct StoreBuffer::MonoTypeBuffer<StoreBuffer::CellPtrEdge>;
+template struct StoreBuffer::MonoTypeBuffer<StoreBuffer::SlotsEdge>;
+template struct StoreBuffer::MonoTypeBuffer<StoreBuffer::WholeCellEdges>;
+template struct StoreBuffer::RelocatableMonoTypeBuffer<StoreBuffer::ValueEdge>;
+template struct StoreBuffer::RelocatableMonoTypeBuffer<StoreBuffer::CellPtrEdge>;
 
 #endif /* JSGC_GENERATIONAL */

--- a/js/src/gc/Tracer.h
+++ b/js/src/gc/Tracer.h
@@ -12,23 +12,23 @@
 #include "js/GCAPI.h"
 #include "js/SliceBudget.h"
 #include "js/TracingAPI.h"
 
 namespace js {
 class GCMarker;
 class ObjectImpl;
 namespace gc {
-class ArenaHeader;
+struct ArenaHeader;
 }
 namespace jit {
 class JitCode;
 }
 namespace types {
-class TypeObject;
+struct TypeObject;
 }
 
 static const size_t NON_INCREMENTAL_MARK_STACK_BASE_CAPACITY = 4096;
 static const size_t INCREMENTAL_MARK_STACK_BASE_CAPACITY = 32768;
 
 /*
  * When the native stack is low, the GC does not call JS_TraceChildren to mark
  * the reachable "children" of the thing. Rather the thing is put aside and

--- a/js/src/jit/AsmJS.h
+++ b/js/src/jit/AsmJS.h
@@ -15,20 +15,20 @@
 
 #include "js/TypeDecls.h"
 #include "vm/ObjectImpl.h"
 
 namespace js {
 
 class ExclusiveContext;
 namespace frontend {
-    template <typename ParseHandler> struct Parser;
+    template <typename ParseHandler> class Parser;
     template <typename ParseHandler> struct ParseContext;
     class FullParseHandler;
-    struct ParseNode;
+    class ParseNode;
 }
 
 typedef frontend::Parser<frontend::FullParseHandler> AsmJSParser;
 typedef frontend::ParseContext<frontend::FullParseHandler> AsmJSParseContext;
 
 // Takes over parsing of a function starting with "use asm". The return value
 // indicates whether an error was reported which the caller should propagate.
 // If no error was reported, the function may still fail to validate as asm.js.

--- a/js/src/jit/AsmJSLink.h
+++ b/js/src/jit/AsmJSLink.h
@@ -10,17 +10,17 @@
 #include "NamespaceImports.h"
 
 class JSAtom;
 
 namespace js {
 
 class AsmJSActivation;
 class AsmJSModule;
-namespace jit { class CallSite; }
+namespace jit { struct CallSite; }
 
 // Iterates over the frames of a single AsmJSActivation.
 class AsmJSFrameIterator
 {
     const AsmJSModule *module_;
     const jit::CallSite *callsite_;
     uint8_t *sp_;
 

--- a/js/src/jit/Recover.h
+++ b/js/src/jit/Recover.h
@@ -6,17 +6,17 @@
 
 #ifndef jit_Recover_h
 #define jit_Recover_h
 
 #include "mozilla/Attributes.h"
 
 #include "jit/Snapshots.h"
 
-class JSContext;
+struct JSContext;
 
 namespace js {
 namespace jit {
 
 #define RECOVER_OPCODE_LIST(_)                  \
     _(ResumePoint)                              \
     _(BitNot)                                   \
     _(BitAnd)                                   \

--- a/js/src/jsalloc.h
+++ b/js/src/jsalloc.h
@@ -14,17 +14,17 @@
 #ifndef jsalloc_h
 #define jsalloc_h
 
 #include "js/TypeDecls.h"
 #include "js/Utility.h"
 
 namespace js {
 
-class ContextFriendFields;
+struct ContextFriendFields;
 
 /* Policy for using system memory functions and doing no error reporting. */
 class SystemAllocPolicy
 {
   public:
     void *malloc_(size_t bytes) { return js_malloc(bytes); }
     void *calloc_(size_t bytes) { return js_calloc(bytes); }
     void *realloc_(void *p, size_t oldBytes, size_t bytes) { return js_realloc(p, bytes); }

--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -32,17 +32,17 @@
 #endif
 
 #define JS_CHECK_STACK_SIZE(limit, lval) JS_CHECK_STACK_SIZE_WITH_TOLERANCE(limit, lval, 0)
 
 class JSAtom;
 struct JSErrorFormatString;
 class JSLinearString;
 struct JSJitInfo;
-class JSErrorReport;
+struct JSErrorReport;
 
 namespace JS {
 template <class T>
 class Heap;
 } /* namespace JS */
 
 extern JS_FRIEND_API(void)
 JS_SetGrayGCRootsTracer(JSRuntime *rt, JSTraceDataOp traceOp, void *data);

--- a/js/src/jsinfer.h
+++ b/js/src/jsinfer.h
@@ -204,19 +204,19 @@ template <> struct ExecutionModeTraits<P
 namespace jit {
     struct IonScript;
     class IonAllocPolicy;
     class TempAllocator;
 }
 
 namespace types {
 
-class TypeZone;
+struct TypeZone;
 class TypeSet;
-class TypeObjectKey;
+struct TypeObjectKey;
 
 /*
  * Information about a single concrete type. We pack this into a single word,
  * where small values are particular primitive or other singleton types, and
  * larger values are either specific JS objects or type objects.
  */
 class Type
 {
@@ -1395,17 +1395,17 @@ struct TypeObjectKey
 // by the compiler, but this is only done on the main thread. If we are
 // compiling off thread and use a property which has not yet been instantiated,
 // it will be treated as empty and non-configured and will be instantiated when
 // rejoining to the main thread. If it is in fact not empty, the compilation
 // will fail; to avoid this, we try to instantiate singleton property types
 // during generation of baseline caches.
 class HeapTypeSetKey
 {
-    friend class TypeObjectKey;
+    friend struct TypeObjectKey;
 
     // Object and property being accessed.
     TypeObjectKey *object_;
     jsid id_;
 
     // If instantiated, the underlying heap type set.
     HeapTypeSet *maybeTypes_;
 

--- a/js/src/jsobj.h
+++ b/js/src/jsobj.h
@@ -28,17 +28,17 @@
 
 namespace JS {
 struct ObjectsExtraSizes;
 }
 
 namespace js {
 
 class AutoPropDescVector;
-struct GCMarker;
+class GCMarker;
 struct NativeIterator;
 class Nursery;
 struct StackShape;
 
 inline JSObject *
 CastAsObject(PropertyOp op)
 {
     return JS_FUNC_TO_DATA_PTR(JSObject *, op);
@@ -202,18 +202,18 @@ class ForkJoinNursery;
  *
  * The JSFunction struct is an extension of this struct allocated from a larger
  * GC size-class.
  */
 class JSObject : public js::ObjectImpl
 {
   private:
     friend class js::Shape;
-    friend struct js::GCMarker;
-    friend class  js::NewObjectCache;
+    friend class js::GCMarker;
+    friend class js::NewObjectCache;
     friend class js::Nursery;
     friend class js::gc::ForkJoinNursery;
 
     /* Make the type object to use for LAZY_TYPE objects. */
     static js::types::TypeObject *makeLazyType(JSContext *cx, js::HandleObject obj);
 
   public:
     static const js::Class class_;

--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -326,17 +326,17 @@ namespace js {
  * Parallel operations in general can have one of three states. They may
  * succeed, fail, or "bail", where bail indicates that the code encountered an
  * unexpected condition and should be re-run sequentially. Different
  * subcategories of the "bail" state are encoded as variants of TP_RETRY_*.
  */
 enum ParallelResult { TP_SUCCESS, TP_RETRY_SEQUENTIALLY, TP_RETRY_AFTER_GC, TP_FATAL };
 
 struct ThreadSafeContext;
-struct ForkJoinContext;
+class ForkJoinContext;
 class ExclusiveContext;
 
 class Allocator;
 
 enum ThingRootKind
 {
     THING_ROOT_OBJECT,
     THING_ROOT_SHAPE,

--- a/js/src/jsscript.h
+++ b/js/src/jsscript.h
@@ -46,17 +46,17 @@ class BindingIter;
 class LazyScript;
 class RegExpObject;
 struct SourceCompressionTask;
 class Shape;
 class WatchpointMap;
 class NestedScopeObject;
 
 namespace frontend {
-    class BytecodeEmitter;
+    struct BytecodeEmitter;
 }
 
 }
 
 /*
  * Type of try note associated with each catch or finally block, and also with
  * for-in and other kinds of loops. Non-for-in loops do not need these notes
  * for exception unwinding, but storing their boundaries here is helpful for
@@ -379,17 +379,17 @@ class SourceDataCache
 
   private:
     void holdEntry(AutoHoldEntry &holder, ScriptSource *ss);
     void releaseEntry(AutoHoldEntry &holder);
 };
 
 class ScriptSource
 {
-    friend class SourceCompressionTask;
+    friend struct SourceCompressionTask;
 
     uint32_t refs;
 
     // Note: while ScriptSources may be compressed off thread, they are only
     // modified by the main thread, and all members are always safe to access
     // on the main thread.
 
     // Indicate which field in the |data| union is active.

--- a/js/src/vm/ForkJoin.h
+++ b/js/src/vm/ForkJoin.h
@@ -342,17 +342,17 @@ struct ParallelBailoutRecord {
     void updateCause(ParallelBailoutCause cause,
                      JSScript *outermostScript,
                      JSScript *currentScript,
                      jsbytecode *currentPc);
     void addTrace(JSScript *script,
                   jsbytecode *pc);
 };
 
-struct ForkJoinShared;
+class ForkJoinShared;
 
 class ForkJoinContext : public ThreadSafeContext
 {
   public:
     // Bailout record used to record the reason this thread stopped executing
     ParallelBailoutRecord *const bailoutRecord;
 
 #ifdef FORKJOIN_SPEW

--- a/js/src/vm/HelperThreads.h
+++ b/js/src/vm/HelperThreads.h
@@ -452,17 +452,17 @@ OffThreadParsingMustWaitForGC(JSRuntime 
 #endif
 
 // Compression tasks are allocated on the stack by their triggering thread,
 // which will block on the compression completing as the task goes out of scope
 // to ensure it completes at the required time.
 struct SourceCompressionTask
 {
     friend class ScriptSource;
-    friend class HelperThread;
+    friend struct HelperThread;
 
 #ifdef JS_THREADSAFE
     // Thread performing the compression.
     HelperThread *helperThread;
 #endif
 
   private:
     // Context from the triggering thread. Don't use this off thread!

--- a/js/src/vm/ObjectImpl.h
+++ b/js/src/vm/ObjectImpl.h
@@ -256,17 +256,17 @@ class ObjectElements
 
     static const size_t VALUES_PER_HEADER = 2;
 };
 
 /* Shared singleton for objects with no elements. */
 extern HeapSlot *const emptyObjectElements;
 
 struct Class;
-struct GCMarker;
+class GCMarker;
 struct ObjectOps;
 class Shape;
 
 class NewObjectCache;
 class TaggedProto;
 
 inline Value
 ObjectValue(ObjectImpl &obj);
@@ -486,17 +486,17 @@ class ObjectImpl : public gc::BarrieredC
                       HeapSlot **fixedStart, HeapSlot **fixedEnd,
                       HeapSlot **slotsStart, HeapSlot **slotsEnd)
     {
         MOZ_ASSERT(slotInRange(start + length, SENTINEL_ALLOWED));
         getSlotRangeUnchecked(start, length, fixedStart, fixedEnd, slotsStart, slotsEnd);
     }
 
   protected:
-    friend struct GCMarker;
+    friend class GCMarker;
     friend class Shape;
     friend class NewObjectCache;
 
     void invalidateSlotRange(uint32_t start, uint32_t length) {
 #ifdef DEBUG
         HeapSlot *fixedStart, *fixedEnd, *slotsStart, *slotsEnd;
         getSlotRange(start, length, &fixedStart, &fixedEnd, &slotsStart, &slotsEnd);
         Debug_SetSlotRangeToCrashOnTouch(fixedStart, fixedEnd);

--- a/js/src/vm/RegExpObject.h
+++ b/js/src/vm/RegExpObject.h
@@ -32,17 +32,17 @@
  * needed for execution. When a RegExpShared needs to be created, it is looked
  * up in a per-compartment table to allow reuse between objects. Lastly, on
  * GC, every RegExpShared (that is not active on the callstack) is discarded.
  * Because of the last point, any code using a RegExpShared (viz., by executing
  * a regexp) must indicate the RegExpShared is active via RegExpGuard.
  */
 namespace js {
 
-class MatchPair;
+struct MatchPair;
 class MatchPairs;
 class RegExpShared;
 
 namespace frontend { class TokenStream; }
 
 enum RegExpFlag
 {
     IgnoreCaseFlag  = 0x01,

--- a/js/src/vm/Runtime.h
+++ b/js/src/vm/Runtime.h
@@ -44,17 +44,17 @@
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable:4100) /* Silence unreferenced formal parameter warnings */
 #endif
 
 namespace js {
 
 class PerThreadData;
-class ThreadSafeContext;
+struct ThreadSafeContext;
 class AutoKeepAtoms;
 #ifdef JS_TRACE_LOGGING
 class TraceLogger;
 #endif
 
 /* Thread Local Storage slot for storing the runtime for a thread. */
 extern mozilla::ThreadLocal<PerThreadData*> TlsPerThreadData;
 
@@ -81,17 +81,17 @@ class AsmJSActivation;
 class MathCache;
 
 namespace jit {
 class JitRuntime;
 class JitActivation;
 struct PcScriptCache;
 class Simulator;
 class SimulatorRuntime;
-class AutoFlushICache;
+struct AutoFlushICache;
 }
 
 /*
  * GetSrcNote cache to avoid O(n^2) growth in finding a source note for a
  * given pc in a script. We use the script->code pointer to tag the cache,
  * instead of the script address itself, so that source notes are always found
  * by offset from the bytecode with which they were generated.
  */

--- a/js/src/vm/Stack.h
+++ b/js/src/vm/Stack.h
@@ -28,17 +28,17 @@ class ArgumentsObject;
 class AsmJSModule;
 class InterpreterRegs;
 class ScopeObject;
 class ScriptFrameIter;
 class SPSProfiler;
 class InterpreterFrame;
 class StaticBlockObject;
 
-struct ScopeCoordinate;
+class ScopeCoordinate;
 
 // VM stack layout
 //
 // A JSRuntime's stack consists of a linked list of activations. Every activation
 // contains a number of scripted frames that are either running in the interpreter
 // (InterpreterActivation) or JIT code (JitActivation). The frames inside a single
 // activation are contiguous: whenever C++ calls back into JS, a new activation is
 // pushed.

--- a/js/xpconnect/src/XPCQuickStubs.h
+++ b/js/xpconnect/src/XPCQuickStubs.h
@@ -7,17 +7,17 @@
 #ifndef xpcquickstubs_h___
 #define xpcquickstubs_h___
 
 #include "XPCForwards.h"
 
 class qsObjectHelper;
 namespace mozilla {
 namespace dom {
-class NativePropertiesHolder;
+struct NativePropertiesHolder;
 }
 }
 
 /* XPCQuickStubs.h - Support functions used only by quick stubs. */
 
 class XPCCallContext;
 
 #define XPC_QS_NULL_INDEX  ((uint16_t) -1)

--- a/layout/base/GeometryUtils.h
+++ b/layout/base/GeometryUtils.h
@@ -21,17 +21,17 @@ class nsIDocument;
 namespace mozilla {
 
 namespace dom {
 struct BoxQuadOptions;
 struct ConvertCoordinateOptions;
 class DOMQuad;
 class DOMRectReadOnly;
 class DOMPoint;
-class DOMPointInit;
+struct DOMPointInit;
 class OwningTextOrElementOrDocument;
 class TextOrElementOrDocument;
 }
 
 typedef dom::TextOrElementOrDocument GeometryNode;
 typedef dom::OwningTextOrElementOrDocument OwningGeometryNode;
 
 /**

--- a/layout/base/nsLayoutUtils.h
+++ b/layout/base/nsLayoutUtils.h
@@ -51,17 +51,17 @@ class gfxDrawable;
 class nsView;
 class nsIFrame;
 class nsStyleCoord;
 class nsStyleCorners;
 class gfxContext;
 class nsPIDOMWindow;
 class imgIRequest;
 class nsIDocument;
-class gfxPoint;
+struct gfxPoint;
 struct nsStyleFont;
 struct nsStyleImageOrientation;
 struct nsOverflowAreas;
 
 namespace mozilla {
 class SVGImageContext;
 struct IntrinsicSize;
 struct ContainerLayerParameters;

--- a/layout/forms/nsButtonFrameRenderer.h
+++ b/layout/forms/nsButtonFrameRenderer.h
@@ -10,17 +10,17 @@
 #include "nsMargin.h"
 
 class nsIFrame;
 class nsFrame;
 class nsDisplayList;
 class nsDisplayListBuilder;
 class nsPresContext;
 class nsRenderingContext;
-class nsRect;
+struct nsRect;
 class nsStyleContext;
 
 
 #define NS_BUTTON_RENDERER_FOCUS_INNER_CONTEXT_INDEX  0
 #define NS_BUTTON_RENDERER_FOCUS_OUTER_CONTEXT_INDEX  1
 #define NS_BUTTON_RENDERER_LAST_CONTEXT_INDEX   NS_BUTTON_RENDERER_FOCUS_OUTER_CONTEXT_INDEX
 
 class nsButtonFrameRenderer {

--- a/layout/generic/StickyScrollContainer.h
+++ b/layout/generic/StickyScrollContainer.h
@@ -11,17 +11,17 @@
 
 #ifndef StickyScrollContainer_h
 #define StickyScrollContainer_h
 
 #include "nsPoint.h"
 #include "nsTArray.h"
 #include "nsIScrollPositionListener.h"
 
-class nsRect;
+struct nsRect;
 class nsIFrame;
 class nsIScrollableFrame;
 
 namespace mozilla {
 
 class StickyScrollContainer MOZ_FINAL : public nsIScrollPositionListener
 {
 public:

--- a/layout/generic/nsAbsoluteContainingBlock.h
+++ b/layout/generic/nsAbsoluteContainingBlock.h
@@ -10,17 +10,17 @@
 
 #ifndef nsAbsoluteContainingBlock_h___
 #define nsAbsoluteContainingBlock_h___
 
 #include "nsFrameList.h"
 #include "nsIFrame.h"
 
 class nsContainerFrame;
-class nsHTMLReflowState;
+struct nsHTMLReflowState;
 class nsPresContext;
 
 /**
  * This class contains the logic for being an absolute containing block.  This
  * class is used within viewport frames (for frames representing content with
  * fixed position) and blocks (for frames representing absolutely positioned
  * content), since each set of frames is absolutely positioned with respect to
  * its parent.

--- a/layout/generic/nsFlexContainerFrame.h
+++ b/layout/generic/nsFlexContainerFrame.h
@@ -30,17 +30,17 @@ public:
   // Factory method:
   friend nsContainerFrame* NS_NewFlexContainerFrame(nsIPresShell* aPresShell,
                                                     nsStyleContext* aContext);
 
   // Forward-decls of helper classes
   class FlexItem;
   class FlexLine;
   class FlexboxAxisTracker;
-  class StrutInfo;
+  struct StrutInfo;
 
   // nsIFrame overrides
   virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,
                                 const nsRect&           aDirtyRect,
                                 const nsDisplayListSet& aLists) MOZ_OVERRIDE;
 
   virtual void Reflow(nsPresContext*           aPresContext,
                       nsHTMLReflowMetrics&     aDesiredSize,

--- a/layout/generic/nsHTMLReflowMetrics.h
+++ b/layout/generic/nsHTMLReflowMetrics.h
@@ -9,17 +9,17 @@
 #define nsHTMLReflowMetrics_h___
 
 #include "nsRect.h"
 #include "nsBoundingMetrics.h"
 #include "WritingModes.h"
 
 //----------------------------------------------------------------------
 
-class nsHTMLReflowState;
+struct nsHTMLReflowState;
 
 // Option flags
 #define NS_REFLOW_CALC_BOUNDING_METRICS  0x0001
 
 /**
  * When we store overflow areas as an array of scrollable and visual
  * overflow, we use these indices.
  *

--- a/layout/generic/nsImageFrame.h
+++ b/layout/generic/nsImageFrame.h
@@ -19,17 +19,17 @@
 #include "mozilla/Attributes.h"
 #include "mozilla/DebugOnly.h"
 #include "nsIReflowCallback.h"
 
 class nsImageMap;
 class nsIURI;
 class nsILoadGroup;
 struct nsHTMLReflowState;
-struct nsHTMLReflowMetrics;
+class nsHTMLReflowMetrics;
 class nsDisplayImage;
 class nsPresContext;
 class nsImageFrame;
 class nsTransform2D;
 class nsImageLoadingContent;
 
 namespace mozilla {
 namespace layers {

--- a/layout/mathml/nsIMathMLFrame.h
+++ b/layout/mathml/nsIMathMLFrame.h
@@ -6,17 +6,17 @@
 #ifndef nsIMathMLFrame_h___
 #define nsIMathMLFrame_h___
 
 #include "nsQueryFrame.h"
 #include "nsMathMLOperators.h"
 
 struct nsPresentationData;
 struct nsEmbellishData;
-struct nsHTMLReflowMetrics;
+class nsHTMLReflowMetrics;
 class nsRenderingContext;
 class nsIFrame;
 
 // For MathML, this 'type' will be used to determine the spacing between frames
 // Subclasses can return a 'type' that will give them a particular spacing
 enum eMathMLFrameType {
   eMathMLFrameType_UNKNOWN = -1,
   eMathMLFrameType_Ordinary,

--- a/layout/mathml/nsMathMLChar.h
+++ b/layout/mathml/nsMathMLChar.h
@@ -15,19 +15,19 @@
 #include "gfxFont.h"
 
 class nsGlyphTable;
 class nsIFrame;
 class nsDisplayListBuilder;
 class nsDisplayListSet;
 class nsPresContext;
 class nsRenderingContext;
-class nsBoundingMetrics;
+struct nsBoundingMetrics;
 class nsStyleContext;
-class nsFont;
+struct nsFont;
 
 // Hints for Stretch() to indicate criteria for stretching
 enum {
   // Don't stretch
   NS_STRETCH_NONE     = 0x00,
   // Variable size stretches
   NS_STRETCH_VARIABLE_MASK = 0x0F,
   NS_STRETCH_NORMAL   = 0x01, // try to stretch to requested size

--- a/layout/style/AnimationCommon.h
+++ b/layout/style/AnimationCommon.h
@@ -18,17 +18,17 @@
 #include "nsStyleStruct.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/FloatingPoint.h"
 #include "nsCSSPseudoElements.h"
 
 class nsIFrame;
 class nsPresContext;
 class nsStyleChangeList;
-class ElementPropertyTransition;
+struct ElementPropertyTransition;
 
 
 namespace mozilla {
 namespace css {
 
 bool IsGeometricProperty(nsCSSProperty aProperty);
 
 struct CommonElementAnimationData;

--- a/layout/style/CSSVariableDeclarations.h
+++ b/layout/style/CSSVariableDeclarations.h
@@ -8,17 +8,17 @@
 #ifndef mozilla_CSSVariableDeclarations_h
 #define mozilla_CSSVariableDeclarations_h
 
 #include "nsDataHashtable.h"
 
 namespace mozilla {
 class CSSVariableResolver;
 }
-class nsRuleData;
+struct nsRuleData;
 
 namespace mozilla {
 
 class CSSVariableDeclarations
 {
 public:
   CSSVariableDeclarations();
   CSSVariableDeclarations(const CSSVariableDeclarations& aOther);

--- a/layout/style/ImageLoader.h
+++ b/layout/style/ImageLoader.h
@@ -21,17 +21,17 @@ class nsIFrame;
 class nsIDocument;
 class nsPresContext;
 class nsIURI;
 class nsIPrincipal;
 
 namespace mozilla {
 namespace css {
 
-class ImageValue;
+struct ImageValue;
 
 class ImageLoader MOZ_FINAL : public imgINotificationObserver,
                               public imgIOnloadBlocker {
 public:
   typedef mozilla::css::ImageValue Image;
 
   ImageLoader(nsIDocument* aDocument)
   : mDocument(aDocument),

--- a/layout/style/nsCSSParser.h
+++ b/layout/style/nsCSSParser.h
@@ -18,17 +18,17 @@
 
 class nsCSSStyleSheet;
 class nsIPrincipal;
 class nsIURI;
 struct nsCSSSelectorList;
 class nsMediaList;
 class nsCSSKeyframeRule;
 class nsCSSValue;
-class nsRuleData;
+struct nsRuleData;
 
 namespace mozilla {
 class CSSVariableValues;
 namespace css {
 class Rule;
 class Declaration;
 class Loader;
 class StyleRule;

--- a/layout/style/nsComputedDOMStyle.h
+++ b/layout/style/nsComputedDOMStyle.h
@@ -26,47 +26,47 @@ namespace dom {
 class Element;
 }
 }
 
 struct nsComputedStyleMap;
 class nsIFrame;
 class nsIPresShell;
 class nsDOMCSSValueList;
-class nsMargin;
+struct nsMargin;
 class nsROCSSPrimitiveValue;
-class nsStyleBackground;
-class nsStyleBorder;
-class nsStyleContent;
-class nsStyleColumn;
-class nsStyleColor;
+struct nsStyleBackground;
+struct nsStyleBorder;
+struct nsStyleContent;
+struct nsStyleColumn;
+struct nsStyleColor;
 class nsStyleCoord;
 class nsStyleCorners;
-class nsStyleDisplay;
-class nsStyleFilter;
-class nsStyleFont;
+struct nsStyleDisplay;
+struct nsStyleFilter;
+struct nsStyleFont;
 class nsStyleGradient;
-class nsStyleImage;
-class nsStyleList;
-class nsStyleMargin;
-class nsStyleOutline;
-class nsStylePadding;
-class nsStylePosition;
-class nsStyleQuotes;
+struct nsStyleImage;
+struct nsStyleList;
+struct nsStyleMargin;
+struct nsStyleOutline;
+struct nsStylePadding;
+struct nsStylePosition;
+struct nsStyleQuotes;
 class nsStyleSides;
-class nsStyleSVG;
-class nsStyleSVGReset;
-class nsStyleTable;
-class nsStyleText;
-class nsStyleTextReset;
+struct nsStyleSVG;
+struct nsStyleSVGReset;
+struct nsStyleTable;
+struct nsStyleText;
+struct nsStyleTextReset;
 class nsStyleTimingFunction;
-class nsStyleUIReset;
-class nsStyleVisibility;
-class nsStyleXUL;
-class nsTimingFunction;
+struct nsStyleUIReset;
+struct nsStyleVisibility;
+struct nsStyleXUL;
+struct nsTimingFunction;
 class gfx3DMatrix;
 
 class nsComputedDOMStyle MOZ_FINAL : public nsDOMCSSDeclaration
 {
 public:
   typedef nsCSSProps::KTableValue KTableValue;
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

--- a/layout/style/nsStyleUtil.h
+++ b/layout/style/nsStyleUtil.h
@@ -14,17 +14,17 @@
 class nsCSSValue;
 class nsStringComparator;
 class nsStyleCoord;
 class nsIContent;
 class nsIPrincipal;
 class nsIURI;
 struct gfxFontFeature;
 struct gfxAlternateValue;
-class nsCSSValueList;
+struct nsCSSValueList;
 
 // Style utility functions
 class nsStyleUtil {
 public:
 
  static bool DashMatchCompare(const nsAString& aAttributeValue,
                                 const nsAString& aSelectorValue,
                                 const nsStringComparator& aComparator);

--- a/layout/xul/nsBoxLayoutState.h
+++ b/layout/xul/nsBoxLayoutState.h
@@ -14,17 +14,17 @@
 #define nsBoxLayoutState_h___
 
 #include "nsCOMPtr.h"
 #include "nsPresContext.h"
 #include "nsIPresShell.h"
 
 class nsRenderingContext;
 class nsCalculatedBoxInfo;
-struct nsHTMLReflowMetrics;
+class nsHTMLReflowMetrics;
 struct nsHTMLReflowState;
 class nsString;
 class nsHTMLReflowCommand;
 
 class MOZ_STACK_CLASS nsBoxLayoutState
 {
 public:
   nsBoxLayoutState(nsPresContext* aPresContext,

--- a/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.h
+++ b/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.h
@@ -11,17 +11,17 @@
 #define mediapipelinefilter_h__
 
 #include <cstddef>
 #include <stdint.h>
 
 #include <set>
 
 namespace webrtc {
-class RTPHeader;
+struct RTPHeader;
 }
 
 namespace mozilla {
 
 // A class that handles the work of filtering RTP packets that arrive at a
 // MediaPipeline. This is primarily important for the use of BUNDLE (ie;
 // multiple m-lines share the same RTP stream). There are three ways that this
 // can work;

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
@@ -67,18 +67,18 @@ class MediaPipeline;
 
 #ifdef USE_FAKE_MEDIA_STREAMS
 typedef Fake_DOMMediaStream DOMMediaStream;
 #else
 class DOMMediaStream;
 #endif
 
 namespace dom {
-class RTCConfiguration;
-class MediaConstraintsInternal;
+struct RTCConfiguration;
+struct MediaConstraintsInternal;
 class MediaStreamTrack;
 
 #ifdef USE_FAKE_PCOBSERVER
 typedef test::AFakePCObserver PeerConnectionObserver;
 typedef const char *PCObserverString;
 #else
 class PeerConnectionObserver;
 typedef NS_ConvertUTF8toUTF16 PCObserverString;
@@ -202,17 +202,17 @@ class RTCStatsQuery {
 class PeerConnectionImpl MOZ_FINAL : public nsISupports,
 #ifdef MOZILLA_INTERNAL_API
                                      public mozilla::DataChannelConnection::DataConnectionListener,
                                      public nsNSSShutDownObject,
                                      public DOMMediaStream::PrincipalChangeObserver,
 #endif
                                      public sigslot::has_slots<>
 {
-  class Internal; // Avoid exposing c includes to bindings
+  struct Internal; // Avoid exposing c includes to bindings
 
 public:
   PeerConnectionImpl(const mozilla::dom::GlobalObject* aGlobal = nullptr);
   virtual ~PeerConnectionImpl();
 
   enum Error {
     kNoError                          = 0,
     kInvalidConstraintsType           = 1,

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
@@ -32,18 +32,18 @@
 #endif
 
 class nsIPrincipal;
 
 namespace mozilla {
 class DataChannel;
 class PeerIdentity;
 namespace dom {
-class RTCInboundRTPStreamStats;
-class RTCOutboundRTPStreamStats;
+struct RTCInboundRTPStreamStats;
+struct RTCOutboundRTPStreamStats;
 }
 }
 
 #include "nricectx.h"
 #include "nriceresolver.h"
 #include "nricemediastream.h"
 #include "MediaPipeline.h"
 

--- a/netwerk/base/src/BackgroundFileSaver.h
+++ b/netwerk/base/src/BackgroundFileSaver.h
@@ -20,17 +20,17 @@
 #include "nsIBackgroundFileSaver.h"
 #include "nsIStreamListener.h"
 #include "nsStreamUtils.h"
 #include "ScopedNSSTypes.h"
 
 class nsIAsyncInputStream;
 class nsIThread;
 class nsIX509CertList;
-class PRLogModuleInfo;
+struct PRLogModuleInfo;
 
 namespace mozilla {
 namespace net {
 
 class DigestOutputStream;
 
 ////////////////////////////////////////////////////////////////////////////////
 //// BackgroundFileSaver

--- a/toolkit/components/downloads/ApplicationReputation.h
+++ b/toolkit/components/downloads/ApplicationReputation.h
@@ -13,17 +13,17 @@
 #include "nsISupports.h"
 
 #include "nsCOMPtr.h"
 #include "nsString.h"
 
 class nsIRequest;
 class PendingDBLookup;
 class PendingLookup;
-class PRLogModuleInfo;
+struct PRLogModuleInfo;
 
 class ApplicationReputationService MOZ_FINAL :
   public nsIApplicationReputationService {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIAPPLICATIONREPUTATIONSERVICE
 
 public:

--- a/tools/profiler/platform.h
+++ b/tools/profiler/platform.h
@@ -244,17 +244,17 @@ void set_tls_stack_top(void* stackTop);
 
 // ----------------------------------------------------------------------------
 // Sampler
 //
 // A sampler periodically samples the state of the VM and optionally
 // (if used for profiling) the program counter and stack pointer for
 // the thread that created it.
 
-class PseudoStack;
+struct PseudoStack;
 class ThreadProfile;
 
 // TickSample captures the information collected for each sample.
 class TickSample {
  public:
   TickSample()
       :
         pc(NULL),

--- a/widget/nsIRollupListener.h
+++ b/widget/nsIRollupListener.h
@@ -6,17 +6,17 @@
 
 #ifndef __nsIRollupListener_h__
 #define __nsIRollupListener_h__
 
 #include "nsTArray.h"
 
 class nsIContent;
 class nsIWidget;
-class nsIntPoint;
+struct nsIntPoint;
 
 class nsIRollupListener {
  public: 
 
   /**
    * Notifies the object to rollup, optionally returning the node that
    * was just rolled up.
    *

--- a/widget/xpwidgets/PuppetWidget.h
+++ b/widget/xpwidgets/PuppetWidget.h
@@ -30,17 +30,17 @@ class gfxASurface;
 namespace mozilla {
 
 namespace dom {
 class TabChild;
 }
 
 namespace widget {
 
-class AutoCacheNativeKeyCommands;
+struct AutoCacheNativeKeyCommands;
 
 class PuppetWidget : public nsBaseWidget, public nsSupportsWeakReference
 {
   typedef mozilla::dom::TabChild TabChild;
   typedef mozilla::gfx::DrawTarget DrawTarget;
   typedef nsBaseWidget Base;
 
   // The width and height of the "widget" are clamped to this.
@@ -136,17 +136,17 @@ public:
   { return NS_ERROR_UNEXPECTED; }
 
   NS_IMETHOD_(bool)
   ExecuteNativeKeyBinding(NativeKeyBindingsType aType,
                           const mozilla::WidgetKeyboardEvent& aEvent,
                           DoCommandCallback aCallback,
                           void* aCallbackData) MOZ_OVERRIDE;
 
-  friend class AutoCacheNativeKeyCommands;
+  friend struct AutoCacheNativeKeyCommands;
 
   //
   // nsBaseWidget methods we override
   //
 
   // Documents loaded in child processes are always subdocuments of
   // other docs in an ancestor process.  To ensure that the
   // backgrounds of those documents are painted like those of

--- a/xpcom/base/CycleCollectedJSRuntime.h
+++ b/xpcom/base/CycleCollectedJSRuntime.h
@@ -15,17 +15,17 @@
 #include "nsDataHashtable.h"
 #include "nsHashKeys.h"
 #include "nsTArray.h"
 
 class nsCycleCollectionNoteRootCallback;
 class nsIException;
 
 namespace js {
-class Class;
+struct Class;
 }
 
 namespace mozilla {
 
 class JSGCThingParticipant: public nsCycleCollectionParticipant
 {
 public:
   NS_IMETHOD_(void) Root(void* aPtr)

--- a/xpcom/reflect/xptinfo/public/XPTInterfaceInfoManager.h
+++ b/xpcom/reflect/xptinfo/public/XPTInterfaceInfoManager.h
@@ -12,18 +12,18 @@
 
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/ReentrantMonitor.h"
 #include "nsDataHashtable.h"
 
 template<typename T> class nsCOMArray;
 class nsIMemoryReporter;
-class XPTHeader;
-class XPTInterfaceDirectoryEntry;
+struct XPTHeader;
+struct XPTInterfaceDirectoryEntry;
 class xptiInterfaceEntry;
 class xptiInterfaceInfo;
 class xptiTypelibGuts;
 
 namespace mozilla {
 
 class XPTInterfaceInfoManager MOZ_FINAL
     : public nsIInterfaceInfoManager