merge mozilla-inbound to mozilla-central

2014-01-20 15:34:26 +01:00 · 2014-01-20 15:34:26 +01:00 · 3c62a7c304
--- a/dom/plugins/ipc/BrowserStreamChild.h
+++ b/dom/plugins/ipc/BrowserStreamChild.h
@ -39,10 +39,10 @@ public:

  virtual bool RecvWrite(const int32_t& offset,
                         const Buffer& data,
-                         const uint32_t& newsize);
-  virtual bool RecvNPP_StreamAsFile(const nsCString& fname);
-  virtual bool RecvNPP_DestroyStream(const NPReason& reason);
-  virtual bool Recv__delete__();
+                         const uint32_t& newsize) MOZ_OVERRIDE;
+  virtual bool RecvNPP_StreamAsFile(const nsCString& fname) MOZ_OVERRIDE;
+  virtual bool RecvNPP_DestroyStream(const NPReason& reason) MOZ_OVERRIDE;
+  virtual bool Recv__delete__() MOZ_OVERRIDE;

  void EnsureCorrectInstance(PluginInstanceChild* i)
  {
--- a/dom/plugins/ipc/BrowserStreamParent.h
+++ b/dom/plugins/ipc/BrowserStreamParent.h
@ -27,11 +27,11 @@ public:
  virtual bool IsBrowserStream() MOZ_OVERRIDE { return true; }

  virtual bool AnswerNPN_RequestRead(const IPCByteRanges& ranges,
-                                     NPError* result);
+                                     NPError* result) MOZ_OVERRIDE;

-  virtual bool RecvNPN_DestroyStream(const NPReason& reason);
+  virtual bool RecvNPN_DestroyStream(const NPReason& reason) MOZ_OVERRIDE;

-  virtual bool RecvStreamDestroyed();
+  virtual bool RecvStreamDestroyed() MOZ_OVERRIDE;

  int32_t WriteReady();
  int32_t Write(int32_t offset, int32_t len, void* buffer);
--- a/dom/plugins/ipc/PluginIdentifierParent.h
+++ b/dom/plugins/ipc/PluginIdentifierParent.h
@ -64,7 +64,7 @@ protected:
    MOZ_COUNT_DTOR(PluginIdentifierParent);
  }

-  virtual bool RecvRetain();
+  virtual bool RecvRetain() MOZ_OVERRIDE;

  void AddTemporaryRef() {
    mTemporaryRefs++;
--- a/dom/plugins/ipc/PluginInstanceChild.h
+++ b/dom/plugins/ipc/PluginInstanceChild.h
@ -69,44 +69,50 @@ class PluginInstanceChild : public PPluginInstanceChild
 #endif

 protected:
-    virtual bool AnswerNPP_SetWindow(const NPRemoteWindow& window);
+    virtual bool AnswerNPP_SetWindow(const NPRemoteWindow& window) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPP_GetValue_NPPVpluginWantsAllNetworkStreams(bool* wantsAllStreams, NPError* rv);
+    AnswerNPP_GetValue_NPPVpluginWantsAllNetworkStreams(bool* wantsAllStreams, NPError* rv) MOZ_OVERRIDE;
    virtual bool
-    AnswerNPP_GetValue_NPPVpluginNeedsXEmbed(bool* needs, NPError* rv);
+    AnswerNPP_GetValue_NPPVpluginNeedsXEmbed(bool* needs, NPError* rv) MOZ_OVERRIDE;
    virtual bool
    AnswerNPP_GetValue_NPPVpluginScriptableNPObject(PPluginScriptableObjectChild** value,
-                                                    NPError* result);
+                                                    NPError* result) MOZ_OVERRIDE;
    virtual bool
    AnswerNPP_GetValue_NPPVpluginNativeAccessibleAtkPlugId(nsCString* aPlugId,
-                                                     NPError* aResult);
+                                                           NPError* aResult) MOZ_OVERRIDE;
    virtual bool
-    AnswerNPP_SetValue_NPNVprivateModeBool(const bool& value, NPError* result);
+    AnswerNPP_SetValue_NPNVprivateModeBool(const bool& value, NPError* result) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPP_HandleEvent(const NPRemoteEvent& event, int16_t* handled);
+    AnswerNPP_HandleEvent(const NPRemoteEvent& event, int16_t* handled) MOZ_OVERRIDE;
    virtual bool
-    AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event, Shmem& mem, int16_t* handled, Shmem* rtnmem);
+    AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event,
+                                Shmem& mem,
+                                int16_t* handled,
+                                Shmem* rtnmem) MOZ_OVERRIDE;
    virtual bool
-    AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event, const uint32_t& surface, int16_t* handled);
+    AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event,
+                                    const uint32_t& surface,
+                                    int16_t* handled) MOZ_OVERRIDE;

    // Async rendering
    virtual bool
    RecvAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
-                       const NPRemoteWindow& aWindow);
+                       const NPRemoteWindow& aWindow) MOZ_OVERRIDE;

    virtual void
    DoAsyncSetWindow(const gfxSurfaceType& aSurfaceType,
                     const NPRemoteWindow& aWindow,
                     bool aIsAsync);

