webkit: Merge 'database' and 'quota' to 'webkit_storage'

webkit/quota/quota_manager.h

 // Copyright (c) 2012 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_QUOTA_QUOTA_MANAGER_H_
 #define WEBKIT_QUOTA_QUOTA_MANAGER_H_
 
 #include <deque>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_database.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/special_storage_policy.h"
+#include "webkit/storage/webkit_storage_export.h"
 
 class FilePath;
 
 namespace base {
 class SequencedTaskRunner;
 class SingleThreadTaskRunner;
 }
 
 namespace quota_internals {
 class QuotaInternalsProxy;
@@ skipping 10 matching lines @@
 struct QuotaManagerDeleter;
 
 struct QuotaAndUsage {
   int64 usage;
   int64 unlimited_usage;
   int64 quota;
   int64 available_disk_space;
 };
 
 // An interface called by QuotaTemporaryStorageEvictor.
-class QuotaEvictionHandler {
+class WEBKIT_STORAGE_EXPORT QuotaEvictionHandler {
  public:
   typedef base::Callback<void(const GURL&)> GetLRUOriginCallback;
   typedef StatusCallback EvictOriginDataCallback;
   typedef base::Callback<void(QuotaStatusCode,
                               const QuotaAndUsage& quota_and_usage)>
       GetUsageAndQuotaForEvictionCallback;
 
   // Returns the least recently used origin.  It might return empty
   // GURL when there are no evictable origins.
   virtual void GetLRUOrigin(
@@ skipping 18 matching lines @@
         type(type),
         usage(usage) {}
   std::string host;
   StorageType type;
   int64 usage;
 };
 
 // The quota manager class.  This class is instantiated per profile and
 // held by the profile.  With the exception of the constructor and the
 // proxy() method, all methods should only be called on the IO thread.
-class QuotaManager : public QuotaTaskObserver,
-                     public QuotaEvictionHandler,
-                     public base::RefCountedThreadSafe<
-                         QuotaManager, QuotaManagerDeleter> {
+class WEBKIT_STORAGE_EXPORT QuotaManager
+    : public QuotaTaskObserver,
+      public QuotaEvictionHandler,
+      public base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter> {
  public:
   typedef base::Callback<void(QuotaStatusCode,
                               int64 /* usage */,
                               int64 /* quota */)>
       GetUsageAndQuotaCallback;
   static const int64 kNoLimit;
 
   QuotaManager(bool is_incognito,
                const FilePath& profile_path,
                base::SingleThreadTaskRunner* io_thread,
@@ skipping 98 matching lines @@
   // This is kept non-const so that test code can change the value.
   // TODO(kinuko): Make this a real const value and add a proper way to set
   // the quota for syncable storage. (http://crbug.com/155488)
   static int64 kSyncableStorageDefaultHostQuota;
 
  protected:
   virtual ~QuotaManager();
 
  private:
   friend class base::DeleteHelper<QuotaManager>;
+  friend class base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter>;
   friend class MockQuotaManager;
   friend class MockStorageClient;
   friend class quota_internals::QuotaInternalsProxy;
   friend class QuotaManagerProxy;
   friend class QuotaManagerTest;
   friend class QuotaTemporaryStorageEvictor;
   friend struct QuotaManagerDeleter;
 
   class GetUsageInfoTask;
   class UsageAndQuotaDispatcherTask;
@@ skipping 183 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(QuotaManager);
 };
 
 struct QuotaManagerDeleter {
   static void Destruct(const QuotaManager* manager) {
     manager->DeleteOnCorrectThread();
   }
 };
 
 // The proxy may be called and finally released on any thread.
-class QuotaManagerProxy
+class WEBKIT_STORAGE_EXPORT QuotaManagerProxy
     : public base::RefCountedThreadSafe<QuotaManagerProxy> {
  public:
   virtual void RegisterClient(QuotaClient* client);
   virtual void NotifyStorageAccessed(QuotaClient::ID client_id,
                                      const GURL& origin,
                                      StorageType type);
   virtual void NotifyStorageModified(QuotaClient::ID client_id,
                                      const GURL& origin,
                                      StorageType type,
                                      int64 delta);
@@ skipping 14 matching lines @@
 
   QuotaManager* manager_;  // only accessed on the io thread
   scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerProxy);
 };
 
 }  // namespace quota
 
 #endif  // WEBKIT_QUOTA_QUOTA_MANAGER_H_