--- 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
    *