chrome/browser/sync_file_system/syncable_file_system_util.h

   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_SYNCABLE_FILE_SYSTEM_UTIL_H_
   6 #define CHROME_BROWSER_SYNC_FILE_SYSTEM_SYNCABLE_FILE_SYSTEM_UTIL_H_
   7
   8 #include <string>
   9
  10 #include "base/callback_forward.h"
  11 #include "base/files/file_path.h"
  12 #include "webkit/browser/fileapi/file_system_url.h"
  13
  14 namespace fileapi {
  15 class FileSystemContext;
  16 class FileSystemURL;
  17 }
  18
  19 namespace tracked_objects {
  20 class Location;
  21 }
  22
  23 namespace sync_file_system {
  24
  25 // Registers a syncable filesystem.
  26 void RegisterSyncableFileSystem();
  27
  28 // Revokes the syncable filesystem.
  29 void RevokeSyncableFileSystem();
  30
  31 // Returns the root URI of the syncable filesystem for |origin|.
  32 GURL GetSyncableFileSystemRootURI(const GURL& origin);
  33
  34 // Creates a FileSystem URL for the |path| in a syncable filesystem for
  35 // |origin|.
  36 //
  37 // Example: Assume following arguments are given:
  38 //   origin: 'http://www.example.com/',
  39 //   path: '/foo/bar',
  40 // returns 'filesystem:http://www.example.com/external/syncfs/foo/bar'
  41 fileapi::FileSystemURL
  42 CreateSyncableFileSystemURL(const GURL& origin, const base::FilePath& path);
  43
  44 // Creates a special filesystem URL for synchronizing |syncable_url|.
  45 fileapi::FileSystemURL CreateSyncableFileSystemURLForSync(
  46     fileapi::FileSystemContext* file_system_context,
  47     const fileapi::FileSystemURL& syncable_url);
  48
  49 // Serializes a given FileSystemURL |url| and sets the serialized string to
  50 // |serialized_url|. If the URL does not represent a syncable filesystem,
  51 // |serialized_url| is not filled in, and returns false. Separators of the
  52 // path will be normalized depending on its platform.
  53 //
  54 // Example: Assume a following FileSystemURL object is given:
  55 //   origin() returns 'http://www.example.com/',
  56 //   type() returns the kFileSystemTypeSyncable,
  57 //   filesystem_id() returns 'syncfs',
  58 //   path() returns '/foo/bar',
  59 // this URL will be serialized to
  60 // (on Windows)
  61 //   'filesystem:http://www.example.com/external/syncfs/foo\\bar'
  62 // (on others)
  63 //   'filesystem:http://www.example.com/external/syncfs/foo/bar'
  64 bool SerializeSyncableFileSystemURL(
  65     const fileapi::FileSystemURL& url, std::string* serialized_url);
  66
  67 // Deserializes a serialized FileSystem URL string |serialized_url| and sets the
  68 // deserialized value to |url|. If the reconstructed object is invalid or does
  69 // not represent a syncable filesystem, returns false.
  70 //
  71 // NOTE: On any platform other than Windows, this function assumes that
  72 // |serialized_url| does not contain '\\'. If it contains '\\' on such
  73 // platforms, '\\' may be replaced with '/' (It would not be an expected
  74 // behavior).
  75 //
  76 // See the comment of SerializeSyncableFileSystemURL() for more details.
  77 bool DeserializeSyncableFileSystemURL(
  78     const std::string& serialized_url, fileapi::FileSystemURL* url);
  79
  80 // Enables or disables directory operations in Sync FileSystem API.
  81 // TODO(nhiroki): This method should be used only for testing and should go
  82 // away when we fully support directory operations. (http://crbug.com/161442)
  83 void SetEnableSyncFSDirectoryOperation(bool flag);
  84
  85 // Returns true if we allow directory operations in Sync FileSystem API.
  86 // It is disabled by default but can be overridden by a command-line switch
  87 // (--enable-syncfs-directory-operations) or by calling
  88 // SetEnableSyncFSDirectoryOperation().
  89 // TODO(nhiroki): This method should be used only for testing and should go
  90 // away when we fully support directory operations. (http://crbug.com/161442)
  91 bool IsSyncFSDirectoryOperationEnabled();
  92
  93 // Checks the same as above, but takes |origin| and sees if directory operation
  94 // is enabled specifically for this |origin|.
  95 bool IsSyncFSDirectoryOperationEnabled(const GURL& origin);
  96
  97 // Returns true if V2 is enabled.
  98 bool IsV2Enabled();
  99
 100 // Returns true if the given |origin| is supposed to run in V2 mode.
 101 bool IsV2EnabledForOrigin(const GURL& origin);
 102
 103 // Returns SyncFileSystem sub-directory path.
 104 base::FilePath GetSyncFileSystemDir(const base::FilePath& profile_base_dir);
 105
 106 // Enables directory operation for syncable filesystems temporarily for testing.
 107 class ScopedEnableSyncFSDirectoryOperation {
 108  public:
 109   ScopedEnableSyncFSDirectoryOperation();
 110   ~ScopedEnableSyncFSDirectoryOperation();
 111
 112  private:
 113   bool was_enabled_;
 114
 115   DISALLOW_COPY_AND_ASSIGN(ScopedEnableSyncFSDirectoryOperation);
 116 };
 117
 118 // Posts |callback| to the current thread.
 119 void RunSoon(const tracked_objects::Location& from_here,
 120              const base::Closure& callback);
 121
 122 }  // namespace sync_file_system
 123
 124 #endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_SYNCABLE_FILE_SYSTEM_UTIL_H_