Move storage-related files from webkit/ to new top-level directory storage/

storage/browser/database/database_tracker.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_BROWSER_DATABASE_DATABASE_TRACKER_H_
 #define WEBKIT_BROWSER_DATABASE_DATABASE_TRACKER_H_
 
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
-#include "webkit/browser/webkit_storage_browser_export.h"
-#include "webkit/common/database/database_connections.h"
+#include "storage/common/storage_export.h"
+#include "storage/common/database/database_connections.h"
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace content {
 class DatabaseTracker_TestHelper_Test;
 class MockDatabaseTracker;
 }
 
 namespace sql {
 class Connection;
 class MetaTable;
 }
 
 namespace quota {
 class QuotaManagerProxy;
 class SpecialStoragePolicy;
 }
 
 namespace webkit_database {
 
-WEBKIT_STORAGE_BROWSER_EXPORT extern const base::FilePath::CharType
-    kDatabaseDirectoryName[];
-WEBKIT_STORAGE_BROWSER_EXPORT extern const base::FilePath::CharType
-    kTrackerDatabaseFileName[];
+STORAGE_EXPORT extern const base::FilePath::CharType kDatabaseDirectoryName[];
+STORAGE_EXPORT extern const base::FilePath::CharType kTrackerDatabaseFileName[];
 
 class DatabasesTable;
 
 // This class is used to store information about all databases in an origin.
-class WEBKIT_STORAGE_BROWSER_EXPORT OriginInfo {
+class STORAGE_EXPORT OriginInfo {
  public:
   OriginInfo();
   OriginInfo(const OriginInfo& origin_info);
   ~OriginInfo();
 
   const std::string& GetOriginIdentifier() const { return origin_identifier_; }
   int64 TotalSize() const { return total_size_; }
   void GetAllDatabaseNames(std::vector<base::string16>* databases) const;
   int64 GetDatabaseSize(const base::string16& database_name) const;
   base::string16 GetDatabaseDescription(
@@ skipping 13 matching lines @@
 // This class manages the main database and keeps track of open databases.
 //
 // The data in this class is not thread-safe, so all methods of this class
 // should be called on the same thread. The only exceptions are the ctor(),
 // the dtor() and the database_directory() and quota_manager_proxy() getters.
 //
 // Furthermore, some methods of this class have to read/write data from/to
 // the disk. Therefore, in a multi-threaded application, all methods of this
 // class should be called on the thread dedicated to file operations (file
 // thread in the browser process, for example), if such a thread exists.
-class WEBKIT_STORAGE_BROWSER_EXPORT DatabaseTracker
+class STORAGE_EXPORT DatabaseTracker
     : public base::RefCountedThreadSafe<DatabaseTracker> {
  public:
   class Observer {
    public:
     virtual void OnDatabaseSizeChanged(const std::string& origin_identifier,
                                        const base::string16& database_name,
                                        int64 database_size) = 0;
     virtual void OnDatabaseScheduledForDeletion(
         const std::string& origin_identifier,
         const base::string16& database_name) = 0;
@@ skipping 78 matching lines @@
 
   // Shutdown the database tracker, deleting database files if the tracker is
   // used for an incognito profile.
   void Shutdown();
   // Disables the exit-time deletion of session-only data.
   void SetForceKeepSessionState();
 
  private:
   friend class base::RefCountedThreadSafe<DatabaseTracker>;
   friend class content::DatabaseTracker_TestHelper_Test;
-  friend class content::MockDatabaseTracker; // for testing
+  friend class content::MockDatabaseTracker;  // for testing
 
   typedef std::map<std::string, std::set<base::string16> > DatabaseSet;
   typedef std::vector<std::pair<net::CompletionCallback, DatabaseSet> >
       PendingDeletionCallbacks;
   typedef std::map<base::string16, base::File*> FileHandlesMap;
   typedef std::map<std::string, base::string16> OriginDirectoriesMap;
 
   class CachedOriginInfo : public OriginInfo {
    public:
     CachedOriginInfo() : OriginInfo(std::string(), 0) {}
@@ skipping 37 matching lines @@
   bool UpgradeToCurrentVersion();
   void InsertOrUpdateDatabaseDetails(const std::string& origin_identifier,
                                      const base::string16& database_name,
                                      const base::string16& database_details,
                                      int64 estimated_size);
 
   void ClearAllCachedOriginInfo();
   CachedOriginInfo* MaybeGetCachedOriginInfo(
       const std::string& origin_identifier,
       bool create_if_needed);
-  CachedOriginInfo* GetCachedOriginInfo(
-      const std::string& origin_identifier) {
+  CachedOriginInfo* GetCachedOriginInfo(const std::string& origin_identifier) {
     return MaybeGetCachedOriginInfo(origin_identifier, true);
   }
 
   int64 GetDBFileSize(const std::string& origin_identifier,
                       const base::string16& database_name);
   int64 SeedOpenDatabaseInfo(const std::string& origin_identifier,
                              const base::string16& database_name,
                              const base::string16& description);
   int64 UpdateOpenDatabaseInfoAndNotify(const std::string& origin_identifier,
                                         const base::string16& database_name,
                                         const base::string16* opt_description);
   int64 UpdateOpenDatabaseSizeAndNotify(const std::string& origin_identifier,
                                         const base::string16& database_name) {
     return UpdateOpenDatabaseInfoAndNotify(
         origin_identifier, database_name, NULL);
   }
 
-
   void ScheduleDatabaseForDeletion(const std::string& origin_identifier,
                                    const base::string16& database_name);
   // Schedule a set of open databases for deletion. If non-null, callback is
   // invoked upon completion.
   void ScheduleDatabasesForDeletion(const DatabaseSet& databases,
                                     const net::CompletionCallback& callback);
 
   // Returns the directory where all DB files for the given origin are stored.
   base::string16 GetOriginDirectory(const std::string& origin_identifier);
 
@@ skipping 35 matching lines @@
   // this map to assign directory names that do not reveal this information.
   OriginDirectoriesMap incognito_origin_directories_;
   int incognito_origin_directories_generator_;
 
   FRIEND_TEST_ALL_PREFIXES(DatabaseTracker, TestHelper);
 };
 
 }  // namespace webkit_database
 
 #endif  // WEBKIT_BROWSER_DATABASE_DATABASE_TRACKER_H_