Home | History | Annotate | Download | only in fileapi
      1 // Copyright (c) 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/media_galleries/fileapi/media_file_system_backend.h"
      6 
      7 #include <string>
      8 
      9 #include "base/bind.h"
     10 #include "base/files/file_path.h"
     11 #include "base/logging.h"
     12 #include "base/message_loop/message_loop_proxy.h"
     13 #include "base/platform_file.h"
     14 #include "base/sequenced_task_runner.h"
     15 #include "base/threading/sequenced_worker_pool.h"
     16 #include "chrome/browser/media_galleries/fileapi/device_media_async_file_util.h"
     17 #include "chrome/browser/media_galleries/fileapi/media_file_validator_factory.h"
     18 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
     19 #include "chrome/browser/media_galleries/fileapi/native_media_file_util.h"
     20 #include "content/public/browser/browser_thread.h"
     21 #include "webkit/browser/blob/local_file_stream_reader.h"
     22 #include "webkit/browser/fileapi/async_file_util_adapter.h"
     23 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
     24 #include "webkit/browser/fileapi/file_system_context.h"
     25 #include "webkit/browser/fileapi/file_system_file_stream_reader.h"
     26 #include "webkit/browser/fileapi/file_system_operation_context.h"
     27 #include "webkit/browser/fileapi/file_system_operation_impl.h"
     28 #include "webkit/browser/fileapi/isolated_context.h"
     29 #include "webkit/browser/fileapi/isolated_file_util.h"
     30 #include "webkit/browser/fileapi/local_file_stream_writer.h"
     31 #include "webkit/browser/fileapi/native_file_util.h"
     32 #include "webkit/common/fileapi/file_system_types.h"
     33 #include "webkit/common/fileapi/file_system_util.h"
     34 
     35 #if defined(OS_WIN) || defined(OS_MACOSX)
     36 #include "chrome/browser/media_galleries/fileapi/itunes_file_util.h"
     37 #include "chrome/browser/media_galleries/fileapi/picasa/picasa_file_util.h"
     38 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
     39 
     40 using fileapi::FileSystemContext;
     41 using fileapi::FileSystemURL;
     42 
     43 namespace chrome {
     44 
     45 const char MediaFileSystemBackend::kMediaTaskRunnerName[] =
     46     "media-task-runner";
     47 
     48 MediaFileSystemBackend::MediaFileSystemBackend(
     49     const base::FilePath& profile_path,
     50     base::SequencedTaskRunner* media_task_runner)
     51     : profile_path_(profile_path),
     52       media_task_runner_(media_task_runner),
     53       media_path_filter_(new MediaPathFilter),
     54       media_copy_or_move_file_validator_factory_(new MediaFileValidatorFactory),
     55       native_media_file_util_(
     56           new NativeMediaFileUtil(media_path_filter_.get())),
     57       device_media_async_file_util_(
     58           DeviceMediaAsyncFileUtil::Create(profile_path_))
     59 #if defined(OS_WIN) || defined(OS_MACOSX)
     60       ,
     61       picasa_file_util_(new picasa::PicasaFileUtil(media_path_filter_.get())),
     62       itunes_file_util_(new itunes::ITunesFileUtil(media_path_filter_.get()))
     63 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
     64 {
     65 }
     66 
     67 MediaFileSystemBackend::~MediaFileSystemBackend() {
     68 }
     69 
     70 // static
     71 bool MediaFileSystemBackend::CurrentlyOnMediaTaskRunnerThread() {
     72   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
     73   base::SequencedWorkerPool::SequenceToken media_sequence_token =
     74       pool->GetNamedSequenceToken(kMediaTaskRunnerName);
     75   return pool->IsRunningSequenceOnCurrentThread(media_sequence_token);
     76 }
     77 
     78 // static
     79 scoped_refptr<base::SequencedTaskRunner>
     80 MediaFileSystemBackend::MediaTaskRunner() {
     81   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
     82   base::SequencedWorkerPool::SequenceToken media_sequence_token =
     83       pool->GetNamedSequenceToken(kMediaTaskRunnerName);
     84   return pool->GetSequencedTaskRunner(media_sequence_token);
     85 }
     86 
     87 bool MediaFileSystemBackend::CanHandleType(
     88     fileapi::FileSystemType type) const {
     89   switch (type) {
     90     case fileapi::kFileSystemTypeNativeMedia:
     91     case fileapi::kFileSystemTypeDeviceMedia:
     92 #if defined(OS_WIN) || defined(OS_MACOSX)
     93     case fileapi::kFileSystemTypePicasa:
     94     case fileapi::kFileSystemTypeItunes:
     95 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
     96       return true;
     97     default:
     98       return false;
     99   }
    100 }
    101 
    102 void MediaFileSystemBackend::Initialize(fileapi::FileSystemContext* context) {
    103 }
    104 
    105 void MediaFileSystemBackend::OpenFileSystem(
    106     const GURL& origin_url,
    107     fileapi::FileSystemType type,
    108     fileapi::OpenFileSystemMode mode,
    109     const OpenFileSystemCallback& callback) {
    110   // We never allow opening a new isolated FileSystem via usual OpenFileSystem.
    111   base::MessageLoopProxy::current()->PostTask(
    112       FROM_HERE,
    113       base::Bind(callback,
    114                  GetFileSystemRootURI(origin_url, type),
    115                  GetFileSystemName(origin_url, type),
    116                  base::PLATFORM_FILE_ERROR_SECURITY));
    117 }
    118 
    119 fileapi::FileSystemFileUtil* MediaFileSystemBackend::GetFileUtil(
    120     fileapi::FileSystemType type) {
    121   NOTREACHED();
    122   return NULL;
    123 }
    124 
    125 fileapi::AsyncFileUtil* MediaFileSystemBackend::GetAsyncFileUtil(
    126     fileapi::FileSystemType type) {
    127   switch (type) {
    128     case fileapi::kFileSystemTypeNativeMedia:
    129       return native_media_file_util_.get();
    130     case fileapi::kFileSystemTypeDeviceMedia:
    131       return device_media_async_file_util_.get();
    132 #if defined(OS_WIN) || defined(OS_MACOSX)
    133     case fileapi::kFileSystemTypeItunes:
    134       return itunes_file_util_.get();
    135     case fileapi::kFileSystemTypePicasa:
    136       return picasa_file_util_.get();
    137 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
    138     default:
    139       NOTREACHED();
    140   }
    141   return NULL;
    142 }
    143 
    144 fileapi::CopyOrMoveFileValidatorFactory*
    145 MediaFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
    146     fileapi::FileSystemType type, base::PlatformFileError* error_code) {
    147   DCHECK(error_code);
    148   *error_code = base::PLATFORM_FILE_OK;
    149   switch (type) {
    150     case fileapi::kFileSystemTypeNativeMedia:
    151     case fileapi::kFileSystemTypeDeviceMedia:
    152     case fileapi::kFileSystemTypeItunes:
    153       if (!media_copy_or_move_file_validator_factory_) {
    154         *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
    155         return NULL;
    156       }
    157       return media_copy_or_move_file_validator_factory_.get();
    158     default:
    159       NOTREACHED();
    160   }
    161   return NULL;
    162 }
    163 
    164 fileapi::FileSystemOperation*
    165 MediaFileSystemBackend::CreateFileSystemOperation(
    166     const FileSystemURL& url,
    167     FileSystemContext* context,
    168     base::PlatformFileError* error_code) const {
    169   scoped_ptr<fileapi::FileSystemOperationContext> operation_context(
    170       new fileapi::FileSystemOperationContext(
    171           context, media_task_runner_.get()));
    172   return new fileapi::FileSystemOperationImpl(url, context,
    173                                               operation_context.Pass());
    174 }
    175 
    176 scoped_ptr<webkit_blob::FileStreamReader>
    177 MediaFileSystemBackend::CreateFileStreamReader(
    178     const FileSystemURL& url,
    179     int64 offset,
    180     const base::Time& expected_modification_time,
    181     FileSystemContext* context) const {
    182   return scoped_ptr<webkit_blob::FileStreamReader>(
    183       new webkit_blob::LocalFileStreamReader(
    184           context->default_file_task_runner(),
    185           url.path(), offset, expected_modification_time));
    186 }
    187 
    188 scoped_ptr<fileapi::FileStreamWriter>
    189 MediaFileSystemBackend::CreateFileStreamWriter(
    190     const FileSystemURL& url,
    191     int64 offset,
    192     FileSystemContext* context) const {
    193   return scoped_ptr<fileapi::FileStreamWriter>(
    194       new fileapi::LocalFileStreamWriter(
    195           context->default_file_task_runner(),
    196           url.path(), offset));
    197 }
    198 
    199 fileapi::FileSystemQuotaUtil*
    200 MediaFileSystemBackend::GetQuotaUtil() {
    201   // No quota support.
    202   return NULL;
    203 }
    204 
    205 }  // namespace chrome
    206