-    virtual PPluginSurfaceChild* AllocPPluginSurfaceChild(const WindowsSharedMemoryHandle&,
-                                                          const gfxIntSize&, const bool&) {
+    virtual PPluginSurfaceChild*
+    AllocPPluginSurfaceChild(const WindowsSharedMemoryHandle&,
+                             const gfxIntSize&, const bool&) MOZ_OVERRIDE {
        return new PPluginSurfaceChild();
    }

-    virtual bool DeallocPPluginSurfaceChild(PPluginSurfaceChild* s) {
+    virtual bool DeallocPPluginSurfaceChild(PPluginSurfaceChild* s) MOZ_OVERRIDE {
        delete s;
        return true;
    }
@ -125,13 +131,13 @@ protected:
    RecvContentsScaleFactorChanged(const double& aContentsScaleFactor) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPP_Destroy(NPError* result);
+    AnswerNPP_Destroy(NPError* result) MOZ_OVERRIDE;

    virtual PPluginScriptableObjectChild*
-    AllocPPluginScriptableObjectChild();
+    AllocPPluginScriptableObjectChild() MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginScriptableObjectChild(PPluginScriptableObjectChild* aObject);
+    DeallocPPluginScriptableObjectChild(PPluginScriptableObjectChild* aObject) MOZ_OVERRIDE;

    virtual bool
    RecvPPluginScriptableObjectConstructor(PPluginScriptableObjectChild* aActor) MOZ_OVERRIDE;
@ -145,7 +151,7 @@ protected:
                             const nsCString& mimeType,
                             const bool& seekable,
                             NPError* rv,
-                             uint16_t *stype);
+                             uint16_t *stype) MOZ_OVERRIDE;

    virtual bool
    AnswerPBrowserStreamConstructor(
@ -158,36 +164,36 @@ protected:
            const nsCString& mimeType,
            const bool& seekable,
            NPError* rv,
-            uint16_t* stype);
-        
+            uint16_t* stype) MOZ_OVERRIDE;
+
    virtual bool
-    DeallocPBrowserStreamChild(PBrowserStreamChild* stream);
+    DeallocPBrowserStreamChild(PBrowserStreamChild* stream) MOZ_OVERRIDE;

    virtual PPluginStreamChild*
    AllocPPluginStreamChild(const nsCString& mimeType,
                            const nsCString& target,
-                            NPError* result);
+                            NPError* result) MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginStreamChild(PPluginStreamChild* stream);
+    DeallocPPluginStreamChild(PPluginStreamChild* stream) MOZ_OVERRIDE;

    virtual PStreamNotifyChild*
    AllocPStreamNotifyChild(const nsCString& url, const nsCString& target,
                            const bool& post, const nsCString& buffer,
                            const bool& file,
-                            NPError* result);
+                            NPError* result) MOZ_OVERRIDE;

    virtual bool
    DeallocPStreamNotifyChild(PStreamNotifyChild* notifyData) MOZ_OVERRIDE;

    virtual bool
-    AnswerSetPluginFocus();
+    AnswerSetPluginFocus() MOZ_OVERRIDE;

    virtual bool
-    AnswerUpdateWindow();
+    AnswerUpdateWindow() MOZ_OVERRIDE;

    virtual bool
-    RecvNPP_DidComposite();
+    RecvNPP_DidComposite() MOZ_OVERRIDE;

 #if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
    bool CreateWindow(const NPRemoteWindow& aWindow);
--- a/dom/plugins/ipc/PluginInstanceParent.h
+++ b/dom/plugins/ipc/PluginInstanceParent.h
@ -62,13 +62,13 @@ public:
    virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;

    virtual PPluginScriptableObjectParent*
-    AllocPPluginScriptableObjectParent();
+    AllocPPluginScriptableObjectParent() MOZ_OVERRIDE;

    virtual bool
    RecvPPluginScriptableObjectConstructor(PPluginScriptableObjectParent* aActor) MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginScriptableObjectParent(PPluginScriptableObjectParent* aObject);
+    DeallocPPluginScriptableObjectParent(PPluginScriptableObjectParent* aObject) MOZ_OVERRIDE;
    virtual PBrowserStreamParent*
    AllocPBrowserStreamParent(const nsCString& url,
                              const uint32_t& length,
@ -78,68 +78,68 @@ public:
                              const nsCString& mimeType,
                              const bool& seekable,
                              NPError* rv,
-                              uint16_t *stype);
+                              uint16_t *stype) MOZ_OVERRIDE;
    virtual bool
-    DeallocPBrowserStreamParent(PBrowserStreamParent* stream);
+    DeallocPBrowserStreamParent(PBrowserStreamParent* stream) MOZ_OVERRIDE;

    virtual PPluginStreamParent*
    AllocPPluginStreamParent(const nsCString& mimeType,
                             const nsCString& target,
-                             NPError* result);
+                             NPError* result) MOZ_OVERRIDE;
    virtual bool
-    DeallocPPluginStreamParent(PPluginStreamParent* stream);
+    DeallocPPluginStreamParent(PPluginStreamParent* stream) MOZ_OVERRIDE;

    virtual bool
    AnswerNPN_GetValue_NPNVnetscapeWindow(NativeWindowHandle* value,
-                                          NPError* result);
+                                          NPError* result) MOZ_OVERRIDE;
    virtual bool
    AnswerNPN_GetValue_NPNVWindowNPObject(
                                       PPluginScriptableObjectParent** value,
-                                       NPError* result);
+                                       NPError* result) MOZ_OVERRIDE;
    virtual bool
    AnswerNPN_GetValue_NPNVPluginElementNPObject(
                                       PPluginScriptableObjectParent** value,
-                                       NPError* result);
+                                       NPError* result) MOZ_OVERRIDE;
    virtual bool
