Add more appcache_exports needed for test_shell_tests when we start linking appcache as a DLL.

R=michaeln@chromium.org
BUG=90442
TEST=

Review URL: http://codereview.chromium.org/8086017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@103562 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 56 insertions, 43 deletions

diff --git a/webkit/appcache/appcache.h b/webkit/appcache/appcache.h
index fb7a90e..2fbb9cd 100644
--- a/webkit/appcache/appcache.h
+++ b/webkit/appcache/appcache.h
@@ -27,12 +27,12 @@ class AppCacheService;
 // Set of cached resources for an application. A cache exists as long as a
 // host is associated with it, the cache is in an appcache group or the
 // cache is being created during an appcache upate.
-class AppCache : public base::RefCounted<AppCache> {
+class APPCACHE_EXPORT AppCache : public base::RefCounted<AppCache> {
  public:
   typedef std::map<GURL, AppCacheEntry> EntryMap;
   typedef std::set<AppCacheHost*> AppCacheHosts;
 
-  APPCACHE_EXPORT AppCache(AppCacheService *service, int64 cache_id);
+  AppCache(AppCacheService *service, int64 cache_id);
 
   int64 cache_id() const { return cache_id_; }
 
@@ -44,7 +44,7 @@ class AppCache : public base::RefCounted<AppCache> {
   AppCacheService* service() const { return service_; }
 
   // Adds a new entry. Entry must not already be in cache.
-  void APPCACHE_EXPORT AddEntry(const GURL& url, const AppCacheEntry& entry);
+  void AddEntry(const GURL& url, const AppCacheEntry& entry);
 
   // Adds a new entry or modifies an existing entry by merging the types
   // of the new entry with the existing entry. Returns true if a new entry
diff --git a/webkit/appcache/appcache_database.h b/webkit/appcache/appcache_database.h
index 7e2dc3f..c6a6c3f 100644
--- a/webkit/appcache/appcache_database.h
+++ b/webkit/appcache/appcache_database.h
@@ -26,9 +26,9 @@ class StatementID;
 
 namespace appcache {
 
-class AppCacheDatabase {
+class APPCACHE_EXPORT AppCacheDatabase {
  public:
-  struct GroupRecord {
+  struct APPCACHE_EXPORT GroupRecord {
     GroupRecord();
     ~GroupRecord();
 
@@ -39,7 +39,7 @@ class AppCacheDatabase {
     base::Time last_access_time;
   };
 
-  struct CacheRecord {
+  struct APPCACHE_EXPORT CacheRecord {
     CacheRecord()
         : cache_id(0), group_id(0), online_wildcard(false), cache_size(0) {}
 
@@ -60,7 +60,7 @@ class AppCacheDatabase {
     int64 response_size;
   };
 
-  struct FallbackNameSpaceRecord {
+  struct APPCACHE_EXPORT FallbackNameSpaceRecord {
     FallbackNameSpaceRecord();
     ~FallbackNameSpaceRecord();
 
@@ -180,7 +180,7 @@ class AppCacheDatabase {
       const sql::Statement& statement, OnlineWhiteListRecord* record);
 
   // Database creation
-  APPCACHE_EXPORT bool LazyOpen(bool create_if_needed);
+  bool LazyOpen(bool create_if_needed);
   bool EnsureDatabaseVersion();
   bool CreateSchema();
   bool UpgradeSchema();
diff --git a/webkit/appcache/appcache_disk_cache.h b/webkit/appcache/appcache_disk_cache.h
index c2dfe57..da39098 100644
--- a/webkit/appcache/appcache_disk_cache.h
+++ b/webkit/appcache/appcache_disk_cache.h
@@ -10,13 +10,15 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "net/disk_cache/disk_cache.h"
+#include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_response.h"
 
 namespace appcache {
 
 // An implementation of AppCacheDiskCacheInterface that
 // uses net::DiskCache as the backing store.
-class AppCacheDiskCache : public AppCacheDiskCacheInterface {
+class APPCACHE_EXPORT AppCacheDiskCache
+    : public AppCacheDiskCacheInterface {
  public:
   AppCacheDiskCache();
   virtual ~AppCacheDiskCache();
diff --git a/webkit/appcache/appcache_group.h b/webkit/appcache/appcache_group.h
index 3dd87bf..383ad54 100644
--- a/webkit/appcache/appcache_group.h
+++ b/webkit/appcache/appcache_group.h
@@ -14,8 +14,8 @@
 #include "base/observer_list.h"
 #include "base/task.h"
 #include "base/time.h"
-#include "webkit/appcache/appcache_export.h"
 #include "googleurl/src/gurl.h"
+#include "webkit/appcache/appcache_export.h"
 
 namespace appcache {
 
@@ -27,10 +27,10 @@ class HostObserver;
 
 // Collection of application caches identified by the same manifest URL.
 // A group exists as long as it is in use by a host or is being updated.
-class AppCacheGroup : public base::RefCounted<AppCacheGroup> {
+class APPCACHE_EXPORT AppCacheGroup : public base::RefCounted<AppCacheGroup> {
  public:
 
-  class UpdateObserver {
+  class APPCACHE_EXPORT UpdateObserver {
     public:
       // Called just after an appcache update has completed.
       virtual void OnUpdateComplete(AppCacheGroup* group) = 0;
@@ -43,9 +43,8 @@ class AppCacheGroup : public base::RefCounted<AppCacheGroup> {
     DOWNLOADING,
   };
 
-  APPCACHE_EXPORT AppCacheGroup(AppCacheService* service,
-                                const GURL& manifest_url,
-                                int64 group_id);
+  AppCacheGroup(AppCacheService* service, const GURL& manifest_url,
+                int64 group_id);
 
   // Adds/removes an update observer, the AppCacheGroup does not take
   // ownership of the observer.
@@ -64,7 +63,7 @@ class AppCacheGroup : public base::RefCounted<AppCacheGroup> {
 
   AppCache* newest_complete_cache() const { return newest_complete_cache_; }
 
-  APPCACHE_EXPORT void AddCache(AppCache* complete_cache);
+  void AddCache(AppCache* complete_cache);
   void RemoveCache(AppCache* cache);
   bool HasCache() const { return newest_complete_cache_ != NULL; }
 
diff --git a/webkit/appcache/appcache_host.h b/webkit/appcache/appcache_host.h
index b54524d..f04b4ef 100644
--- a/webkit/appcache/appcache_host.h
+++ b/webkit/appcache/appcache_host.h
@@ -12,6 +12,7 @@
 #include "googleurl/src/gurl.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_interfaces.h"
+#include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/appcache/appcache_storage.h"
 #include "webkit/glue/resource_type.h"
@@ -31,11 +32,11 @@ typedef Callback2<bool, void*>::Type StartUpdateCallback;
 typedef Callback2<bool, void*>::Type SwapCacheCallback;
 
 // Server-side representation of an application cache host.
-class AppCacheHost : public AppCacheStorage::Delegate,
-                     public AppCacheGroup::UpdateObserver {
+class APPCACHE_EXPORT AppCacheHost : public AppCacheStorage::Delegate,
+                                     public AppCacheGroup::UpdateObserver {
  public:
 
-  class Observer {
+  class APPCACHE_EXPORT Observer {
    public:
     // Called just after the cache selection algorithm completes.
     virtual void OnCacheSelectionComplete(AppCacheHost* host) = 0;
diff --git a/webkit/appcache/appcache_quota_client.h b/webkit/appcache/appcache_quota_client.h
index 44457793..7618f9b 100644
--- a/webkit/appcache/appcache_quota_client.h
+++ b/webkit/appcache/appcache_quota_client.h
@@ -13,6 +13,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/completion_callback.h"
+#include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_storage.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_task.h"
@@ -72,7 +73,7 @@ class AppCacheQuotaClient : public quota::QuotaClient {
   typedef std::deque<OriginsRequest> OriginsRequestQueue;
   typedef std::deque<DeleteRequest> DeleteRequestQueue;
 
-  explicit AppCacheQuotaClient(AppCacheService* service);
+  APPCACHE_EXPORT explicit AppCacheQuotaClient(AppCacheService* service);
 
   void DidDeleteAppCachesForOrigin(int rv);
   void GetOriginsHelper(quota::StorageType type,
@@ -84,8 +85,8 @@ class AppCacheQuotaClient : public quota::QuotaClient {
   const AppCacheStorage::UsageMap* GetUsageMap();
 
   // For use by appcache internals during initialization and shutdown.
-  void NotifyAppCacheReady();
-  void NotifyAppCacheDestroyed();
+  APPCACHE_EXPORT void NotifyAppCacheReady();
+  APPCACHE_EXPORT void NotifyAppCacheDestroyed();
 
   // Prior to appcache service being ready, we have to queue
   // up reqeusts and defer acting on them until we're ready.
diff --git a/webkit/appcache/appcache_request_handler.h b/webkit/appcache/appcache_request_handler.h
index c5abb5f..e2f5b94 100644
--- a/webkit/appcache/appcache_request_handler.h
+++ b/webkit/appcache/appcache_request_handler.h
@@ -5,8 +5,10 @@
 #ifndef WEBKIT_APPCACHE_APPCACHE_REQUEST_HANDLER_H_
 #define WEBKIT_APPCACHE_APPCACHE_REQUEST_HANDLER_H_
 
+#include "base/compiler_specific.h"
 #include "net/url_request/url_request.h"
 #include "webkit/appcache/appcache_entry.h"
+#include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_host.h"
 #include "webkit/glue/resource_type.h"
 
@@ -24,9 +26,10 @@ class AppCacheURLRequestJob;
 // given the opportunity to hijack the request along the way. Callers
 // should use AppCacheHost::CreateRequestHandler to manufacture instances
 // that can retrieve resources for a particular host.
-class AppCacheRequestHandler : public net::URLRequest::UserData,
-                               public AppCacheHost::Observer,
-                               public AppCacheStorage::Delegate  {
+class APPCACHE_EXPORT AppCacheRequestHandler
+    : NON_EXPORTED_BASE(public net::URLRequest::UserData),
+      public AppCacheHost::Observer,
+      public AppCacheStorage::Delegate  {
  public:
   virtual ~AppCacheRequestHandler();
 
diff --git a/webkit/appcache/appcache_response.h b/webkit/appcache/appcache_response.h
index 7f39c41..a31bb9c 100644
--- a/webkit/appcache/appcache_response.h
+++ b/webkit/appcache/appcache_response.h
@@ -26,7 +26,7 @@ static const int kUnkownResponseDataSize = -1;
 
 // Response info for a particular response id. Instances are tracked in
 // the working set.
-class AppCacheResponseInfo
+class APPCACHE_EXPORT AppCacheResponseInfo
     : public base::RefCounted<AppCacheResponseInfo> {
  public:
   // AppCacheResponseInfo takes ownership of the http_info.
@@ -54,7 +54,7 @@ class AppCacheResponseInfo
 
 // A refcounted wrapper for HttpResponseInfo so we can apply the
 // refcounting semantics used with IOBuffer with these structures too.
-struct HttpResponseInfoIOBuffer
+struct APPCACHE_EXPORT HttpResponseInfoIOBuffer
     : public base::RefCountedThreadSafe<HttpResponseInfoIOBuffer> {
   scoped_ptr<net::HttpResponseInfo> http_info;
   int response_data_size;
@@ -68,7 +68,7 @@ struct HttpResponseInfoIOBuffer
 };
 
 // Low level storage api used by the response reader and writer.
-class AppCacheDiskCacheInterface {
+class APPCACHE_EXPORT AppCacheDiskCacheInterface {
  public:
   class Entry {
    public:
@@ -94,7 +94,7 @@ class AppCacheDiskCacheInterface {
 };
 
 // Common base class for response reader and writer.
-class AppCacheResponseIO {
+class APPCACHE_EXPORT AppCacheResponseIO {
  public:
   virtual ~AppCacheResponseIO();
   int64 response_id() const { return response_id_; }
@@ -148,7 +148,7 @@ class AppCacheResponseIO {
 // and there is a read in progress, the implementation will return
 // immediately but will take care of any side effect of cancelling the
 // operation.  In other words, instances are safe to delete at will.
-class AppCacheResponseReader : public AppCacheResponseIO {
+class APPCACHE_EXPORT AppCacheResponseReader : public AppCacheResponseIO {
  public:
   virtual ~AppCacheResponseReader();
 
@@ -208,7 +208,7 @@ class AppCacheResponseReader : public AppCacheResponseIO {
 // and there is a write in progress, the implementation will return
 // immediately but will take care of any side effect of cancelling the
 // operation. In other words, instances are safe to delete at will.
-class AppCacheResponseWriter : public AppCacheResponseIO {
+class APPCACHE_EXPORT AppCacheResponseWriter : public AppCacheResponseIO {
  public:
   virtual ~AppCacheResponseWriter();
 
diff --git a/webkit/appcache/appcache_storage.h b/webkit/appcache/appcache_storage.h
index 562bb16..b9b3d40 100644
--- a/webkit/appcache/appcache_storage.h
+++ b/webkit/appcache/appcache_storage.h
@@ -14,6 +14,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/completion_callback.h"
+#include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_working_set.h"
 
 class GURL;
@@ -29,11 +30,11 @@ class AppCacheService;
 struct AppCacheInfoCollection;
 struct HttpResponseInfoIOBuffer;
 
-class AppCacheStorage {
+class APPCACHE_EXPORT AppCacheStorage {
  public:
   typedef std::map<GURL, int64> UsageMap;
 
-  class Delegate {
+  class APPCACHE_EXPORT Delegate {
    public:
     virtual ~Delegate() {}
 
diff --git a/webkit/appcache/appcache_update_job.h b/webkit/appcache/appcache_update_job.h
index 358ee3e..adbf22f 100644
--- a/webkit/appcache/appcache_update_job.h
+++ b/webkit/appcache/appcache_update_job.h
@@ -19,6 +19,7 @@
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "webkit/appcache/appcache.h"
+#include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_host.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/appcache/appcache_response.h"
@@ -29,8 +30,8 @@ namespace appcache {
 class HostNotifier;
 
 // Application cache Update algorithm and state.
-class AppCacheUpdateJob : public AppCacheStorage::Delegate,
-                          public AppCacheHost::Observer {
+class APPCACHE_EXPORT AppCacheUpdateJob : public AppCacheStorage::Delegate,
+                                          public AppCacheHost::Observer {
  public:
   AppCacheUpdateJob(AppCacheService* service, AppCacheGroup* group);
   virtual ~AppCacheUpdateJob();
diff --git a/webkit/appcache/appcache_url_request_job.h b/webkit/appcache/appcache_url_request_job.h
index e90f077..8144ebd 100644
--- a/webkit/appcache/appcache_url_request_job.h
+++ b/webkit/appcache/appcache_url_request_job.h
@@ -11,6 +11,7 @@
 #include "net/http/http_byte_range.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/appcache/appcache_entry.h"
+#include "webkit/appcache/appcache_export.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_storage.h"
 
@@ -18,8 +19,8 @@ namespace appcache {
 
 // A net::URLRequestJob derivative that knows how to return a response stored
 // in the appcache.
-class AppCacheURLRequestJob : public net::URLRequestJob,
-                              public AppCacheStorage::Delegate {
+class APPCACHE_EXPORT AppCacheURLRequestJob : public net::URLRequestJob,
+                                              public AppCacheStorage::Delegate {
  public:
   AppCacheURLRequestJob(net::URLRequest* request, AppCacheStorage* storage);
   virtual ~AppCacheURLRequestJob();
diff --git a/webkit/appcache/appcache_working_set.h b/webkit/appcache/appcache_working_set.h
index d7e4fc9..638b562 100644
--- a/webkit/appcache/appcache_working_set.h
+++ b/webkit/appcache/appcache_working_set.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -9,6 +9,7 @@
 
 #include "base/hash_tables.h"
 #include "googleurl/src/gurl.h"
+#include "webkit/appcache/appcache_export.h"
 
 namespace appcache {
 
@@ -18,7 +19,7 @@ class AppCacheResponseInfo;
 
 // Represents the working set of appcache object instances
 // currently in memory.
-class AppCacheWorkingSet {
+class APPCACHE_EXPORT AppCacheWorkingSet {
  public:
   typedef std::map<GURL, AppCacheGroup*> GroupMap;
 
diff --git a/webkit/appcache/manifest_parser.h b/webkit/appcache/manifest_parser.h
index 19d5cac..cd1d569 100644
--- a/webkit/appcache/manifest_parser.h
+++ b/webkit/appcache/manifest_parser.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 //
@@ -36,6 +36,7 @@
 #include <vector>
 
 #include "base/hash_tables.h"
+#include "webkit/appcache/appcache_export.h"
 
 class GURL;
 
@@ -43,7 +44,7 @@ namespace appcache {
 
 typedef std::pair<GURL, GURL> FallbackNamespace;
 
-struct Manifest {
+struct APPCACHE_EXPORT Manifest {
   Manifest();
   ~Manifest();
 
@@ -53,8 +54,10 @@ struct Manifest {
   bool online_whitelist_all;
 };
 
-bool ParseManifest(const GURL& manifest_url, const char* data, int length,
-                   Manifest& manifest);
+APPCACHE_EXPORT bool ParseManifest(const GURL& manifest_url,
+                                   const char* data,
+                                   int length,
+                                   Manifest& manifest);
 
 }  // namespace appcache