Remove MTP support on Linux.

chrome/browser/media_galleries/fileapi/media_file_system_backend.cc

 // Copyright (c) 2013 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.
 
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/media_galleries/fileapi/device_media_async_file_util.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_validator_factory.h"
 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
 #include "chrome/browser/media_galleries/fileapi/native_media_file_util.h"
 #include "chrome/browser/media_galleries/media_file_system_registry.h"
 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_system.h"
 #include "net/url_request/url_request.h"
 #include "storage/browser/fileapi/copy_or_move_file_validator.h"
 #include "storage/browser/fileapi/file_stream_reader.h"
 #include "storage/browser/fileapi/file_stream_writer.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation.h"
 #include "storage/browser/fileapi/file_system_operation_context.h"
 #include "storage/browser/fileapi/file_system_url.h"
 #include "storage/browser/fileapi/native_file_util.h"
 #include "storage/common/fileapi/file_system_types.h"
 #include "storage/common/fileapi/file_system_util.h"
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #include "chrome/browser/media_galleries/fileapi/itunes_file_util.h"
 #include "chrome/browser/media_galleries/fileapi/picasa_file_util.h"
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
+#include "chrome/browser/media_galleries/fileapi/device_media_async_file_util.h"
+#endif
+
 using storage::FileSystemContext;
 using storage::FileSystemURL;
 
 namespace {
 
 const char kMediaGalleryMountPrefix[] = "media_galleries-";
 
 #if DCHECK_IS_ON()
 base::LazyInstance<base::SequenceChecker>::Leaky g_media_sequence_checker =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 66 matching lines @@
 const char MediaFileSystemBackend::kMediaTaskRunnerName[] =
     "media-task-runner";
 
 MediaFileSystemBackend::MediaFileSystemBackend(
     const base::FilePath& profile_path,
     base::SequencedTaskRunner* media_task_runner)
     : profile_path_(profile_path),
       media_task_runner_(media_task_runner),
       media_path_filter_(new MediaPathFilter),
       media_copy_or_move_file_validator_factory_(new MediaFileValidatorFactory),
-      native_media_file_util_(
-          new NativeMediaFileUtil(media_path_filter_.get())),
+      native_media_file_util_(new NativeMediaFileUtil(media_path_filter_.get()))
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
+      ,
       device_media_async_file_util_(
           DeviceMediaAsyncFileUtil::Create(profile_path_,
                                            APPLY_MEDIA_FILE_VALIDATION))
+#endif
 #if defined(OS_WIN) || defined(OS_MACOSX)
       ,
       picasa_file_util_(new picasa::PicasaFileUtil(media_path_filter_.get())),
       itunes_file_util_(new itunes::ITunesFileUtil(media_path_filter_.get())),
       picasa_file_util_used_(false),
       itunes_file_util_used_(false)
-#endif  // defined(OS_WIN) || defined(OS_MACOSX)
+#endif
 {
 }
 
 MediaFileSystemBackend::~MediaFileSystemBackend() {
 }
 
 // static
 void MediaFileSystemBackend::AssertCurrentlyOnMediaSequence() {
 #if DCHECK_IS_ON()
   DCHECK(g_media_sequence_checker.Get().CalledOnValidSequence());
@@ skipping 92 matching lines @@
                  base::File::FILE_ERROR_SECURITY));
 }
 
 storage::AsyncFileUtil* MediaFileSystemBackend::GetAsyncFileUtil(
     storage::FileSystemType type) {
   // We count file system usages here, because we want to count (per session)
   // when the file system is actually used for I/O, rather than merely present.
   switch (type) {
     case storage::kFileSystemTypeNativeMedia:
       return native_media_file_util_.get();
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
     case storage::kFileSystemTypeDeviceMedia:
       return device_media_async_file_util_.get();
+#endif
 #if defined(OS_WIN) || defined(OS_MACOSX)
     case storage::kFileSystemTypeItunes:
       if (!itunes_file_util_used_) {
         media_galleries::UsageCount(media_galleries::ITUNES_FILE_SYSTEM_USED);
         itunes_file_util_used_ = true;
       }
       return itunes_file_util_.get();
     case storage::kFileSystemTypePicasa:
       if (!picasa_file_util_used_) {
         media_galleries::UsageCount(media_galleries::PICASA_FILE_SYSTEM_USED);
@@ skipping 39 matching lines @@
     base::File::Error* error_code) const {
   std::unique_ptr<storage::FileSystemOperationContext> operation_context(
       new storage::FileSystemOperationContext(context,
                                               media_task_runner_.get()));
   return storage::FileSystemOperation::Create(url, context,
                                               std::move(operation_context));
 }
 
 bool MediaFileSystemBackend::SupportsStreaming(
     const storage::FileSystemURL& url) const {
-  if (url.type() == storage::kFileSystemTypeDeviceMedia) {
-    DCHECK(device_media_async_file_util_);
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
+  if (url.type() == storage::kFileSystemTypeDeviceMedia)
     return device_media_async_file_util_->SupportsStreaming(url);
-  }
+#endif
 
   return false;
 }
 
 bool MediaFileSystemBackend::HasInplaceCopyImplementation(
     storage::FileSystemType type) const {
   DCHECK(type == storage::kFileSystemTypeNativeMedia ||
          type == storage::kFileSystemTypeDeviceMedia ||
          type == storage::kFileSystemTypeItunes ||
          type == storage::kFileSystemTypePicasa);
   return true;
 }
 
 std::unique_ptr<storage::FileStreamReader>
 MediaFileSystemBackend::CreateFileStreamReader(
     const FileSystemURL& url,
     int64_t offset,
     int64_t max_bytes_to_read,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
   if (url.type() == storage::kFileSystemTypeDeviceMedia) {
-    DCHECK(device_media_async_file_util_);
     std::unique_ptr<storage::FileStreamReader> reader =
         device_media_async_file_util_->GetFileStreamReader(
             url, offset, expected_modification_time, context);
     DCHECK(reader);
     return reader;
   }
+#endif
 
   return std::unique_ptr<storage::FileStreamReader>(
       storage::FileStreamReader::CreateForLocalFile(
           context->default_file_task_runner(), url.path(), offset,
           expected_modification_time));
 }
 
 std::unique_ptr<storage::FileStreamWriter>
 MediaFileSystemBackend::CreateFileStreamWriter(
     const FileSystemURL& url,
@@ skipping 17 matching lines @@
 
 const storage::ChangeObserverList* MediaFileSystemBackend::GetChangeObservers(
     storage::FileSystemType type) const {
   return NULL;
 }
 
 const storage::AccessObserverList* MediaFileSystemBackend::GetAccessObservers(
     storage::FileSystemType type) const {
   return NULL;
 }