-    AnswerNPN_GetValue_NPNVprivateModeBool(bool* value, NPError* result);
+    AnswerNPN_GetValue_NPNVprivateModeBool(bool* value, NPError* result) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPN_GetValue_DrawingModelSupport(const NPNVariable& model, bool* value);
+    AnswerNPN_GetValue_DrawingModelSupport(const NPNVariable& model, bool* value) MOZ_OVERRIDE;
  
    virtual bool
-    AnswerNPN_GetValue_NPNVdocumentOrigin(nsCString* value, NPError* result);
+    AnswerNPN_GetValue_NPNVdocumentOrigin(nsCString* value, NPError* result) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPN_SetValue_NPPVpluginWindow(const bool& windowed, NPError* result);
+    AnswerNPN_SetValue_NPPVpluginWindow(const bool& windowed, NPError* result) MOZ_OVERRIDE;
    virtual bool
    AnswerNPN_SetValue_NPPVpluginTransparent(const bool& transparent,
-                                             NPError* result);
+                                             NPError* result) MOZ_OVERRIDE;
    virtual bool
    AnswerNPN_SetValue_NPPVpluginUsesDOMForCursor(const bool& useDOMForCursor,
-                                                  NPError* result);
+                                                  NPError* result) MOZ_OVERRIDE;
    virtual bool
    AnswerNPN_SetValue_NPPVpluginDrawingModel(const int& drawingModel,
                                              OptionalShmem *remoteImageData,
                                              CrossProcessMutexHandle *mutex,
-                                              NPError* result);
+                                              NPError* result) MOZ_OVERRIDE;
    virtual bool
    AnswerNPN_SetValue_NPPVpluginEventModel(const int& eventModel,
-                                             NPError* result);
+                                             NPError* result) MOZ_OVERRIDE;

    virtual bool
    AnswerNPN_GetURL(const nsCString& url, const nsCString& target,
-                     NPError *result);
+                     NPError *result) MOZ_OVERRIDE;

    virtual bool
    AnswerNPN_PostURL(const nsCString& url, const nsCString& target,
                      const nsCString& buffer, const bool& file,
-                      NPError* result);
+                      NPError* result) MOZ_OVERRIDE;

    virtual PStreamNotifyParent*
    AllocPStreamNotifyParent(const nsCString& url, const nsCString& target,
                             const bool& post, const nsCString& buffer,
                             const bool& file,
-                             NPError* result);
+                             NPError* result) MOZ_OVERRIDE;

    virtual bool
    AnswerPStreamNotifyConstructor(PStreamNotifyParent* actor,
@ -150,30 +150,30 @@ public:
                                   NPError* result) MOZ_OVERRIDE;

    virtual bool
-    DeallocPStreamNotifyParent(PStreamNotifyParent* notifyData);
+    DeallocPStreamNotifyParent(PStreamNotifyParent* notifyData) MOZ_OVERRIDE;

    virtual bool
-    RecvNPN_InvalidateRect(const NPRect& rect);
+    RecvNPN_InvalidateRect(const NPRect& rect) MOZ_OVERRIDE;

    // Async rendering
    virtual bool
    RecvShow(const NPRect& updatedRect,
             const SurfaceDescriptor& newSurface,
-             SurfaceDescriptor* prevSurface);
+             SurfaceDescriptor* prevSurface) MOZ_OVERRIDE;

    virtual PPluginSurfaceParent*
    AllocPPluginSurfaceParent(const WindowsSharedMemoryHandle& handle,
                              const gfxIntSize& size,
-                              const bool& transparent);
+                              const bool& transparent) MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginSurfaceParent(PPluginSurfaceParent* s);
+    DeallocPPluginSurfaceParent(PPluginSurfaceParent* s) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPN_PushPopupsEnabledState(const bool& aState);
+    AnswerNPN_PushPopupsEnabledState(const bool& aState) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPN_PopPopupsEnabledState();
+    AnswerNPN_PopPopupsEnabledState() MOZ_OVERRIDE;

    virtual bool
    AnswerNPN_GetValueForURL(const NPNURLVariable& variable,
@ -210,15 +210,15 @@ public:
    AnswerNPN_InitAsyncSurface(const gfxIntSize& size,
                               const NPImageFormat& format,
                               NPRemoteAsyncSurface* surfData,
-                               bool* result);
+                               bool* result) MOZ_OVERRIDE;

    virtual bool
-    RecvRedrawPlugin();
+    RecvRedrawPlugin() MOZ_OVERRIDE;

    virtual bool
    RecvNegotiatedCarbon() MOZ_OVERRIDE;

-    virtual bool RecvReleaseDXGISharedSurface(const DXGISharedSurfaceHandle &aHandle);
+    virtual bool RecvReleaseDXGISharedSurface(const DXGISharedSurfaceHandle &aHandle) MOZ_OVERRIDE;

    NPError NPP_SetWindow(const NPWindow* aWindow);

@ -265,7 +265,7 @@ public:
    }

    virtual bool
