FileAPI: Copy base::FileUtilProxy::Entry to fileapi::DirectoryEntry

chrome/browser/chromeos/drive/file_system_proxy.cc

 // Copyright (c) 2012 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/chromeos/drive/file_system_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_system_service.h"
 #include "chrome/browser/chromeos/drive/file_system_interface.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/webkit_file_stream_reader_impl.h"
 #include "chrome/browser/google_apis/task_util.h"
 #include "chrome/browser/google_apis/time_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/blob/file_stream_reader.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using base::MessageLoopProxy;
 using content::BrowserThread;
+using fileapi::DirectoryEntry;
 using fileapi::FileSystemURL;
 using fileapi::FileSystemOperation;
 using webkit_blob::ShareableFileReference;
 
 namespace drive {
 
 namespace {
 
 typedef fileapi::RemoteFileSystemProxyInterface::OpenFileCallback
     OpenFileCallback;
@@ skipping 106 matching lines @@
     base::PlatformFileError truncate_result,
     FileError close_result) {
   // Reports the first error.
   callback.Run(truncate_result == base::PLATFORM_FILE_OK ?
                FileErrorToPlatformError(close_result) :
                truncate_result);
 }
 
 }  // namespace
 
-base::FileUtilProxy::Entry ResourceEntryToFileUtilProxyEntry(
+DirectoryEntry ResourceEntryToDirectoryEntry(
     const ResourceEntry& resource_entry) {
   base::PlatformFileInfo file_info;
   util::ConvertResourceEntryToPlatformFileInfo(
       resource_entry.file_info(), &file_info);
 
-  base::FileUtilProxy::Entry entry;
+  DirectoryEntry entry;
   entry.name = resource_entry.base_name();
   entry.is_directory = file_info.is_directory;
   entry.size = file_info.size;
   entry.last_modified_time = file_info.last_modified;
   return entry;
 }
 
 // FileSystemProxy class implementation.
 
 FileSystemProxy::FileSystemProxy(
@@ skipping 89 matching lines @@
     const FileSystemURL& file_url,
     const FileSystemOperation::ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
-                   std::vector<base::FileUtilProxy::Entry>(),
+                   std::vector<DirectoryEntry>(),
                    false));
     return;
   }
 
   CallFileSystemMethodOnUIThread(
       base::Bind(&FileSystemInterface::ReadDirectoryByPath,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnReadDirectory,
@@ skipping 510 matching lines @@
 void FileSystemProxy::OnReadDirectory(
     const FileSystemOperation::ReadDirectoryCallback&
     callback,
     FileError error,
     bool hide_hosted_documents,
     scoped_ptr<ResourceEntryVector> resource_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != FILE_ERROR_OK) {
     callback.Run(FileErrorToPlatformError(error),
-                 std::vector<base::FileUtilProxy::Entry>(),
+                 std::vector<DirectoryEntry>(),
                  false);
     return;
   }
   DCHECK(resource_entries.get());
 
-  std::vector<base::FileUtilProxy::Entry> entries;
+  std::vector<DirectoryEntry> entries;
   // Convert Drive files to something File API stack can understand.
   for (size_t i = 0; i < resource_entries->size(); ++i) {
     const ResourceEntry& resource_entry = (*resource_entries)[i];
     if (resource_entry.has_file_specific_info() &&
         resource_entry.file_specific_info().is_hosted_document() &&
         hide_hosted_documents) {
       continue;
     }
-    entries.push_back(ResourceEntryToFileUtilProxyEntry(resource_entry));
+    entries.push_back(ResourceEntryToDirectoryEntry(resource_entry));
   }
 
   callback.Run(base::PLATFORM_FILE_OK, entries, false);
 }
 
 void FileSystemProxy::OnCreateWritableSnapshotFile(
     const base::FilePath& virtual_path,
     const fileapi::WritableSnapshotFile& callback,
     FileError result,
     const base::FilePath& local_path) {
@@ skipping 28 matching lines @@
                      base::Bind(&EmitDebugLogForCloseFile,
                                 virtual_path))));
 }
 
 FileSystemInterface* FileSystemProxy::GetFileSystemOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return file_system_;
 }
 
 }  // namespace drive