Home | History | Annotate | Download | only in drive_backend_v1
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_V1_DRIVE_METADATA_STORE_H_
      6 #define CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_V1_DRIVE_METADATA_STORE_H_
      7 
      8 #include <map>
      9 #include <string>
     10 #include <utility>
     11 #include <vector>
     12 
     13 #include "base/callback_forward.h"
     14 #include "base/files/file_path.h"
     15 #include "base/logging.h"
     16 #include "base/memory/scoped_ptr.h"
     17 #include "base/memory/weak_ptr.h"
     18 #include "base/threading/non_thread_safe.h"
     19 #include "chrome/browser/sync_file_system/sync_callbacks.h"
     20 #include "chrome/browser/sync_file_system/sync_status_code.h"
     21 #include "webkit/browser/fileapi/file_system_url.h"
     22 
     23 namespace base {
     24 class ListValue;
     25 class SequencedTaskRunner;
     26 }
     27 
     28 namespace leveldb {
     29 class DB;
     30 class WriteBatch;
     31 }
     32 
     33 class GURL;
     34 
     35 namespace sync_file_system {
     36 
     37 class DriveMetadata;
     38 struct DBContents;
     39 struct FileMetadata;
     40 
     41 // This class holds a snapshot of the server side metadata.
     42 class DriveMetadataStore
     43     : public base::NonThreadSafe,
     44       public base::SupportsWeakPtr<DriveMetadataStore> {
     45  public:
     46   typedef std::map<GURL, std::string> ResourceIdByOrigin;
     47   typedef std::map<std::string, GURL> OriginByResourceId;
     48   typedef std::map<base::FilePath, DriveMetadata> PathToMetadata;
     49   typedef std::map<GURL, PathToMetadata> MetadataMap;
     50   typedef std::vector<std::pair<fileapi::FileSystemURL, DriveMetadata> >
     51       URLAndDriveMetadataList;
     52   typedef base::Callback<void(SyncStatusCode status, bool created)>
     53       InitializationCallback;
     54 
     55   static const base::FilePath::CharType kDatabaseName[];
     56 
     57   DriveMetadataStore(const base::FilePath& base_dir,
     58                      base::SequencedTaskRunner* file_task_runner);
     59   ~DriveMetadataStore();
     60 
     61   // Initializes the internal database and loads its content to memory.
     62   // This function works asynchronously.
     63   void Initialize(const InitializationCallback& callback);
     64 
     65   void SetLargestChangeStamp(int64 largest_changestamp,
     66                              const SyncStatusCallback& callback);
     67   int64 GetLargestChangeStamp() const;
     68 
     69   // Updates database entry. Invokes |callback|, upon completion.
     70   void UpdateEntry(const fileapi::FileSystemURL& url,
     71                    const DriveMetadata& metadata,
     72                    const SyncStatusCallback& callback);
     73 
     74   // Deletes database entry for |url|. Invokes |callback|, upon completion.
     75   void DeleteEntry(const fileapi::FileSystemURL& url,
     76                    const SyncStatusCallback& callback);
     77 
     78   // Lookups and reads the database entry for |url|.
     79   SyncStatusCode ReadEntry(const fileapi::FileSystemURL& url,
     80                            DriveMetadata* metadata) const;
     81 
     82   // Marks |origin| as incremental sync and associates it with the directory
     83   // identified by |resource_id|.
     84   // |origin| must not already be an incremental sync origin.
     85   void AddIncrementalSyncOrigin(const GURL& origin,
     86                                 const std::string& resource_id);
     87 
     88   // Returns true if |origin| is an incremental sync or disabled origin.
     89   bool IsKnownOrigin(const GURL& origin) const;
     90 
     91   // Returns true if |origin| is an incremental sync origin, i.e. the origin's
     92   // entire file list has been cached and is ready to apply changes
     93   // incrementally.
     94   bool IsIncrementalSyncOrigin(const GURL& origin) const;
     95 
     96   // Returns true if |origin| is a disabled origin.
     97   bool IsOriginDisabled(const GURL& origin) const;
     98 
     99   void EnableOrigin(const GURL& origin,
    100                     const SyncStatusCallback& callback);
    101 
    102   void DisableOrigin(const GURL& origin,
    103                      const SyncStatusCallback& callback);
    104 
    105   void RemoveOrigin(const GURL& origin,
    106                     const SyncStatusCallback& callback);
    107 
    108   // Sets the directory identified by |resource_id| as the sync data directory.
    109   // All data for the Sync FileSystem should be store into the directory.
    110   void SetSyncRootDirectory(const std::string& resource_id);
    111   void SetOriginRootDirectory(const GURL& origin,
    112                               const std::string& resource_id);
    113 
    114   // Returns a set of URLs for files in conflict.
    115   SyncStatusCode GetConflictURLs(
    116       fileapi::FileSystemURLSet* urls) const;
    117 
    118   // Returns a set of URLs and Resource IDs for files to be fetched.
    119   SyncStatusCode GetToBeFetchedFiles(URLAndDriveMetadataList* list) const;
    120 
    121   // Returns resource id for |origin|.
    122   // This may return an empty string if |origin| is not a incremental or
    123   // disabled origin.
    124   std::string GetResourceIdForOrigin(const GURL& origin) const;
    125 
    126   const std::string& sync_root_directory() const {
    127     DCHECK(CalledOnValidThread());
    128     return sync_root_directory_resource_id_;
    129   }
    130 
    131   const ResourceIdByOrigin& incremental_sync_origins() const {
    132     DCHECK(CalledOnValidThread());
    133     return incremental_sync_origins_;
    134   }
    135 
    136   const ResourceIdByOrigin& disabled_origins() const {
    137     DCHECK(CalledOnValidThread());
    138     return disabled_origins_;
    139   }
    140 
    141   // Returns all tracked origins. i.e. incremental_sync_origins_ and
    142   // disabled_origins_.
    143   void GetAllOrigins(std::vector<GURL>* origins);
    144 
    145   // Maps |resource_id| to corresponding |origin|.
    146   // Returns true if the directory indicated by |resource_id| is not an origin
    147   // root directory.
    148   bool GetOriginByOriginRootDirectoryId(const std::string& resource_id,
    149                                         GURL* origin);
    150 
    151   // Returns all file metadata for the given origin.
    152   scoped_ptr<base::ListValue> DumpFiles(const GURL& origin);
    153 
    154  private:
    155   friend class DriveMetadataStoreTest;
    156 
    157   void WriteToDB(scoped_ptr<leveldb::WriteBatch> batch,
    158                  const SyncStatusCallback& callback);
    159 
    160   void UpdateDBStatus(SyncStatusCode status);
    161   void UpdateDBStatusAndInvokeCallback(const SyncStatusCallback& callback,
    162                                        const leveldb::Status& status);
    163   void DidInitialize(const InitializationCallback& callback,
    164                      scoped_ptr<DBContents> contents);
    165 
    166   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
    167   base::FilePath base_dir_;
    168   scoped_ptr<leveldb::DB> db_;
    169   SyncStatusCode db_status_;
    170 
    171   int64 largest_changestamp_;
    172   MetadataMap metadata_map_;
    173 
    174   std::string sync_root_directory_resource_id_;
    175   ResourceIdByOrigin incremental_sync_origins_;
    176   ResourceIdByOrigin disabled_origins_;
    177 
    178   OriginByResourceId origin_by_resource_id_;
    179 
    180   DISALLOW_COPY_AND_ASSIGN(DriveMetadataStore);
    181 };
    182 
    183 }  // namespace sync_file_system
    184 
    185 #endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_DRIVE_BACKEND_V1_DRIVE_METADATA_STORE_H_
    186