-    AnswerPluginFocusChange(const bool& gotFocus);
+    AnswerPluginFocusChange(const bool& gotFocus) MOZ_OVERRIDE;

    nsresult AsyncSetWindow(NPWindow* window);
    nsresult GetImageContainer(mozilla::layers::ImageContainer** aContainer);
--- a/dom/plugins/ipc/PluginModuleChild.h
+++ b/dom/plugins/ipc/PluginModuleChild.h
@ -84,32 +84,32 @@ protected:
    virtual bool ShouldContinueFromReplyTimeout() MOZ_OVERRIDE;

    // Implement the PPluginModuleChild interface
-    virtual bool AnswerNP_GetEntryPoints(NPError* rv);
-    virtual bool AnswerNP_Initialize(const uint32_t& aFlags, NPError* rv);
+    virtual bool AnswerNP_GetEntryPoints(NPError* rv) MOZ_OVERRIDE;
+    virtual bool AnswerNP_Initialize(const uint32_t& aFlags, NPError* rv) MOZ_OVERRIDE;

    virtual PPluginIdentifierChild*
    AllocPPluginIdentifierChild(const nsCString& aString,
                                const int32_t& aInt,
-                                const bool& aTemporary);
+                                const bool& aTemporary) MOZ_OVERRIDE;

    virtual bool
    RecvPPluginIdentifierConstructor(PPluginIdentifierChild* actor,
                                     const nsCString& aString,
                                     const int32_t& aInt,
-                                     const bool& aTemporary);
+                                     const bool& aTemporary) MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginIdentifierChild(PPluginIdentifierChild* aActor);
+    DeallocPPluginIdentifierChild(PPluginIdentifierChild* aActor) MOZ_OVERRIDE;

    virtual PPluginInstanceChild*
    AllocPPluginInstanceChild(const nsCString& aMimeType,
                              const uint16_t& aMode,
                              const InfallibleTArray<nsCString>& aNames,
                              const InfallibleTArray<nsCString>& aValues,
-                              NPError* rv);
+                              NPError* rv) MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginInstanceChild(PPluginInstanceChild* aActor);
+    DeallocPPluginInstanceChild(PPluginInstanceChild* aActor) MOZ_OVERRIDE;

    virtual bool
    AnswerPPluginInstanceConstructor(PPluginInstanceChild* aActor,
@ -117,44 +117,44 @@ protected:
                                     const uint16_t& aMode,
                                     const InfallibleTArray<nsCString>& aNames,
                                     const InfallibleTArray<nsCString>& aValues,
-                                     NPError* rv);
+                                     NPError* rv) MOZ_OVERRIDE;
    virtual bool
-    AnswerNP_Shutdown(NPError *rv);
+    AnswerNP_Shutdown(NPError *rv) MOZ_OVERRIDE;

    virtual bool
    AnswerOptionalFunctionsSupported(bool *aURLRedirectNotify,
                                     bool *aClearSiteData,
-                                     bool *aGetSitesWithData);
+                                     bool *aGetSitesWithData) MOZ_OVERRIDE;

    virtual bool
    AnswerNPP_ClearSiteData(const nsCString& aSite,
                            const uint64_t& aFlags,
                            const uint64_t& aMaxAge,
-                            NPError* aResult);
+                            NPError* aResult) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPP_GetSitesWithData(InfallibleTArray<nsCString>* aResult);
+    AnswerNPP_GetSitesWithData(InfallibleTArray<nsCString>* aResult) MOZ_OVERRIDE;

    virtual bool
    RecvSetAudioSessionData(const nsID& aId,
                            const nsString& aDisplayName,
-                            const nsString& aIconPath);
+                            const nsString& aIconPath) MOZ_OVERRIDE;

    virtual bool
-    RecvSetParentHangTimeout(const uint32_t& aSeconds);
+    RecvSetParentHangTimeout(const uint32_t& aSeconds) MOZ_OVERRIDE;

    virtual PCrashReporterChild*
    AllocPCrashReporterChild(mozilla::dom::NativeThreadId* id,
-                             uint32_t* processType);
+                             uint32_t* processType) MOZ_OVERRIDE;
    virtual bool
-    DeallocPCrashReporterChild(PCrashReporterChild* actor);
+    DeallocPCrashReporterChild(PCrashReporterChild* actor) MOZ_OVERRIDE;
    virtual bool
    AnswerPCrashReporterConstructor(PCrashReporterChild* actor,
                                    mozilla::dom::NativeThreadId* id,
-                                    uint32_t* processType);
+                                    uint32_t* processType) MOZ_OVERRIDE;

    virtual void
-    ActorDestroy(ActorDestroyReason why);
+    ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;

    MOZ_NORETURN void QuickExit();

@ -162,7 +162,7 @@ protected:
    RecvProcessNativeEventsInInterruptCall() MOZ_OVERRIDE;

    virtual bool
-    AnswerGeckoGetProfile(nsCString* aProfile);
+    AnswerGeckoGetProfile(nsCString* aProfile) MOZ_OVERRIDE;

 public:
    PluginModuleChild();
