Add exports needed for glue to build as a component.

webkit/plugins/ppapi/callbacks.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WEBKIT_GLUE_PLUGINS_PEPPER_CALLBACKS_H_
 #define WEBKIT_GLUE_PLUGINS_PEPPER_CALLBACKS_H_
 
 #include <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/task.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_resource.h"
+#include "webkit/plugins/webkit_plugins_export.h"
 
 namespace webkit {
 namespace ppapi {
 
 class TrackedCallback;
 
 // Pepper callbacks have the following semantics (unless otherwise specified;
 // in particular, the below apply to all completion callbacks):
 //  - Callbacks are always run on the main thread.
 //  - Callbacks are always called from the main message loop. In particular,
@@ skipping 43 matching lines @@
 
   // Abort all callbacks (synchronously).
   void AbortAll();
 
   // Abort all callbacks associated to the given resource ID (which must be
   // valid, i.e., nonzero) by posting a task (or tasks).
   void PostAbortForResource(PP_Resource resource_id);
 
  private:
   friend class base::RefCountedThreadSafe<CallbackTracker>;
-  ~CallbackTracker();
+  WEBKIT_PLUGINS_EXPORT ~CallbackTracker();
 
   // |TrackedCallback| are expected to automatically add and
   // remove themselves from their provided |CallbackTracker|.
   friend class TrackedCallback;
   void Add(const scoped_refptr<TrackedCallback>& tracked_callback);
   void Remove(const scoped_refptr<TrackedCallback>& tracked_callback);
 
   // For each resource ID with a pending callback, store a set with its pending
   // callbacks. (Resource ID 0 is used for callbacks not associated to a valid
   // resource.) If a resource ID is re-used for another resource, there may be
@@ skipping 35 matching lines @@
 //    callback; see the comment for |MarkAsCompleted()| for a caveat.
 class TrackedCallback : public base::RefCountedThreadSafe<TrackedCallback> {
  public:
   // The constructor will add the new object to the tracker. The resource ID is
   // optional -- set it to 0 if no resource is associated to the callback.
   TrackedCallback(const scoped_refptr<CallbackTracker>& tracker,
                   PP_Resource resource_id);
 
   // These run the callback in an abortive manner, or post a task to do so (but
   // immediately marking the callback as to be aborted).
-  void Abort();
+  WEBKIT_PLUGINS_EXPORT void Abort();
   void PostAbort();
 
   // Returns the ID of the resource which "owns" the callback, or 0 if the
   // callback is not associated with any resource.
   PP_Resource resource_id() const { return resource_id_; }
 
   // Returns true if the callback was completed (possibly aborted).
   bool completed() const { return completed_; }
 
   // Returns true if the callback was or should be aborted; this will be the
@@ skipping 26 matching lines @@
   bool aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TrackedCallback);
 };
 
 // |TrackedCompletionCallback| represents a tracked Pepper completion callback.
 class TrackedCompletionCallback : public TrackedCallback {
  public:
   // Create a tracked completion callback and register it with the tracker. The
   // resource ID may be 0 if the callback is not associated to any resource.
-  TrackedCompletionCallback(const scoped_refptr<CallbackTracker>& tracker,
-                            PP_Resource resource_id,
-                            const PP_CompletionCallback& callback);
+  WEBKIT_PLUGINS_EXPORT TrackedCompletionCallback(
+      const scoped_refptr<CallbackTracker>& tracker,
+      PP_Resource resource_id,
+      const PP_CompletionCallback& callback);
 
   // Run the callback with the given result. If the callback had previously been
   // marked as to be aborted (by |PostAbort()|), |result| will be ignored and
   // the callback will be run with result |PP_ERROR_ABORTED|.
-  void Run(int32_t result);
+  WEBKIT_PLUGINS_EXPORT void Run(int32_t result);
 
  protected:
   // |TrackedCallback| method:
   virtual void AbortImpl();
 
  private:
   PP_CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TrackedCompletionCallback);
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_CALLBACKS_H_