Remove fileapi::FileSystemFileUtil dependency in media gallery code

chrome/browser/media_galleries/win/mtp_device_delegate_impl_win.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.
 //
 // MTPDeviceDelegateImplWin implementation.
 
 #include "chrome/browser/media_galleries/win/mtp_device_delegate_impl_win.h"
 
 #include <portabledevice.h>
 
@@ skipping 80 matching lines @@
                                                      path_components[i]);
     if (file_object_id.empty())
       break;
     parent_id = file_object_id;
   }
   return file_object_id;
 }
 
 // Returns a pointer to a new instance of AbstractFileEnumerator for the given
 // |root| directory. Called on a blocking pool thread.
-scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator>
+scoped_ptr<MTPDeviceObjectEnumerator>
 CreateFileEnumeratorOnBlockingPoolThread(
     const MTPDeviceDelegateImplWin::StorageDeviceInfo& device_info,
     const base::FilePath& root) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!device_info.registered_device_path.empty());
   DCHECK(!root.empty());
-  scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator>
-      file_enumerator(new fileapi::FileSystemFileUtil::EmptyFileEnumerator());
   IPortableDevice* device =
       PortableDeviceMapService::GetInstance()->GetPortableDevice(
           device_info.registered_device_path);
   if (!device)
-    return file_enumerator.Pass();
+    return scoped_ptr<MTPDeviceObjectEnumerator>();
 
   string16 object_id = GetFileObjectIdFromPathOnBlockingPoolThread(device_info,
                                                                    root);
   if (object_id.empty())
-    return file_enumerator.Pass();
+    return scoped_ptr<MTPDeviceObjectEnumerator>();
 
   MTPDeviceObjectEntries entries;
   if (!media_transfer_protocol::GetDirectoryEntries(device, object_id,
                                                     &entries) ||
       entries.empty())
-    return file_enumerator.Pass();
+    return scoped_ptr<MTPDeviceObjectEnumerator>();
 
-  file_enumerator.reset(new MTPDeviceObjectEnumerator(entries));
-  return file_enumerator.Pass();
+  return scoped_ptr<MTPDeviceObjectEnumerator>(
+      new MTPDeviceObjectEnumerator(entries));
 }
 
 // Opens the device for communication on a blocking pool thread.
 // |pnp_device_id| specifies the PnP device id.
 // |registered_device_path| specifies the registered file system root path for
 // the given device.
 bool OpenDeviceOnBlockingPoolThread(const string16& pnp_device_id,
                                     const string16& registered_device_path) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!pnp_device_id.empty());
@@ skipping 49 matching lines @@
   base::PlatformFileError error = GetFileInfoOnBlockingPoolThread(device_info,
                                                                   root,
                                                                   &file_info);
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   if (!file_info.is_directory)
     return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
 
   base::FilePath current;
-  scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator> file_enum =
+  scoped_ptr<MTPDeviceObjectEnumerator> file_enum =
       CreateFileEnumeratorOnBlockingPoolThread(device_info, root);
+  if (!file_enum)
+    return error;
+
   while (!(current = file_enum->Next()).empty()) {
     fileapi::DirectoryEntry entry;
     entry.is_directory = file_enum->IsDirectory();
     entry.name = fileapi::VirtualPath::BaseName(current).value();
     entry.size = file_enum->Size();
     entry.last_modified_time = file_enum->LastModifiedTime();
     entries->push_back(entry);
   }
   return error;
 }
@@ skipping 74 matching lines @@
       file_details.optimal_transfer_size());
 }
 
 void DeletePortableDeviceOnBlockingPoolThread(
     const string16& registered_device_path) {
   base::ThreadRestrictions::AssertIOAllowed();
   PortableDeviceMapService::GetInstance()->RemovePortableDevice(
       registered_device_path);
 }
 
-
 }  // namespace
 
 // Used by CreateMTPDeviceAsyncDelegate() to create the MTP device
 // delegate on the IO thread.
 void OnGetStorageInfoCreateDelegate(
     const string16& device_location,
     const CreateMTPDeviceAsyncDelegateCallback& callback,
     string16* pnp_device_id,
     string16* storage_object_id,
     bool succeeded) {
@@ skipping 296 matching lines @@
         current_snapshot_details_->file_info(),
         current_snapshot_details_->request_info().snapshot_file_path);
   } else {
     current_snapshot_details_->request_info().error_callback.Run(
         base::PLATFORM_FILE_ERROR_FAILED);
   }
   task_in_progress_ = false;
   current_snapshot_details_.reset();
   ProcessNextPendingRequest();
 }