--- a/dom/plugins/ipc/PluginModuleParent.h
+++ b/dom/plugins/ipc/PluginModuleParent.h
@ -70,20 +70,20 @@ protected:
    virtual PPluginIdentifierParent*
    AllocPPluginIdentifierParent(const nsCString& aString,
                                 const int32_t& aInt,
-                                 const bool& aTemporary);
+                                 const bool& aTemporary) MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginIdentifierParent(PPluginIdentifierParent* aActor);
+    DeallocPPluginIdentifierParent(PPluginIdentifierParent* aActor) MOZ_OVERRIDE;

    PPluginInstanceParent*
    AllocPPluginInstanceParent(const nsCString& aMimeType,
                               const uint16_t& aMode,
                               const InfallibleTArray<nsCString>& aNames,
                               const InfallibleTArray<nsCString>& aValues,
-                               NPError* rv);
+                               NPError* rv) MOZ_OVERRIDE;

    virtual bool
-    DeallocPPluginInstanceParent(PPluginInstanceParent* aActor);
+    DeallocPPluginInstanceParent(PPluginInstanceParent* aActor) MOZ_OVERRIDE;

 public:
    // aFilePath is UTF8, not native!
@ -141,20 +141,18 @@ protected:
        return MediateRace(parent, child);
    }

-    virtual bool RecvXXX_HACK_FIXME_cjones(Shmem& mem) { NS_RUNTIMEABORT("not reached"); return false; }
-
    virtual bool ShouldContinueFromReplyTimeout() MOZ_OVERRIDE;

    virtual bool
    RecvBackUpXResources(const FileDescriptor& aXSocketFd) MOZ_OVERRIDE;

    virtual bool
-    AnswerNPN_UserAgent(nsCString* userAgent);
+    AnswerNPN_UserAgent(nsCString* userAgent) MOZ_OVERRIDE;

    virtual bool
    AnswerNPN_GetValue_WithBoolReturn(const NPNVariable& aVariable,
                                      NPError* aError,
-                                      bool* aBoolVal);
+                                      bool* aBoolVal) MOZ_OVERRIDE;

    virtual bool AnswerProcessSomeEvents() MOZ_OVERRIDE;

--- a/dom/plugins/ipc/PluginScriptableObjectChild.h
+++ b/dom/plugins/ipc/PluginScriptableObjectChild.h
@ -54,57 +54,57 @@ public:


  virtual bool
-  AnswerInvalidate();
+  AnswerInvalidate() MOZ_OVERRIDE;

  virtual bool
  AnswerHasMethod(PPluginIdentifierChild* aId,
-                  bool* aHasMethod);
+                  bool* aHasMethod) MOZ_OVERRIDE;

  virtual bool
  AnswerInvoke(PPluginIdentifierChild* aId,
               const InfallibleTArray<Variant>& aArgs,
               Variant* aResult,
-               bool* aSuccess);
+               bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerInvokeDefault(const InfallibleTArray<Variant>& aArgs,
                      Variant* aResult,
-                      bool* aSuccess);
+                      bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerHasProperty(PPluginIdentifierChild* aId,
-                    bool* aHasProperty);
+                    bool* aHasProperty) MOZ_OVERRIDE;

  virtual bool
  AnswerGetChildProperty(PPluginIdentifierChild* aId,
                         bool* aHasProperty,
                         bool* aHasMethod,
                         Variant* aResult,
-                         bool* aSuccess);
+                         bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerSetProperty(PPluginIdentifierChild* aId,
                    const Variant& aValue,
-                    bool* aSuccess);
+                    bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerRemoveProperty(PPluginIdentifierChild* aId,
-                       bool* aSuccess);
+                       bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerEnumerate(InfallibleTArray<PPluginIdentifierChild*>* aProperties,
-                  bool* aSuccess);
+                  bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerConstruct(const InfallibleTArray<Variant>& aArgs,
                  Variant* aResult,
-                  bool* aSuccess);
+                  bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
-  RecvProtect();
+  RecvProtect() MOZ_OVERRIDE;

  virtual bool
-  RecvUnprotect();
+  RecvUnprotect() MOZ_OVERRIDE;

  NPObject*
  GetObject(bool aCanResurrect);
--- a/dom/plugins/ipc/PluginScriptableObjectParent.h
+++ b/dom/plugins/ipc/PluginScriptableObjectParent.h
@ -47,56 +47,56 @@ public:

  virtual bool
  AnswerHasMethod(PPluginIdentifierParent* aId,
-                  bool* aHasMethod);
+                  bool* aHasMethod) MOZ_OVERRIDE;

  virtual bool
  AnswerInvoke(PPluginIdentifierParent* aId,
               const InfallibleTArray<Variant>& aArgs,
               Variant* aResult,
-               bool* aSuccess);
+               bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerInvokeDefault(const InfallibleTArray<Variant>& aArgs,
                      Variant* aResult,
-                      bool* aSuccess);
+                      bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerHasProperty(PPluginIdentifierParent* aId,
-                    bool* aHasProperty);
+                    bool* aHasProperty) MOZ_OVERRIDE;

  virtual bool
  AnswerGetParentProperty(PPluginIdentifierParent* aId,
                          Variant* aResult,
-                          bool* aSuccess);
+                          bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerSetProperty(PPluginIdentifierParent* aId,
                    const Variant& aValue,
-                    bool* aSuccess);
+                    bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerRemoveProperty(PPluginIdentifierParent* aId,
-                       bool* aSuccess);
+                       bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerEnumerate(InfallibleTArray<PPluginIdentifierParent*>* aProperties,
-                  bool* aSuccess);
+                  bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerConstruct(const InfallibleTArray<Variant>& aArgs,
                  Variant* aResult,
-                  bool* aSuccess);
+                  bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
  AnswerNPN_Evaluate(const nsCString& aScript,
                     Variant* aResult,
-                     bool* aSuccess);
+                     bool* aSuccess) MOZ_OVERRIDE;

  virtual bool
