Revert 184054

> Implement ReadEntries API for PPB_DirectoryReader
> 
> The ReadEntries API returns all file entries in the given directory at once.
> 
> API discussion is here: https://codereview.chromium.org/12026008/
> 
> BUG=113086
> TEST=browser_tests --gtest_filter=\*DirectoryReader\*
> 
> Review URL: https://chromiumcodereview.appspot.com/12090071

TBR=nhiroki@chromium.org
Review URL: https://codereview.chromium.org/12319065

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@184074 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 64 insertions, 37 deletions

diff --git a/ppapi/proxy/directory_reader_resource.cc b/ppapi/proxy/directory_reader_resource.cc
index 17826d03..99075a3 100644
--- a/ppapi/proxy/directory_reader_resource.cc
+++ b/ppapi/proxy/directory_reader_resource.cc
@@ -21,22 +21,13 @@ using ppapi::proxy::PPB_FileRef_Proxy;
 namespace ppapi {
 namespace proxy {
 
-namespace {
-
-void ReleaseEntries(const std::vector<PP_DirectoryEntry_Dev>& entries) {
-  ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker();
-  for (std::vector<PP_DirectoryEntry_Dev>::const_iterator it = entries.begin();
-       it != entries.end(); ++it)
-    tracker->ReleaseResource(it->file_ref);
-}
-
-}  // namespace
-
 DirectoryReaderResource::DirectoryReaderResource(
     Connection connection,
     PP_Instance instance,
     PP_Resource directory_ref)
-    : PluginResource(connection, instance) {
+    : PluginResource(connection, instance),
+      output_(NULL),
+      did_receive_get_entries_reply_(false) {
   directory_resource_ =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(directory_ref);
 }
@@ -49,14 +40,18 @@ DirectoryReaderResource::AsPPB_DirectoryReader_API() {
   return this;
 }
 
-int32_t DirectoryReaderResource::ReadEntries(
-    const PP_ArrayOutput& output,
+int32_t DirectoryReaderResource::GetNextEntry(
+    PP_DirectoryEntry_Dev* entry,
     scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(callback_))
     return PP_ERROR_INPROGRESS;
 
+  output_ = entry;
   callback_ = callback;
 
+  if (FillUpEntry())
+    return PP_OK;
+
   if (!sent_create_to_renderer())
     SendCreate(RENDERER, PpapiHostMsg_DirectoryReader_Create());
 
@@ -64,44 +59,61 @@ int32_t DirectoryReaderResource::ReadEntries(
       directory_resource_->host_resource());
   Call<PpapiPluginMsg_DirectoryReader_GetEntriesReply>(
       RENDERER, msg,
-      base::Bind(&DirectoryReaderResource::OnPluginMsgGetEntriesReply,
-                 this, output));
+      base::Bind(&DirectoryReaderResource::OnPluginMsgGetEntriesReply, this));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void DirectoryReaderResource::OnPluginMsgGetEntriesReply(
-    const PP_ArrayOutput& output,
     const ResourceMessageReplyParams& params,
     const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos,
     const std::vector<PP_FileType>& file_types) {
   CHECK_EQ(infos.size(), file_types.size());
+  did_receive_get_entries_reply_ = true;
 
-  std::vector<PP_DirectoryEntry_Dev> entries;
   for (std::vector<ppapi::PPB_FileRef_CreateInfo>::size_type i = 0;
        i < infos.size(); ++i) {
-    PP_DirectoryEntry_Dev entry;
-    entry.file_ref = PPB_FileRef_Proxy::DeserializeFileRef(infos[i]);
+    DirectoryEntry entry;
+    entry.file_resource = ScopedPPResource(
+        ScopedPPResource::PassRef(),
+        PPB_FileRef_Proxy::DeserializeFileRef(infos[i]));
     entry.file_type = file_types[i];
-    entries.push_back(entry);
+    entries_.push(entry);
   }
 
-  if (!TrackedCallback::IsPending(callback_)) {
-    ReleaseEntries(entries);
-    entries.clear();
+  if (!TrackedCallback::IsPending(callback_))
     return;
+
+  FillUpEntry();
+  callback_->Run(params.result());
+}
+
+bool DirectoryReaderResource::FillUpEntry() {
+  DCHECK(output_);
+
+  if (!did_receive_get_entries_reply_)
+    return false;
+
+  if (output_->file_ref) {
+    // Release an existing file reference before the next reference is stored.
+    // (see the API doc)
+    PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(
+        output_->file_ref);
   }
 
-  ArrayWriter writer(output);
-  if (!writer.is_valid()) {
-    ReleaseEntries(entries);
-    entries.clear();
-    callback_->Run(PP_ERROR_FAILED);
-    return;
+  if (!entries_.empty()) {
+    DirectoryEntry entry = entries_.front();
+    entries_.pop();
+    output_->file_ref = entry.file_resource.Release();
+    output_->file_type = entry.file_type;
+    output_ = NULL;
+    return true;
   }
 
-  writer.StoreVector(entries);
-  entries.clear();
-  callback_->Run(params.result());
+  // Set the reference to zero to indicates reaching the end of the directory.
+  output_->file_ref = 0;
+  output_->file_type = PP_FILETYPE_OTHER;
+  output_ = NULL;
+  return true;
 }
 
 }  // namespace proxy
diff --git a/ppapi/proxy/directory_reader_resource.h b/ppapi/proxy/directory_reader_resource.h
index e532414..b79993a 100644
--- a/ppapi/proxy/directory_reader_resource.h
+++ b/ppapi/proxy/directory_reader_resource.h
@@ -5,15 +5,16 @@
 #ifndef PPAPI_PROXY_DIRECTORY_READER_RESOURCE_H_
 #define PPAPI_PROXY_DIRECTORY_READER_RESOURCE_H_
 
+#include <queue>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_proxy_export.h"
-#include "ppapi/shared_impl/array_writer.h"
 #include "ppapi/shared_impl/ppb_file_ref_shared.h"
 #include "ppapi/shared_impl/resource.h"
+#include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/thunk/ppb_directory_reader_api.h"
 
 namespace ppapi {
@@ -35,18 +36,32 @@ class PPAPI_PROXY_EXPORT DirectoryReaderResource
   virtual thunk::PPB_DirectoryReader_API* AsPPB_DirectoryReader_API() OVERRIDE;
 
   // PPB_DirectoryReader_API.
-  virtual int32_t ReadEntries(
-      const PP_ArrayOutput& output,
+  virtual int32_t GetNextEntry(
+      PP_DirectoryEntry_Dev* entry,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
 
  private:
+  struct DirectoryEntry {
+    ScopedPPResource file_resource;
+    PP_FileType file_type;
+  };
+
   void OnPluginMsgGetEntriesReply(
-      const PP_ArrayOutput& output,
       const ResourceMessageReplyParams& params,
       const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos,
       const std::vector<PP_FileType>& file_types);
 
+  // Fills up an output with the next entry in the directory. If the plugin
+  // resource did not receive directory entries from the host side, returns
+  // false.
+  bool FillUpEntry();
+
   scoped_refptr<Resource> directory_resource_;
+  std::queue<DirectoryEntry> entries_;
+
+  PP_DirectoryEntry_Dev* output_;
+  bool did_receive_get_entries_reply_;
+
   scoped_refptr<TrackedCallback> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectoryReaderResource);