Bug 1178513 - Export libxul symbols needed by ACL. r=mattwoodrow, a=fabrice
--- a/content/html/content/public/HTMLMediaElement.h
+++ b/content/html/content/public/HTMLMediaElement.h
@@ -215,17 +215,17 @@ public:
virtual void DownloadStalled() MOZ_FINAL MOZ_OVERRIDE;
// Called by the media decoder to indicate whether the media cache has
// suspended the channel.
virtual void NotifySuspendedByCache(bool aIsSuspended) MOZ_FINAL MOZ_OVERRIDE;
// Called by the media decoder and the video frame to get the
// ImageContainer containing the video data.
- virtual VideoFrameContainer* GetVideoFrameContainer() MOZ_FINAL MOZ_OVERRIDE;
+ B2G_ACL_EXPORT virtual VideoFrameContainer* GetVideoFrameContainer() MOZ_FINAL MOZ_OVERRIDE;
layers::ImageContainer* GetImageContainer();
// Dispatch events
using nsGenericHTMLElement::DispatchEvent;
virtual nsresult DispatchEvent(const nsAString& aName) MOZ_FINAL MOZ_OVERRIDE;
virtual nsresult DispatchAsyncEvent(const nsAString& aName) MOZ_FINAL MOZ_OVERRIDE;
// Dispatch events that were raised while in the bfcache
--- a/content/media/VideoFrameContainer.h
+++ b/content/media/VideoFrameContainer.h
@@ -29,45 +29,45 @@ class ImageContainer;
* to manage the "current video frame" state. This state includes timing data
* and an intrinsic size (see below).
* This has to be a thread-safe object since it's accessed by resource decoders
* and other off-main-thread components. So we can't put this state in the media
* element itself ... well, maybe we could, but it could be risky and/or
* confusing.
*/
class VideoFrameContainer {
- ~VideoFrameContainer();
+ B2G_ACL_EXPORT ~VideoFrameContainer();
public:
typedef layers::ImageContainer ImageContainer;
typedef layers::Image Image;
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoFrameContainer)
VideoFrameContainer(dom::HTMLMediaElement* aElement,
already_AddRefed<ImageContainer> aContainer);
// Call on any thread
- void SetCurrentFrame(const gfxIntSize& aIntrinsicSize, Image* aImage,
+ B2G_ACL_EXPORT void SetCurrentFrame(const gfxIntSize& aIntrinsicSize, Image* aImage,
TimeStamp aTargetTime);
void ClearCurrentFrame(bool aResetSize = false);
// Reset the VideoFrameContainer
void Reset();
// Time in seconds by which the last painted video frame was late by.
// E.g. if the last painted frame should have been painted at time t,
// but was actually painted at t+n, this returns n in seconds. Threadsafe.
double GetFrameDelay();
// Call on main thread
enum {
INVALIDATE_DEFAULT,
INVALIDATE_FORCE
};
void Invalidate() { InvalidateWithFlags(INVALIDATE_DEFAULT); }
- void InvalidateWithFlags(uint32_t aFlags);
- ImageContainer* GetImageContainer();
+ B2G_ACL_EXPORT void InvalidateWithFlags(uint32_t aFlags);
+ B2G_ACL_EXPORT ImageContainer* GetImageContainer();
void ForgetElement() { mElement = nullptr; }
protected:
// Non-addreffed pointer to the element. The element calls ForgetElement
// to clear this reference when the element is destroyed.
dom::HTMLMediaElement* mElement;
nsRefPtr<ImageContainer> mImageContainer;
--- a/gfx/layers/ImageContainer.h
+++ b/gfx/layers/ImageContainer.h
@@ -355,17 +355,17 @@ public:
/**
* Create an Image in one of the given formats.
* Picks the "best" format from the list and creates an Image of that
* format.
* Returns null if this backend does not support any of the formats.
* Can be called on any thread. This method takes mReentrantMonitor
* when accessing thread-shared state.
*/
- already_AddRefed<Image> CreateImage(ImageFormat aFormat);
+ B2G_ACL_EXPORT already_AddRefed<Image> CreateImage(ImageFormat aFormat);
/**
* Set an Image as the current image to display. The Image must have
* been created by this ImageContainer.
* Can be called on any thread. This method takes mReentrantMonitor
* when accessing thread-shared state.
* aImage can be null. While it's null, nothing will be painted.
*
@@ -590,17 +590,17 @@ public:
* This can be used to check if the container has RemoteData set.
*/
RemoteImageData *GetRemoteImageData() { return mRemoteData; }
private:
typedef mozilla::ReentrantMonitor ReentrantMonitor;
// Private destructor, to discourage deletion outside of Release():
- ~ImageContainer();
+ B2G_ACL_EXPORT ~ImageContainer();
void SetCurrentImageInternal(Image* aImage);
// This is called to ensure we have an active image, this may not be true
// when we're storing image information in a RemoteImageData structure.
// NOTE: If we have remote data mRemoteDataMutex should be locked when
// calling this function!
void EnsureActiveImage();
--- a/gfx/layers/client/TextureClient.h
+++ b/gfx/layers/client/TextureClient.h
@@ -427,17 +427,17 @@ public:
private:
/**
* Called once, just before the destructor.
*
* Here goes the shut-down code that uses virtual methods.
* Must only be called by Release().
*/
- void Finalize();
+ B2G_ACL_EXPORT void Finalize();
friend class AtomicRefCountedWithFinalize<TextureClient>;
protected:
/**
* An invalid TextureClient cannot provide access to its shared data
* anymore. This usually means it will soon be destroyed.
*/
--- a/ipc/chromium/src/base/message_loop.h
+++ b/ipc/chromium/src/base/message_loop.h
@@ -104,17 +104,17 @@ public:
// such tasks get deferred until the top-most MessageLoop::Run is executing.
//
// The MessageLoop takes ownership of the Task, and deletes it after it has
// been Run().
//
// NOTE: These methods may be called on any thread. The Task will be invoked
// on the thread that executes MessageLoop::Run().
- void PostTask(
+ B2G_ACL_EXPORT void PostTask(
const tracked_objects::Location& from_here, Task* task);
void PostDelayedTask(
const tracked_objects::Location& from_here, Task* task, int delay_ms);
void PostNonNestableTask(
const tracked_objects::Location& from_here, Task* task);
--- a/ipc/chromium/src/base/task.h
+++ b/ipc/chromium/src/base/task.h
@@ -13,17 +13,17 @@
// Task ------------------------------------------------------------------------
//
// A task is a generic runnable thingy, usually used for running code on a
// different thread or for scheduling future tasks off of the message loop.
class Task : public tracked_objects::Tracked {
public:
Task() {}
- virtual ~Task() {}
+ virtual B2G_ACL_EXPORT ~Task() {}
// Tasks are automatically deleted after Run is called.
virtual void Run() = 0;
};
class CancelableTask : public Task {
public:
// Not all tasks support cancellation.
--- a/ipc/chromium/src/base/tracked.h
+++ b/ipc/chromium/src/base/tracked.h
@@ -89,18 +89,18 @@ class Location {
//------------------------------------------------------------------------------
class Births;
class Tracked {
public:
- Tracked();
- virtual ~Tracked();
+ B2G_ACL_EXPORT Tracked();
+ B2G_ACL_EXPORT virtual ~Tracked();
// Used to record the FROM_HERE location of a caller.
void SetBirthPlace(const Location& from_here);
// When a task sits around a long time, such as in a timer, or object watcher,
// this method should be called when the task becomes active, and its
// significant lifetime begins (and its waiting to be woken up has passed).
void ResetBirthTime();
--- a/widget/gonk/nativewindow/GonkConsumerBaseKK.h
+++ b/widget/gonk/nativewindow/GonkConsumerBaseKK.h
@@ -64,17 +64,17 @@ public:
void abandon();
// set the name of the GonkConsumerBase that will be used to identify it in
// log messages.
void setName(const String8& name);
// getBufferQueue returns the GonkBufferQueue object to which this
// GonkConsumerBase is connected.
- sp<GonkBufferQueue> getBufferQueue() const;
+ B2G_ACL_EXPORT sp<GonkBufferQueue> getBufferQueue() const;
// dump writes the current state to a string. Child classes should add
// their state to the dump by overriding the dumpLocked method, which is
// called by these methods after locking the mutex.
void dump(String8& result) const;
void dump(String8& result, const char* prefix) const;
// setFrameAvailableListener sets the listener object that will be notified
--- a/widget/gonk/nativewindow/GonkNativeWindowKK.h
+++ b/widget/gonk/nativewindow/GonkNativeWindowKK.h
@@ -62,17 +62,17 @@ class GonkNativeWindow: public GonkConsu
enum { NO_BUFFER_AVAILABLE = GonkBufferQueue::NO_BUFFER_AVAILABLE };
// Create a new buffer item consumer. The consumerUsage parameter determines
// the consumer usage flags passed to the graphics allocator. The
// bufferCount parameter specifies how many buffers can be locked for user
// access at the same time.
// controlledByApp tells whether this consumer is controlled by the
// application.
- GonkNativeWindow(int bufferCount = GonkBufferQueue::MIN_UNDEQUEUED_BUFFERS);
+ B2G_ACL_EXPORT GonkNativeWindow(int bufferCount = GonkBufferQueue::MIN_UNDEQUEUED_BUFFERS);
GonkNativeWindow(const sp<GonkBufferQueue>& bq, uint32_t consumerUsage,
int bufferCount = GonkBufferQueue::MIN_UNDEQUEUED_BUFFERS,
bool controlledByApp = false);
virtual ~GonkNativeWindow();
// set the name of the GonkNativeWindow that will be used to identify it in
// log messages.
@@ -107,25 +107,25 @@ class GonkNativeWindow: public GonkConsu
status_t setDefaultBufferSize(uint32_t w, uint32_t h);
// setDefaultBufferFormat allows the BufferQueue to create
// GraphicBuffers of a defaultFormat if no format is specified
// in dequeueBuffer
status_t setDefaultBufferFormat(uint32_t defaultFormat);
// Get next frame from the queue, caller owns the returned buffer.
- mozilla::TemporaryRef<TextureClient> getCurrentBuffer();
+ B2G_ACL_EXPORT mozilla::TemporaryRef<TextureClient> getCurrentBuffer();
// Return the buffer to the queue and mark it as FREE. After that
// the buffer is useable again for the decoder.
void returnBuffer(TextureClient* client);
mozilla::TemporaryRef<TextureClient> getTextureClientFromBuffer(ANativeWindowBuffer* buffer);
- void setNewFrameCallback(GonkNativeWindowNewFrameCallback* callback);
+ B2G_ACL_EXPORT void setNewFrameCallback(GonkNativeWindowNewFrameCallback* callback);
static void RecycleCallback(TextureClient* client, void* closure);
protected:
virtual void onFrameAvailable();
private:
GonkNativeWindowNewFrameCallback* mNewFrameCallback;
--- a/xpcom/base/nscore.h
+++ b/xpcom/base/nscore.h
@@ -130,16 +130,22 @@
#define NS_CALLBACK_(_type, _name) _type (* _name)
#define NS_STDCALL
#define NS_FROZENCALL
#define NS_EXPORT_STATIC_MEMBER_(type) NS_EXTERNAL_VIS_(type)
#define NS_IMPORT_STATIC_MEMBER_(type) NS_EXTERNAL_VIS_(type)
#endif
+#ifdef MOZ_WIDGET_GONK
+#define B2G_ACL_EXPORT NS_EXPORT
+#else
+#define B2G_ACL_EXPORT
+#endif
+
/**
* Macro for creating typedefs for pointer-to-member types which are
* declared with stdcall. It is important to use this for any type which is
* declared as stdcall (i.e. NS_IMETHOD). For example, instead of writing:
*
* typedef nsresult (nsIFoo::*someType)(nsISupports* arg);
*
* you should write:
--- a/xpcom/ds/TimeStamp.h
+++ b/xpcom/ds/TimeStamp.h
@@ -267,17 +267,17 @@ public:
* Now() is trying to ensure the best possible precision on each platform,
* at least one millisecond.
*
* NowLoRes() has been introduced to workaround performance problems of
* QueryPerformanceCounter on the Windows platform. NowLoRes() is giving
* lower precision, usually 15.6 ms, but with very good performance benefit.
* Use it for measurements of longer times, like >200ms timeouts.
*/
- static TimeStamp Now() { return Now(true); }
+ B2G_ACL_EXPORT static TimeStamp Now() { return Now(true); }
static TimeStamp NowLoRes() { return Now(false); }
/**
* Return a timestamp representing the time when the current process was
* created which will be comparable with other timestamps taken with this
* class. If the actual process creation time is detected to be inconsistent
* the @a aIsInconsistent parameter will be set to true, the returned
* timestamp however will still be valid though inaccurate.
@@ -388,17 +388,17 @@ public:
static void Shutdown();
private:
friend struct IPC::ParamTraits<mozilla::TimeStamp>;
friend void StartupTimelineRecordExternal(int, uint64_t);
MOZ_IMPLICIT TimeStamp(TimeStampValue aValue) : mValue(aValue) {}
- static TimeStamp Now(bool aHighResolution);
+ B2G_ACL_EXPORT static TimeStamp Now(bool aHighResolution);
/**
* Computes the uptime of the current process in microseconds. The result
* is platform-dependent and needs to be checked against existing timestamps
* for consistency.
*
* @returns The number of microseconds since the calling process was started
* or 0 if an error was encountered while computing the uptime
--- a/xpcom/string/nsReadableUtils.h
+++ b/xpcom/string/nsReadableUtils.h
@@ -108,17 +108,17 @@ char* ToNewCString(const nsACString& aSo
* The new buffer is zero-terminated, but that may not help you if |aSource|
* contains embedded nulls.
*
* @param aSource a UTF-16 string (made of char16_t's)
* @param aUTF8Count the number of 8-bit units that was returned
* @return a new |char| buffer you must free with |nsMemory::Free|.
*/
-char* ToNewUTF8String(const nsAString& aSource, uint32_t* aUTF8Count = nullptr);
+B2G_ACL_EXPORT char* ToNewUTF8String(const nsAString& aSource, uint32_t* aUTF8Count = nullptr);
/**
* Returns a new |char16_t| buffer containing a zero-terminated copy of
* |aSource|.
*
* Allocates and returns a new |char16_t| buffer which you must free with
* |nsMemory::Free|.
--- a/xpcom/string/nsTSubstring.h
+++ b/xpcom/string/nsTSubstring.h
@@ -306,23 +306,23 @@ public:
}
#endif
/**
* An efficient comparison with ASCII that can be used even
* for wide strings. Call this version when you know the
* length of 'data'.
*/
- bool NS_FASTCALL EqualsASCII(const char* aData, size_type aLen) const;
+ bool NS_FASTCALL B2G_ACL_EXPORT EqualsASCII(const char* aData, size_type aLen) const;
/**
* An efficient comparison with ASCII that can be used even
* for wide strings. Call this version when 'data' is
* null-terminated.
*/
- bool NS_FASTCALL EqualsASCII(const char* aData) const;
+ bool NS_FASTCALL B2G_ACL_EXPORT EqualsASCII(const char* aData) const;
// EqualsLiteral must ONLY be applied to an actual literal string, or
// a char array *constant* declared without an explicit size.
// Do not attempt to use it with a regular char* pointer, or with a
// non-constant char array variable. Use EqualsASCII for them.
// The template trick to acquire the array length at compile time without
// using a macro is due to Corey Kosak, with much thanks.
template<int N>
@@ -905,17 +905,17 @@ protected:
{
}
/**
* this function releases mData and does not change the value of
* any of its member variables. in other words, this function acts
* like a destructor.
*/
- void NS_FASTCALL Finalize();
+ void NS_FASTCALL B2G_ACL_EXPORT Finalize();
/**
* this function prepares mData to be mutated.
*
* @param aCapacity specifies the required capacity of mData
* @param aOldData returns null or the old value of mData
* @param aOldFlags returns 0 or the old value of mFlags
*