-  RecvProtect();
+  RecvProtect() MOZ_OVERRIDE;

  virtual bool
-  RecvUnprotect();
+  RecvUnprotect() MOZ_OVERRIDE;

  static const NPClass*
  GetClass()
--- a/dom/plugins/ipc/PluginStreamChild.h
+++ b/dom/plugins/ipc/PluginStreamChild.h
@ -25,7 +25,7 @@ public:
  virtual bool IsBrowserStream() MOZ_OVERRIDE { return false; }

  virtual bool Answer__delete__(const NPReason& reason,
-                                const bool& artificial);
+                                const bool& artificial) MOZ_OVERRIDE;

  int32_t NPN_Write(int32_t length, void* buffer);
  void NPP_DestroyStream(NPError reason);
--- a/dom/plugins/ipc/PluginStreamParent.h
+++ b/dom/plugins/ipc/PluginStreamParent.h
@ -26,9 +26,9 @@ public:

  virtual bool IsBrowserStream() MOZ_OVERRIDE { return false; }

-  virtual bool AnswerNPN_Write(const Buffer& data, int32_t* written);
+  virtual bool AnswerNPN_Write(const Buffer& data, int32_t* written) MOZ_OVERRIDE;

-  virtual bool Answer__delete__(const NPError& reason, const bool& artificial);
+  virtual bool Answer__delete__(const NPError& reason, const bool& artificial) MOZ_OVERRIDE;

 private:
  void NPN_DestroyStream(NPReason reason);
--- a/dom/plugins/ipc/StreamNotifyChild.h
+++ b/dom/plugins/ipc/StreamNotifyChild.h
@ -37,7 +37,7 @@ public:
 private:
  virtual bool Recv__delete__(const NPReason& reason) MOZ_OVERRIDE;

