Move DirectoryReader::ReadEntries to FileRef::ReadDirectoryEntries

webkit/plugins/ppapi/ppb_file_ref_impl.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 "webkit/plugins/ppapi/ppb_file_ref_impl.h"
 
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
@@ skipping 75 matching lines @@
   CHECK(pos != std::string::npos);
   return path.substr(pos + 1);
 }
 
 void IgnoreCloseCallback(base::PlatformFileError error_code) {
 }
 
 void GetFileInfoCallback(
     scoped_refptr<base::TaskRunner> task_runner,
     base::PlatformFile file,
-    PP_FileInfo* info,
+    linked_ptr<PP_FileInfo> info,
     scoped_refptr<TrackedCallback> callback,
     base::PlatformFileError error_code,
     const base::PlatformFileInfo& file_info) {
   base::FileUtilProxy::Close(
       task_runner, file, base::Bind(&IgnoreCloseCallback));
 
   if (!TrackedCallback::IsPending(callback))
     return;
 
   int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
   if (pp_error != PP_OK)
     callback->Run(pp_error);
 
   info->size = file_info.size;
   if (file_info.is_symbolic_link)
     info->type = PP_FILETYPE_OTHER;
   else if (file_info.is_directory)
     info->type = PP_FILETYPE_DIRECTORY;
   else
     info->type = PP_FILETYPE_REGULAR;
 
   info->system_type = PP_FILESYSTEMTYPE_EXTERNAL;
   info->creation_time = file_info.creation_time.ToDoubleT();
   info->last_access_time = file_info.last_accessed.ToDoubleT();
   info->last_modified_time = file_info.last_modified.ToDoubleT();
   callback->Run(PP_OK);
 }
 
 void QueryCallback(scoped_refptr<base::TaskRunner> task_runner,
-                   PP_FileInfo* info,
+                   linked_ptr<PP_FileInfo> info,
                    scoped_refptr<TrackedCallback> callback,
                    base::PlatformFileError error_code,
                    base::PassPlatformFile passed_file) {
   if (!TrackedCallback::IsPending(callback))
     return;
 
   int32_t pp_error = ::ppapi::PlatformFileErrorToPepperError(error_code);
   if (pp_error != PP_OK)
     callback->Run(pp_error);
   base::PlatformFile file = passed_file.ReleaseValue();
@@ skipping 105 matching lines @@
     PP_Bool make_ancestors,
     scoped_refptr<TrackedCallback> callback) {
   if (!IsValidNonExternalFileSystem())
     return PP_ERROR_NOACCESS;
 
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   if (!plugin_instance->delegate()->MakeDirectory(
           GetFileSystemURL(), PP_ToBool(make_ancestors),
-          new FileCallbacks(this, callback, NULL)))
+          new FileCallbacks(this, callback)))
     return PP_ERROR_FAILED;
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileRef_Impl::Touch(PP_Time last_access_time,
                                 PP_Time last_modified_time,
                                 scoped_refptr<TrackedCallback> callback) {
   if (!IsValidNonExternalFileSystem())
     return PP_ERROR_NOACCESS;
 
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   if (!plugin_instance->delegate()->Touch(
           GetFileSystemURL(),
           PPTimeToTime(last_access_time),
           PPTimeToTime(last_modified_time),
-          new FileCallbacks(this, callback, NULL)))
+          new FileCallbacks(this, callback)))
     return PP_ERROR_FAILED;
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileRef_Impl::Delete(scoped_refptr<TrackedCallback> callback) {
   if (!IsValidNonExternalFileSystem())
     return PP_ERROR_NOACCESS;
 
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   if (!plugin_instance->delegate()->Delete(
           GetFileSystemURL(),
-          new FileCallbacks(this, callback, NULL)))
+          new FileCallbacks(this, callback)))
     return PP_ERROR_FAILED;
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_FileRef_Impl::Rename(PP_Resource new_pp_file_ref,
                                  scoped_refptr<TrackedCallback> callback) {
   EnterResourceNoLock<PPB_FileRef_API> enter(new_pp_file_ref, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
   PPB_FileRef_Impl* new_file_ref =
       static_cast<PPB_FileRef_Impl*>(enter.object());
 
   if (!IsValidNonExternalFileSystem() ||
       file_system_ != new_file_ref->file_system_)
     return PP_ERROR_NOACCESS;
 
   // TODO(viettrungluu): Also cancel when the new file ref is destroyed?
   // http://crbug.com/67624
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
   if (!plugin_instance->delegate()->Rename(
           GetFileSystemURL(), new_file_ref->GetFileSystemURL(),
-          new FileCallbacks(this, callback, NULL)))
+          new FileCallbacks(this, callback)))
     return PP_ERROR_FAILED;
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Var PPB_FileRef_Impl::GetAbsolutePath() {
   if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL)
     return GetPath();
   if (!external_path_var_.get()) {
     external_path_var_ = new StringVar(
         external_file_system_path_.AsUTF8Unsafe());
@@ skipping 45 matching lines @@
 
 bool PPB_FileRef_Impl::HasValidFileSystem() const {
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   PluginDelegate* delegate =
       plugin_instance ? plugin_instance->delegate() : NULL;
   return delegate && delegate->IsFileSystemOpened(pp_instance(), file_system_);
 }
 
 int32_t PPB_FileRef_Impl::Query(PP_FileInfo* info,
                                 scoped_refptr<TrackedCallback> callback) {
+  NOTREACHED();
+  return PP_ERROR_FAILED;
+}
+
+int32_t PPB_FileRef_Impl::QueryInHost(
+    linked_ptr<PP_FileInfo> info,
+    scoped_refptr<TrackedCallback> callback) {
   scoped_refptr<PluginInstance> plugin_instance =
       ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance.get())
     return PP_ERROR_FAILED;
 
   if (!file_system_) {
     // External file system
     // We have to do something totally different for external file systems.
 
     // TODO(teravest): Use the SequencedWorkerPool instead.
@@ skipping 19 matching lines @@
             GetFileSystemURL(),
             new FileCallbacks(this, callback, info,
                               delegate->GetFileSystemType(pp_instance(),
                                                           file_system_))))
       return PP_ERROR_FAILED;
 
   }
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t PPB_FileRef_Impl::ReadDirectoryEntries(
+    const PP_ArrayOutput& output,
+    scoped_refptr<TrackedCallback> callback) {
+  NOTREACHED();
+  return PP_ERROR_FAILED;
+}
+
+int32_t PPB_FileRef_Impl::ReadDirectoryEntriesInHost(
+    linked_ptr<std::vector< ::ppapi::PPB_FileRef_CreateInfo> > files,
+    linked_ptr<std::vector<PP_FileType> > file_types,
+    scoped_refptr<TrackedCallback> callback) {
+  if (!IsValidNonExternalFileSystem())
+    return PP_ERROR_NOACCESS;
+
+  PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
+  if (!plugin_instance)
+    return PP_ERROR_FAILED;
+
+  FileCallbacks::ReadDirectoryEntriesParams params;
+  params.dir_ref = this;
+  params.files = files;
+  params.file_types = file_types;
+
+  if (!plugin_instance->delegate()->ReadDirectoryEntries(
+          GetFileSystemURL(),
+          new FileCallbacks(this, callback, params)))
+    return PP_ERROR_FAILED;
+  return PP_OK_COMPLETIONPENDING;
+}
+
 }  // namespace ppapi
 }  // namespace webkit