prune down content_dll change to just the CONTENT_EXPORTS

content/browser/cancelable_request.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.
 
 // CancelableRequestProviders and Consumers work together to make requests that
 // execute on a background thread in the provider and return data to the
 // consumer. These class collaborate to keep a list of open requests and to
 // make sure that requests to not outlive either of the objects involved in the
 // transaction.
 //
@@ skipping 82 matching lines @@
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "build/build_config.h"
+#include "content/common/content_export.h"
 
 class CancelableRequestBase;
 class CancelableRequestConsumerBase;
 
 // CancelableRequestProvider --------------------------------------------------
 //
 // This class is threadsafe. Requests may be added or canceled from any thread,
 // but a task must only be canceled from the same thread it was initially run
 // on.
 //
 // It is intended that providers inherit from this class to provide the
 // necessary functionality.
 
-class CancelableRequestProvider {
+class CONTENT_EXPORT CancelableRequestProvider {
  public:
   // Identifies a specific request from this provider.
   typedef int Handle;
 
   CancelableRequestProvider();
   virtual ~CancelableRequestProvider();
 
   // Called by the enduser of the request to cancel it. This MUST be called on
   // the same thread that originally issued the request (which is also the same
   // thread that would have received the callback if it was not canceled).
@@ skipping 380 matching lines @@
 //
 // Callback parameters are passed by value. In some cases, the request will
 // want to return a large amount of data (for example, an image). One good
 // approach is to derive from the CancelableRequest and make the data object
 // (for example, a std::vector) owned by the CancelableRequest. The pointer
 // to this data would be passed for the callback parameter. Since the
 // CancelableRequest outlives the callback call, the data will be valid on the
 // other thread for the callback, but will still be destroyed properly.
 
 // Non-templatized base class that provides cancellation
-class CancelableRequestBase
+class CONTENT_EXPORT CancelableRequestBase
     : public base::RefCountedThreadSafe<CancelableRequestBase> {
  public:
   friend class CancelableRequestProvider;
 
   // Initializes most things to empty, Init() must be called to complete
   // initialization of the object. This will be done by the provider when
   // the request is dispatched.
   //
   // This must be called on the same thread the callback will be executed on,
   // it will save that thread for later.
@@ skipping 195 matching lines @@
   }
 
   // The value.
   Type value;
 
  protected:
   virtual ~CancelableRequest1() {}
 };
 
 #endif  // CONTENT_BROWSER_CANCELABLE_REQUEST_H_