-  bool RecvRedirectNotify(const nsCString& url, const int32_t& status);
+  bool RecvRedirectNotify(const nsCString& url, const int32_t& status) MOZ_OVERRIDE;

  /**
   * If a stream is created for this this URLNotify, we associate the objects
--- a/dom/plugins/ipc/StreamNotifyParent.h
+++ b/dom/plugins/ipc/StreamNotifyParent.h
@ -35,7 +35,7 @@ public:
  }

 private:
-  bool RecvRedirectNotifyResponse(const bool& allow);
+  bool RecvRedirectNotifyResponse(const bool& allow) MOZ_OVERRIDE;

  bool* mDestructionFlag;
 };
--- a/dom/smil/crashtests/690994-1.svg
+++ b/dom/smil/crashtests/690994-1.svg
@ -1,7 +1,10 @@
 <?xml version="1.0"?>
-<svg xmlns="http://www.w3.org/2000/svg" class="reftest-wait">
+<svg xmlns="http://www.w3.org/2000/svg" class="reftest-wait" onload="go()">
 <script>
 <![CDATA[
+function go() {
+  document.documentElement.setCurrentTime(100);
+}
 function boom()
 {
  document.documentElement.removeChild(document.getElementById("a"));
@ -9,6 +12,6 @@ function boom()
 }
 ]]>
 </script>
-<animate id="a" begin="a.end; -0.1s" end="a.begin+0.2s" onend="boom()"/>
-<animate id="a" begin="a.end; -0.1s" end="a.begin+0.2s"/>
+<animate id="a" begin="a.end; 99.9s" end="a.begin+0.2s" onend="boom()"/>
+<animate id="a" begin="a.end; 99.9s" end="a.begin+0.2s"/>
 </svg>
--- a/js/src/jit/IonCaches.cpp
+++ b/js/src/jit/IonCaches.cpp
@ -3528,6 +3528,60 @@ IsTypedArrayElementSetInlineable(JSObject *obj, const Value &idval, const Value
            !value.isString() && !value.isObject());
 }

+static void
+StoreDenseElement(MacroAssembler &masm, ConstantOrRegister value, Register elements,
+                  BaseIndex target)
+{
+    // If the ObjectElements::CONVERT_DOUBLE_ELEMENTS flag is set, int32 values
+    // have to be converted to double first. If the value is not int32, it can
+    // always be stored directly.
+
+    Address elementsFlags(elements, ObjectElements::offsetOfFlags());
+    if (value.constant()) {
+        Value v = value.value();
+        Label done;
+        if (v.isInt32()) {
+            Label dontConvert;
+            masm.branchTest32(Assembler::Zero, elementsFlags,
+                              Imm32(ObjectElements::CONVERT_DOUBLE_ELEMENTS),
+                              &dontConvert);
+            masm.storeValue(DoubleValue(v.toInt32()), target);
+            masm.jump(&done);
+            masm.bind(&dontConvert);
+        }
+        masm.storeValue(v, target);
+        masm.bind(&done);
+        return;
+    }
+
+    TypedOrValueRegister reg = value.reg();
+    if (reg.hasTyped() && reg.type() != MIRType_Int32) {
+        masm.storeTypedOrValue(reg, target);
+        return;
+    }
+
+    Label convert, storeValue, done;
+    masm.branchTest32(Assembler::NonZero, elementsFlags,
+                      Imm32(ObjectElements::CONVERT_DOUBLE_ELEMENTS),
+                      &convert);
+    masm.bind(&storeValue);
+    masm.storeTypedOrValue(reg, target);
+    masm.jump(&done);
+
+    masm.bind(&convert);
+    if (reg.hasValue()) {
+        masm.branchTestInt32(Assembler::NotEqual, reg.valueReg(), &storeValue);
+        masm.int32ValueToDouble(reg.valueReg(), ScratchFloatReg);
+        masm.storeDouble(ScratchFloatReg, target);
+    } else {
+        JS_ASSERT(reg.type() == MIRType_Int32);
+        masm.convertInt32ToDouble(reg.typedReg().gpr(), ScratchFloatReg);
+        masm.storeDouble(ScratchFloatReg, target);
+    }
+
+    masm.bind(&done);
+}
+
 static bool
 GenerateSetDenseElement(JSContext *cx, MacroAssembler &masm, IonCache::StubAttacher &attacher,
                        JSObject *obj, const Value &idval, bool guardHoles, Register object,
@ -3609,7 +3663,7 @@ GenerateSetDenseElement(JSContext *cx, MacroAssembler &masm, IonCache::StubAttac
            masm.branchTestMagic(Assembler::Equal, target, &failures);
        else
            masm.bind(&storeElement);
-        masm.storeConstantOrRegister(value, target);
+        StoreDenseElement(masm, value, elements, target);
    }
    attacher.jumpRejoin(masm);

--- a/layout/base/nsDisplayList.cpp
+++ b/layout/base/nsDisplayList.cpp
@ -4291,20 +4291,20 @@ static bool IsFrameVisible(nsIFrame* aFrame, const gfx3DMatrix& aMatrix)
 }

 const gfx3DMatrix&
-nsDisplayTransform::GetTransform(float aAppUnitsPerPixel)
+nsDisplayTransform::GetTransform()
 {
-  if (mTransform.IsIdentity() || mCachedAppUnitsPerPixel != aAppUnitsPerPixel) {
+  if (mTransform.IsIdentity()) {
+    float scale = mFrame->PresContext()->AppUnitsPerDevPixel();
    gfxPoint3D newOrigin =
-      gfxPoint3D(NSAppUnitsToFloatPixels(mToReferenceFrame.x, aAppUnitsPerPixel),
-                 NSAppUnitsToFloatPixels(mToReferenceFrame.y, aAppUnitsPerPixel),
+      gfxPoint3D(NSAppUnitsToFloatPixels(mToReferenceFrame.x, scale),
+                 NSAppUnitsToFloatPixels(mToReferenceFrame.y, scale),
                  0.0f);
    if (mTransformGetter) {
-      mTransform = mTransformGetter(mFrame, aAppUnitsPerPixel);
+      mTransform = mTransformGetter(mFrame, scale);
      mTransform = nsLayoutUtils::ChangeMatrixBasis(newOrigin, mTransform);
    } else {
      mTransform =
-        GetResultingTransformMatrix(mFrame, ToReferenceFrame(),
-                                    aAppUnitsPerPixel);
+        GetResultingTransformMatrix(mFrame, ToReferenceFrame(), scale);

      /**
       * Shift the coorindates to be relative to our reference frame instead of relative to this frame.
@ -4316,7 +4316,6 @@ nsDisplayTransform::GetTransform(float aAppUnitsPerPixel)
                         hasSVGTransforms ? newOrigin.y : NS_round(newOrigin.y), 
                         0);
      mTransform.Translate(rounded);
-      mCachedAppUnitsPerPixel = aAppUnitsPerPixel;
    }
  }
  return mTransform;
@ -4332,8 +4331,7 @@ already_AddRefed<Layer> nsDisplayTransform::BuildLayer(nsDisplayListBuilder *aBu
                                                       LayerManager *aManager,
                                                       const ContainerLayerParameters& aContainerParameters)
 {
-  const gfx3DMatrix& newTransformMatrix =
-    GetTransform(mFrame->PresContext()->AppUnitsPerDevPixel());
+  const gfx3DMatrix& newTransformMatrix = GetTransform();

  if (mFrame->StyleDisplay()->mBackfaceVisibility == NS_STYLE_BACKFACE_VISIBILITY_HIDDEN &&
      newTransformMatrix.IsBackfaceVisible()) {
@ -4377,8 +4375,7 @@ nsDisplayTransform::GetLayerState(nsDisplayListBuilder* aBuilder,
                                  const ContainerLayerParameters& aParameters) {
  // If the transform is 3d, or the layer takes part in preserve-3d sorting
  // then we *always* want this to be an active layer.
-  if (!GetTransform(mFrame->PresContext()->AppUnitsPerDevPixel()).Is2D() || 
-      mFrame->Preserves3D()) {
+  if (!GetTransform().Is2D() || mFrame->Preserves3D()) {
    return LAYER_ACTIVE_FORCE;
  }
  // Here we check if the *post-transform* bounds of this item are big enough
@ -4408,10 +4405,11 @@ bool nsDisplayTransform::ComputeVisibility(nsDisplayListBuilder *aBuilder,
   * think that it's painting in its original rectangular coordinate space.
   * If we can't untransform, take the entire overflow rect */
  nsRect untransformedVisibleRect;
