chrome/browser/sync_file_system/local/sync_file_system_backend.cc

   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 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
   6
   7 #include "base/logging.h"
   8 #include "chrome/browser/chrome_notification_types.h"
   9 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
  10 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
  11 #include "chrome/browser/sync_file_system/local/syncable_file_system_operation.h"
  12 #include "chrome/browser/sync_file_system/sync_file_system_service.h"
  13 #include "chrome/browser/sync_file_system/sync_file_system_service_factory.h"
  14 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #include "content/public/browser/notification_service.h"
  17 #include "webkit/browser/blob/file_stream_reader.h"
  18 #include "webkit/browser/fileapi/file_stream_writer.h"
  19 #include "webkit/browser/fileapi/file_system_context.h"
  20 #include "webkit/browser/fileapi/file_system_operation.h"
  21 #include "webkit/common/fileapi/file_system_util.h"
  22
  23 using content::BrowserThread;
  24
  25 namespace sync_file_system {
  26
  27 namespace {
  28
  29 bool CalledOnUIThread() {
  30   // Ensure that these methods are called on the UI thread, except for unittests
  31   // where a UI thread might not have been created.
  32   return BrowserThread::CurrentlyOn(BrowserThread::UI) ||
  33          !BrowserThread::IsMessageLoopValid(BrowserThread::UI);
  34 }
  35
  36 }  // namespace
  37
  38 SyncFileSystemBackend::ProfileHolder::ProfileHolder(Profile* profile)
  39     : profile_(profile) {
  40   DCHECK(CalledOnUIThread());
  41   registrar_.Add(this,
  42                  chrome::NOTIFICATION_PROFILE_DESTROYED,
  43                  content::Source<Profile>(profile_));
  44 }
  45
  46 void SyncFileSystemBackend::ProfileHolder::Observe(
  47     int type,
  48     const content::NotificationSource& source,
  49     const content::NotificationDetails& details) {
  50   DCHECK(CalledOnUIThread());
  51   DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
  52   DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
  53   profile_ = NULL;
  54   registrar_.RemoveAll();
  55 }
  56
  57 Profile* SyncFileSystemBackend::ProfileHolder::GetProfile() {
  58   DCHECK(CalledOnUIThread());
  59   return profile_;
  60 }
  61
  62 SyncFileSystemBackend::SyncFileSystemBackend(Profile* profile)
  63     : context_(NULL),
  64       skip_initialize_syncfs_service_for_testing_(false) {
  65   DCHECK(CalledOnUIThread());
  66   if (profile)
  67     profile_holder_.reset(new ProfileHolder(profile));
  68
  69   // Register the service name here to enable to crack an URL on SyncFileSystem
  70   // even if SyncFileSystemService has not started yet.
  71   RegisterSyncableFileSystem();
  72 }
  73
  74 SyncFileSystemBackend::~SyncFileSystemBackend() {
  75   if (change_tracker_) {
  76     GetDelegate()->file_task_runner()->DeleteSoon(
  77         FROM_HERE, change_tracker_.release());
  78   }
  79
  80   if (profile_holder_ && !CalledOnUIThread()) {
  81     BrowserThread::DeleteSoon(
  82         BrowserThread::UI, FROM_HERE, profile_holder_.release());
  83   }
  84 }
  85
  86 // static
  87 SyncFileSystemBackend* SyncFileSystemBackend::CreateForTesting() {
  88   DCHECK(CalledOnUIThread());
  89   SyncFileSystemBackend* backend = new SyncFileSystemBackend(NULL);
  90   backend->skip_initialize_syncfs_service_for_testing_ = true;
  91   return backend;
  92 }
  93
  94 bool SyncFileSystemBackend::CanHandleType(
  95     fileapi::FileSystemType type) const {
  96   return type == fileapi::kFileSystemTypeSyncable ||
  97          type == fileapi::kFileSystemTypeSyncableForInternalSync;
  98 }
  99
 100 void SyncFileSystemBackend::Initialize(fileapi::FileSystemContext* context) {
 101   DCHECK(context);
 102   DCHECK(!context_);
 103   context_ = context;
 104
 105   fileapi::SandboxFileSystemBackendDelegate* delegate = GetDelegate();
 106   delegate->RegisterQuotaUpdateObserver(fileapi::kFileSystemTypeSyncable);
 107   delegate->RegisterQuotaUpdateObserver(
 108       fileapi::kFileSystemTypeSyncableForInternalSync);
 109 }
 110
 111 void SyncFileSystemBackend::OpenFileSystem(
 112     const GURL& origin_url,
 113     fileapi::FileSystemType type,
 114     fileapi::OpenFileSystemMode mode,
 115     const OpenFileSystemCallback& callback) {
 116   DCHECK(CanHandleType(type));
 117
 118   if (skip_initialize_syncfs_service_for_testing_) {
 119     GetDelegate()->OpenFileSystem(origin_url, type, mode, callback,
 120                                   GetSyncableFileSystemRootURI(origin_url));
 121     return;
 122   }
 123
 124   // It is safe to pass Unretained(this) since |context_| owns it.
 125   SyncStatusCallback initialize_callback =
 126       base::Bind(&SyncFileSystemBackend::DidInitializeSyncFileSystemService,
 127                  base::Unretained(this), make_scoped_refptr(context_),
 128                  origin_url, type, mode, callback);
 129   InitializeSyncFileSystemService(origin_url, initialize_callback);
 130 }
 131
 132 fileapi::AsyncFileUtil* SyncFileSystemBackend::GetAsyncFileUtil(
 133     fileapi::FileSystemType type) {
 134   return GetDelegate()->file_util();
 135 }
 136
 137 fileapi::CopyOrMoveFileValidatorFactory*
 138 SyncFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
 139     fileapi::FileSystemType type,
 140     base::PlatformFileError* error_code) {
 141   DCHECK(error_code);
 142   *error_code = base::PLATFORM_FILE_OK;
 143   return NULL;
 144 }
 145
 146 fileapi::FileSystemOperation*
 147 SyncFileSystemBackend::CreateFileSystemOperation(
 148     const fileapi::FileSystemURL& url,
 149     fileapi::FileSystemContext* context,
 150     base::PlatformFileError* error_code) const {
 151   DCHECK(CanHandleType(url.type()));
 152   DCHECK(context);
 153   DCHECK(error_code);
 154
 155   scoped_ptr<fileapi::FileSystemOperationContext> operation_context =
 156       GetDelegate()->CreateFileSystemOperationContext(url, context, error_code);
 157   if (!operation_context)
 158     return NULL;
 159
 160   if (url.type() == fileapi::kFileSystemTypeSyncableForInternalSync) {
 161     return fileapi::FileSystemOperation::Create(
 162         url, context, operation_context.Pass());
 163   }
 164
 165   return new SyncableFileSystemOperation(
 166       url, context, operation_context.Pass());
 167 }
 168
 169 scoped_ptr<webkit_blob::FileStreamReader>
 170 SyncFileSystemBackend::CreateFileStreamReader(
 171     const fileapi::FileSystemURL& url,
 172     int64 offset,
 173     const base::Time& expected_modification_time,
 174     fileapi::FileSystemContext* context) const {
 175   DCHECK(CanHandleType(url.type()));
 176   return GetDelegate()->CreateFileStreamReader(
 177       url, offset, expected_modification_time, context);
 178 }
 179
 180 scoped_ptr<fileapi::FileStreamWriter>
 181 SyncFileSystemBackend::CreateFileStreamWriter(
 182     const fileapi::FileSystemURL& url,
 183     int64 offset,
 184     fileapi::FileSystemContext* context) const {
 185   DCHECK(CanHandleType(url.type()));
 186   return GetDelegate()->CreateFileStreamWriter(
 187       url, offset, context, fileapi::kFileSystemTypeSyncableForInternalSync);
 188 }
 189
 190 fileapi::FileSystemQuotaUtil* SyncFileSystemBackend::GetQuotaUtil() {
 191   return GetDelegate();
 192 }
 193
 194 // static
 195 SyncFileSystemBackend* SyncFileSystemBackend::GetBackend(
 196     const fileapi::FileSystemContext* file_system_context) {
 197   DCHECK(file_system_context);
 198   return static_cast<SyncFileSystemBackend*>(
 199       file_system_context->GetFileSystemBackend(
 200           fileapi::kFileSystemTypeSyncable));
 201 }
 202
 203 void SyncFileSystemBackend::SetLocalFileChangeTracker(
 204     scoped_ptr<LocalFileChangeTracker> tracker) {
 205   DCHECK(!change_tracker_);
 206   DCHECK(tracker);
 207   change_tracker_ = tracker.Pass();
 208
 209   fileapi::SandboxFileSystemBackendDelegate* delegate = GetDelegate();
 210   delegate->AddFileUpdateObserver(
 211       fileapi::kFileSystemTypeSyncable,
 212       change_tracker_.get(),
 213       delegate->file_task_runner());
 214   delegate->AddFileChangeObserver(
 215       fileapi::kFileSystemTypeSyncable,
 216       change_tracker_.get(),
 217       delegate->file_task_runner());
 218 }
 219
 220 void SyncFileSystemBackend::set_sync_context(
 221     LocalFileSyncContext* sync_context) {
 222   DCHECK(!sync_context_);
 223   sync_context_ = sync_context;
 224 }
 225
 226 fileapi::SandboxFileSystemBackendDelegate*
 227 SyncFileSystemBackend::GetDelegate() const {
 228   DCHECK(context_);
 229   DCHECK(context_->sandbox_delegate());
 230   return context_->sandbox_delegate();
 231 }
 232
 233 void SyncFileSystemBackend::InitializeSyncFileSystemService(
 234     const GURL& origin_url,
 235     const SyncStatusCallback& callback) {
 236   // Repost to switch from IO thread to UI thread.
 237   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 238     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 239     // It is safe to pass Unretained(this) (see comments in OpenFileSystem()).
 240     BrowserThread::PostTask(
 241         BrowserThread::UI, FROM_HERE,
 242         base::Bind(&SyncFileSystemBackend::InitializeSyncFileSystemService,
 243                    base::Unretained(this), origin_url, callback));
 244     return;
 245   }
 246
 247   if (!profile_holder_->GetProfile()) {
 248     // Profile was destroyed.
 249     callback.Run(SYNC_FILE_ERROR_FAILED);
 250     return;
 251   }
 252
 253   SyncFileSystemService* service = SyncFileSystemServiceFactory::GetForProfile(
 254           profile_holder_->GetProfile());
 255   DCHECK(service);
 256   service->InitializeForApp(context_, origin_url, callback);
 257 }
 258
 259 void SyncFileSystemBackend::DidInitializeSyncFileSystemService(
 260     fileapi::FileSystemContext* context,
 261     const GURL& origin_url,
 262     fileapi::FileSystemType type,
 263     fileapi::OpenFileSystemMode mode,
 264     const OpenFileSystemCallback& callback,
 265     SyncStatusCode status) {
 266   // Repost to switch from UI thread to IO thread.
 267   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
 268     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 269     // It is safe to pass Unretained(this) since |context| owns it.
 270     BrowserThread::PostTask(
 271         BrowserThread::IO, FROM_HERE,
 272         base::Bind(&SyncFileSystemBackend::DidInitializeSyncFileSystemService,
 273                    base::Unretained(this), make_scoped_refptr(context),
 274                    origin_url, type, mode, callback, status));
 275     return;
 276   }
 277
 278   if (status != sync_file_system::SYNC_STATUS_OK) {
 279     callback.Run(GURL(), std::string(),
 280                  SyncStatusCodeToPlatformFileError(status));
 281     return;
 282   }
 283
 284   callback.Run(GetSyncableFileSystemRootURI(origin_url),
 285                GetFileSystemName(origin_url, type),
 286                base::PLATFORM_FILE_OK);
 287 }
 288
 289 }  // namespace sync_file_system