Add directory_entry.cc to libppapi_cpp

native_client_sdk/src/examples/api/file_io/file_io.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.
 
 /// @file file_io.cc
 /// This example demonstrates the use of persistent file I/O
 
 #define __STDC_LIMIT_MACROS
 #include <sstream>
 #include <string>
 
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/c/ppb_file_io.h"
+#include "ppapi/cpp/directory_entry.h"
 #include "ppapi/cpp/file_io.h"
 #include "ppapi/cpp/file_ref.h"
 #include "ppapi/cpp/file_system.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/message_loop.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/utility/completion_callback_factory.h"
 #include "ppapi/utility/threading/simple_thread.h"
 
 #ifndef INT32_MAX
 #define INT32_MAX (0x7FFFFFFF)
 #endif
 
 #ifdef WIN32
 #undef min
 #undef max
 #undef PostMessage
 
 // Allow 'this' in initializer list
 #pragma warning(disable : 4355)
 #endif
 
 namespace {
 /// Used for our simple protocol to communicate with Javascript
 const char* const kLoadPrefix = "ld";
 const char* const kSavePrefix = "sv";
 const char* const kDeletePrefix = "de";
+const char* const kListPrefix = "ls";
 }
 
 /// The Instance class.  One of these exists for each instance of your NaCl
 /// module on the web page.  The browser will ask the Module object to create
 /// a new Instance for each occurrence of the <embed> tag that has these
 /// attributes:
 ///     type="application/x-nacl"
 ///     src="file_io.nmf"
 class FileIoInstance : public pp::Instance {
  public:
@@ skipping 74 matching lines @@
       file_thread_.message_loop().PostWork(callback_factory_.NewCallback(
           &FileIoInstance::Save, file_name, file_text));
       return;
     }
 
     if (instruction.compare(kDeletePrefix) == 0) {
       file_thread_.message_loop().PostWork(
           callback_factory_.NewCallback(&FileIoInstance::Delete, file_name));
       return;
     }
+
+    if (instruction.compare(kListPrefix) == 0) {
+      const std::string& dir_name = file_name;
+      file_thread_.message_loop().PostWork(
+          callback_factory_.NewCallback(&FileIoInstance::List, dir_name));
+      return;
+    }
   }
 
   void OpenFileSystem(int32_t /* result */) {
     int32_t rv = file_system_.Open(1024 * 1024, pp::CompletionCallback());
     if (rv == PP_OK) {
       file_system_ready_ = true;
       // Notify the user interface that we're ready
       PostMessage(pp::Var("READY|"));
     } else {
       ShowErrorMessage("Failed to open file system", rv);
@@ skipping 114 matching lines @@
     if (result == PP_ERROR_FILENOTFOUND) {
       ShowStatusMessage("File not found");
       return;
     } else if (result != PP_OK) {
       ShowErrorMessage("Deletion failed", result);
       return;
     }
     ShowStatusMessage("File deleted");
   }
 
+  void List(int32_t /* result */, const std::string& dir_name) {
+    if (!file_system_ready_) {
+      ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
+      return;
+    }
+    pp::FileRef ref(file_system_, dir_name.c_str());
+
+    // Pass ref along to keep it alive.
+    ref.ReadDirectoryEntries(callback_factory_.NewCallbackWithOutput(
+        &FileIoInstance::ListCallback, ref));
+  }
+
+  void ListCallback(int32_t result,
+                    const std::vector<pp::DirectoryEntry>& entries,
+                    pp::FileRef /* unused_ref */) {
+    if (result != PP_OK) {
+      ShowErrorMessage("List failed", result);
+      return;
+    }
+
+    std::string buffer = "File list:";
+    for (size_t i = 0; i < entries.size(); ++i) {
+      pp::Var name = entries[i].file_ref().GetName();
+      if (name.is_string())
+        buffer += " " + name.AsString();
+    }
+    ShowStatusMessage(buffer);
+  }
+
   /// Encapsulates our simple javascript communication protocol
   void ShowErrorMessage(const std::string& message, int32_t result) {
     std::stringstream ss;
     ss << "ERR|" << message << " -- Error #: " << result;
     PostMessage(pp::Var(ss.str()));
   }
 
   /// Encapsulates our simple javascript communication protocol
   void ShowStatusMessage(const std::string& message) {
     std::stringstream ss;
@@ skipping 19 matching lines @@
 };
 
 namespace pp {
 /// Factory function called by the browser when the module is first loaded.
 /// The browser keeps a singleton of this module.  It calls the
 /// CreateInstance() method on the object you return to make instances.  There
 /// is one instance per <embed> tag on the page.  This is the main binding
 /// point for your NaCl module with the browser.
 Module* CreateModule() { return new FileIoModule(); }
 }  // namespace pp