Remove MTP support on Linux.

components/storage_monitor/storage_monitor_linux.cc

 // Copyright 2014 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.
 
 // StorageMonitorLinux implementation.
 
 #include "components/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <limits>
 #include <list>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/storage_monitor/media_storage_util.h"
-#include "components/storage_monitor/media_transfer_protocol_device_observer_linux.h"
 #include "components/storage_monitor/removable_device_constants.h"
 #include "components/storage_monitor/storage_info.h"
 #include "components/storage_monitor/udev_util_linux.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 #include "device/udev_linux/scoped_udev.h"
 
 using content::BrowserThread;
 
 namespace storage_monitor {
 
@@ skipping 219 matching lines @@
 void StorageMonitorLinux::Init() {
   DCHECK(!mtab_path_.empty());
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateMtabWatcherLinuxOnFileThread,
                  mtab_path_,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&StorageMonitorLinux::OnMtabWatcherCreated,
                  weak_ptr_factory_.GetWeakPtr()));
-
-  if (!media_transfer_protocol_manager_) {
-    media_transfer_protocol_manager_.reset(
-        device::MediaTransferProtocolManager::Initialize(
-            BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
-  }
-
-  media_transfer_protocol_device_observer_.reset(
-      new MediaTransferProtocolDeviceObserverLinux(
-          receiver(), media_transfer_protocol_manager_.get()));
 }
 
 bool StorageMonitorLinux::GetStorageInfoForPath(
     const base::FilePath& path,
     StorageInfo* device_info) const {
   DCHECK(device_info);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  // TODO(thestig) |media_transfer_protocol_device_observer_| should always be
-  // valid.
-  if (media_transfer_protocol_device_observer_ &&
-      media_transfer_protocol_device_observer_->GetStorageInfoForPath(
-          path, device_info)) {
-    return true;
-  }
-
   if (!path.IsAbsolute())
     return false;
 
   base::FilePath current = path;
   while (!base::ContainsKey(mount_info_map_, current) &&
          current != current.DirName())
     current = current.DirName();
 
   MountMap::const_iterator mount_info = mount_info_map_.find(current);
   if (mount_info == mount_info_map_.end())
     return false;
   *device_info = mount_info->second.storage_info;
   return true;
 }
 
-device::MediaTransferProtocolManager*
-StorageMonitorLinux::media_transfer_protocol_manager() {
-  return media_transfer_protocol_manager_.get();
-}
-
 void StorageMonitorLinux::SetGetDeviceInfoCallbackForTest(
     const GetDeviceInfoCallback& get_device_info_callback) {
   get_device_info_callback_ = get_device_info_callback;
 }
 
-void StorageMonitorLinux::SetMediaTransferProtocolManagerForTest(
-    device::MediaTransferProtocolManager* test_manager) {
-  DCHECK(!media_transfer_protocol_manager_);
-  media_transfer_protocol_manager_.reset(test_manager);
-}
-
 void StorageMonitorLinux::EjectDevice(
     const std::string& device_id,
     base::Callback<void(EjectStatus)> callback) {
   StorageInfo::Type type;
   if (!StorageInfo::CrackDeviceId(device_id, &type, NULL)) {
     callback.Run(EJECT_FAILURE);
     return;
   }
 
-  if (type == StorageInfo::MTP_OR_PTP) {
-    media_transfer_protocol_device_observer_->EjectDevice(device_id, callback);
-    return;
-  }
+  DCHECK_NE(type, StorageInfo::MTP_OR_PTP);
 
   // Find the mount point for the given device ID.
   base::FilePath path;
   base::FilePath device;
   for (MountMap::iterator mount_info = mount_info_map_.begin();
        mount_info != mount_info_map_.end(); ++mount_info) {
     if (mount_info->second.storage_info.device_id() == device_id) {
       path = mount_info->first;
       device = mount_info->second.mount_device;
       mount_info_map_.erase(mount_info);
@@ skipping 158 matching lines @@
   mount_priority_map_[mount_device][mount_point] = removable;
   receiver()->ProcessAttach(*storage_info);
 }
 
 StorageMonitor* StorageMonitor::CreateInternal() {
   const base::FilePath kDefaultMtabPath("/etc/mtab");
   return new StorageMonitorLinux(kDefaultMtabPath);
 }
 
 }  // namespace storage_monitor