Add exports needed for glue to build as a component.

webkit/glue/resource_loader_bridge.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.
 //
 // The intent of this file is to provide a type-neutral abstraction between
 // Chrome and WebKit for resource loading. This pure-virtual interface is
 // implemented by the embedder.
 //
 // One of these objects will be created by WebKit for each request. WebKit
 // will own the pointer to the bridge, and will delete it when the request is
@@ skipping 16 matching lines @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_port_pair.h"
 #include "net/url_request/url_request_status.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "webkit/glue/resource_type.h"
+#include "webkit/glue/webkit_glue_export.h"
 
 namespace net {
 class HttpResponseHeaders;
 }
 
 namespace webkit_glue {
 
 // Structure containing timing information for the request. It addresses
 // http://groups.google.com/group/http-archive-specification/web/har-1-1-spec
 // and http://dev.w3.org/2006/webapi/WebTiming/ needs.
 //
 // All the values for starts and ends are given in milliseconds and are
 // offsets with respect to the given base time.
 struct ResourceLoadTimingInfo {
-  ResourceLoadTimingInfo();
-  ~ResourceLoadTimingInfo();
+  WEBKIT_GLUE_EXPORT ResourceLoadTimingInfo();
+  WEBKIT_GLUE_EXPORT ~ResourceLoadTimingInfo();
 
   // All the values in this struct are given as offsets in milliseconds wrt
   // this base time.
   base::Time base_time;
 
   // The time that proxy processing started. For requests with no proxy phase,
   // this time is -1.
   int32 proxy_start;
 
   // The time that proxy processing ended. For reused sockets this time
@@ skipping 33 matching lines @@
 
   // The time at which receiving HTTP headers ended. For non-HTTP requests
   // this is 0.
   int32 receive_headers_end;
 };
 
 struct ResourceDevToolsInfo : base::RefCounted<ResourceDevToolsInfo> {
   typedef std::vector<std::pair<std::string, std::string> >
       HeadersVector;
 
-  ResourceDevToolsInfo();
-  ~ResourceDevToolsInfo();
+  WEBKIT_GLUE_EXPORT ResourceDevToolsInfo();
+  WEBKIT_GLUE_EXPORT ~ResourceDevToolsInfo();
 
   int32 http_status_code;
   std::string http_status_text;
   HeadersVector request_headers;
   HeadersVector response_headers;
   std::string request_headers_text;
   std::string response_headers_text;
 };
 
 struct ResourceResponseInfo {
-  ResourceResponseInfo();
-  ~ResourceResponseInfo();
+  WEBKIT_GLUE_EXPORT ResourceResponseInfo();
+  WEBKIT_GLUE_EXPORT ~ResourceResponseInfo();
 
   // The time at which the request was made that resulted in this response.
   // For cached responses, this time could be "far" in the past.
   base::Time request_time;
 
   // The time at which the response headers were received.  For cached
   // responses, this time could be "far" in the past.
   base::Time response_time;
 
   // The response headers or NULL if the URL type does not support headers.
@@ skipping 61 matching lines @@
   bool was_fetched_via_proxy;
 
   // Remote address of the socket which fetched this resource.
   net::HostPortPair socket_address;
 };
 
 class ResourceLoaderBridge {
  public:
   // Structure used when calling
   // WebKitPlatformSupportImpl::CreateResourceLoader().
-  struct RequestInfo {
+  struct WEBKIT_GLUE_EXPORT RequestInfo {
     RequestInfo();
     ~RequestInfo();
 
     // HTTP-style method name (e.g., "GET" or "POST").
     std::string method;
 
     // Absolute URL encoded in ASCII per the rules of RFC-2396.
     GURL url;
 
     // URL of the document in the top-level window, which may be checked by the
@@ skipping 112 matching lines @@
 
     // Called when the response is complete.  This method signals completion of
     // the resource load.ff
     virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                     const std::string& security_info,
                                     const base::Time& completion_time) = 0;
   };
 
   // use WebKitPlatformSupportImpl::CreateResourceLoader() for construction, but
   // anybody can delete at any time, INCLUDING during processing of callbacks.
-  virtual ~ResourceLoaderBridge();
+  WEBKIT_GLUE_EXPORT virtual ~ResourceLoaderBridge();
 
   // Call this method before calling Start() to append a chunk of binary data
   // to the request body.  May only be used with HTTP(S) POST requests.
   virtual void AppendDataToUpload(const char* data, int data_len) = 0;
 
   // Call this method before calling Start() to append the contents of a file
   // to the request body.  May only be used with HTTP(S) POST requests.
   void AppendFileToUpload(const FilePath& file_path) {
     AppendFileRangeToUpload(file_path, 0, kuint64max, base::Time());
   }
@@ skipping 40 matching lines @@
 
   // When loader is transferred from one page to another, the IPC routing id
   // can change (they are associated with pages).
   virtual void UpdateRoutingId(int new_routing_id) = 0;
 
  protected:
   // Construction must go through
   // WebKitPlatformSupportImpl::CreateResourceLoader()
   // For HTTP(S) POST requests, the AppendDataToUpload and AppendFileToUpload
   // methods may be called to construct the body of the request.
-  ResourceLoaderBridge();
+  WEBKIT_GLUE_EXPORT ResourceLoaderBridge();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ResourceLoaderBridge);
 };
 
 }  // namespace webkit_glue
 
 #endif  // WEBKIT_GLUE_RESOURCE_LOADER_BRIDGE_H_