+  // GetTransform always operates in dev pixels.
  float factor = mFrame->PresContext()->AppUnitsPerDevPixel();
  if (ShouldPrerenderTransformedContent(aBuilder, mFrame) ||
      !UntransformRectMatrix(mVisibleRect,
-                             GetTransform(factor),
+                             GetTransform(),
                             factor,
                             &untransformedVisibleRect))
  {
@ -4442,8 +4440,9 @@ void nsDisplayTransform::HitTest(nsDisplayListBuilder *aBuilder,
   * 3. Use it to transform the rect into the correct space.
   * 4. Pass that rect down through to the list's version of HitTest.
   */
+  // GetTransform always operates in dev pixels.
  float factor = mFrame->PresContext()->AppUnitsPerDevPixel();
-  gfx3DMatrix matrix = GetTransform(factor);
+  gfx3DMatrix matrix = GetTransform();

  if (!IsFrameVisible(mFrame, matrix)) {
    return;
@ -4501,8 +4500,9 @@ void nsDisplayTransform::HitTest(nsDisplayListBuilder *aBuilder,
 float
 nsDisplayTransform::GetHitDepthAtPoint(const nsPoint& aPoint)
 {
+  // GetTransform always operates in dev pixels.
  float factor = mFrame->PresContext()->AppUnitsPerDevPixel();
-  gfx3DMatrix matrix = GetTransform(factor);
+  gfx3DMatrix matrix = GetTransform();

  NS_ASSERTION(IsFrameVisible(mFrame, matrix), "We can't have hit a frame that isn't visible!");

@ -4524,9 +4524,10 @@ nsRect nsDisplayTransform::GetBounds(nsDisplayListBuilder *aBuilder, bool* aSnap
    mFrame->GetVisualOverflowRectRelativeToSelf() :
    mStoredList.GetBounds(aBuilder, aSnap);
  *aSnap = false;
+  // GetTransform always operates in dev pixels.
  float factor = mFrame->PresContext()->AppUnitsPerDevPixel();
  return nsLayoutUtils::MatrixTransformRect(untransformedBounds,
-                                            GetTransform(factor),
+                                            GetTransform(),
                                            factor);
 }

@ -4551,6 +4552,7 @@ nsRegion nsDisplayTransform::GetOpaqueRegion(nsDisplayListBuilder *aBuilder,
 {
  *aSnap = false;
  nsRect untransformedVisible;
+  // GetTransform always operates in dev pixels.
  float factor = mFrame->PresContext()->AppUnitsPerDevPixel();
  // If we're going to prerender all our content, pretend like we
  // don't have opqaue content so that everything under us is rendered
@ -4559,11 +4561,11 @@ nsRegion nsDisplayTransform::GetOpaqueRegion(nsDisplayListBuilder *aBuilder,
  // updated extremely cheaply, without invalidating any other
  // content.
  if (ShouldPrerenderTransformedContent(aBuilder, mFrame) ||
-      !UntransformRectMatrix(mVisibleRect, GetTransform(factor), factor, &untransformedVisible)) {
+      !UntransformRectMatrix(mVisibleRect, GetTransform(), factor, &untransformedVisible)) {
      return nsRegion();
  }

-  const gfx3DMatrix& matrix = GetTransform(factor);
+  const gfx3DMatrix& matrix = GetTransform();

  nsRegion result;
  gfxMatrix matrix2d;
@ -4583,11 +4585,12 @@ nsRegion nsDisplayTransform::GetOpaqueRegion(nsDisplayListBuilder *aBuilder,
 bool nsDisplayTransform::IsUniform(nsDisplayListBuilder *aBuilder, nscolor* aColor)
 {
  nsRect untransformedVisible;
+  // GetTransform always operates in dev pixels.
  float factor = mFrame->PresContext()->AppUnitsPerDevPixel();
-  if (!UntransformRectMatrix(mVisibleRect, GetTransform(factor), factor, &untransformedVisible)) {
+  if (!UntransformRectMatrix(mVisibleRect, GetTransform(), factor, &untransformedVisible)) {
    return false;
  }
-  const gfx3DMatrix& matrix = GetTransform(factor);
+  const gfx3DMatrix& matrix = GetTransform();

  gfxMatrix matrix2d;
  return matrix.Is2D(&matrix2d) &&
--- a/layout/base/nsDisplayList.h
+++ b/layout/base/nsDisplayList.h
@ -3068,7 +3068,7 @@ public:
    INDEX_MAX = UINT32_MAX >> nsDisplayItem::TYPE_BITS
  };

-  const gfx3DMatrix& GetTransform(float aAppUnitsPerPixel);
+  const gfx3DMatrix& GetTransform();

  float GetHitDepthAtPoint(const nsPoint& aPoint);

@ -3201,7 +3201,6 @@ private:
  nsDisplayWrapList mStoredList;
  gfx3DMatrix mTransform;
  ComputeTransformFunction mTransformGetter;
-  float mCachedAppUnitsPerPixel;
  uint32_t mIndex;
 };

--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@ -1814,7 +1814,7 @@ nsLayoutUtils::GetLayerTransformForFrame(nsIFrame* aFrame,
    new (&builder) nsDisplayTransform(&builder, aFrame, &list);

  *aTransform =
-    item->GetTransform(aFrame->PresContext()->AppUnitsPerDevPixel());
+    item->GetTransform();
  item->~nsDisplayTransform();

  return true;