native_client_sdk/src/examples/api/file_io/file_io.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /// @file file_io.cc
   6 /// This example demonstrates the use of persistent file I/O
   7
   8 #define __STDC_LIMIT_MACROS
   9 #include <sstream>
  10 #include <string>
  11
  12 #include "ppapi/c/pp_stdint.h"
  13 #include "ppapi/c/ppb_file_io.h"
  14 #include "ppapi/cpp/directory_entry.h"
  15 #include "ppapi/cpp/file_io.h"
  16 #include "ppapi/cpp/file_ref.h"
  17 #include "ppapi/cpp/file_system.h"
  18 #include "ppapi/cpp/instance.h"
  19 #include "ppapi/cpp/message_loop.h"
  20 #include "ppapi/cpp/module.h"
  21 #include "ppapi/cpp/var.h"
  22 #include "ppapi/utility/completion_callback_factory.h"
  23 #include "ppapi/utility/threading/simple_thread.h"
  24
  25 #ifndef INT32_MAX
  26 #define INT32_MAX (0x7FFFFFFF)
  27 #endif
  28
  29 #ifdef WIN32
  30 #undef min
  31 #undef max
  32 #undef PostMessage
  33
  34 // Allow 'this' in initializer list
  35 #pragma warning(disable : 4355)
  36 #endif
  37
  38 namespace {
  39 /// Used for our simple protocol to communicate with Javascript
  40 const char* const kLoadPrefix = "ld";
  41 const char* const kSavePrefix = "sv";
  42 const char* const kDeletePrefix = "de";
  43 const char* const kListPrefix = "ls";
  44 const char* const kMakeDirPrefix = "md";
  45 }
  46
  47 /// The Instance class.  One of these exists for each instance of your NaCl
  48 /// module on the web page.  The browser will ask the Module object to create
  49 /// a new Instance for each occurrence of the <embed> tag that has these
  50 /// attributes:
  51 ///     type="application/x-nacl"
  52 ///     src="file_io.nmf"
  53 class FileIoInstance : public pp::Instance {
  54  public:
  55   /// The constructor creates the plugin-side instance.
  56   /// @param[in] instance the handle to the browser-side plugin instance.
  57   explicit FileIoInstance(PP_Instance instance)
  58       : pp::Instance(instance),
  59         callback_factory_(this),
  60         file_system_(this, PP_FILESYSTEMTYPE_LOCALPERSISTENT),
  61         file_system_ready_(false),
  62         file_thread_(this) {}
  63
  64   virtual ~FileIoInstance() { file_thread_.Join(); }
  65
  66   virtual bool Init(uint32_t /*argc*/,
  67                     const char * /*argn*/ [],
  68                     const char * /*argv*/ []) {
  69     file_thread_.Start();
  70     // Open the file system on the file_thread_. Since this is the first
  71     // operation we perform there, and because we do everything on the
  72     // file_thread_ synchronously, this ensures that the FileSystem is open
  73     // before any FileIO operations execute.
  74     file_thread_.message_loop().PostWork(
  75         callback_factory_.NewCallback(&FileIoInstance::OpenFileSystem));
  76     return true;
  77   }
  78
  79  private:
  80   pp::CompletionCallbackFactory<FileIoInstance> callback_factory_;
  81   pp::FileSystem file_system_;
  82
  83   // Indicates whether file_system_ was opened successfully. We only read/write
  84   // this on the file_thread_.
  85   bool file_system_ready_;
  86
  87   // We do all our file operations on the file_thread_.
  88   pp::SimpleThread file_thread_;
  89
  90   /// Handler for messages coming in from the browser via postMessage().  The
  91   /// @a var_message can contain anything: a JSON string; a string that encodes
  92   /// method names and arguments; etc.
  93   ///
  94   /// Here we use messages to communicate with the user interface
  95   ///
  96   /// @param[in] var_message The message posted by the browser.
  97   virtual void HandleMessage(const pp::Var& var_message) {
  98     if (!var_message.is_string())
  99       return;
 100
 101     // Parse message into: instruction file_name_length file_name [file_text]
 102     std::string message = var_message.AsString();
 103     std::string instruction;
 104     std::string file_name;
 105     std::stringstream reader(message);
 106     int file_name_length;
 107
 108     reader >> instruction >> file_name_length;
 109     file_name.resize(file_name_length);
 110     reader.ignore(1);  // Eat the delimiter
 111     reader.read(&file_name[0], file_name_length);
 112
 113     if (file_name.length() == 0 || file_name[0] != '/') {
 114       ShowStatusMessage("File name must begin with /");
 115       return;
 116     }
 117
 118     // Dispatch the instruction
 119     if (instruction == kLoadPrefix) {
 120       file_thread_.message_loop().PostWork(
 121           callback_factory_.NewCallback(&FileIoInstance::Load, file_name));
 122     } else if (instruction == kSavePrefix) {
 123       // Read the rest of the message as the file text
 124       reader.ignore(1);  // Eat the delimiter
 125       std::string file_text = message.substr(reader.tellg());
 126       file_thread_.message_loop().PostWork(callback_factory_.NewCallback(
 127           &FileIoInstance::Save, file_name, file_text));
 128     } else if (instruction == kDeletePrefix) {
 129       file_thread_.message_loop().PostWork(
 130           callback_factory_.NewCallback(&FileIoInstance::Delete, file_name));
 131     } else if (instruction == kListPrefix) {
 132       const std::string& dir_name = file_name;
 133       file_thread_.message_loop().PostWork(
 134           callback_factory_.NewCallback(&FileIoInstance::List, dir_name));
 135     } else if (instruction == kMakeDirPrefix) {
 136       const std::string& dir_name = file_name;
 137       file_thread_.message_loop().PostWork(
 138           callback_factory_.NewCallback(&FileIoInstance::MakeDir, dir_name));
 139     }
 140   }
 141
 142   void OpenFileSystem(int32_t /* result */) {
 143     int32_t rv = file_system_.Open(1024 * 1024, pp::BlockUntilComplete());
 144     if (rv == PP_OK) {
 145       file_system_ready_ = true;
 146       // Notify the user interface that we're ready
 147       PostMessage("READY|");
 148     } else {
 149       ShowErrorMessage("Failed to open file system", rv);
 150     }
 151   }
 152
 153   void Save(int32_t /* result */,
 154             const std::string& file_name,
 155             const std::string& file_contents) {
 156     if (!file_system_ready_) {
 157       ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
 158       return;
 159     }
 160     pp::FileRef ref(file_system_, file_name.c_str());
 161     pp::FileIO file(this);
 162
 163     int32_t open_result =
 164         file.Open(ref,
 165                   PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE |
 166                       PP_FILEOPENFLAG_TRUNCATE,
 167                   pp::BlockUntilComplete());
 168     if (open_result != PP_OK) {
 169       ShowErrorMessage("File open for write failed", open_result);
 170       return;
 171     }
 172
 173     // We have truncated the file to 0 bytes. So we need only write if
 174     // file_contents is non-empty.
 175     if (!file_contents.empty()) {
 176       if (file_contents.length() > INT32_MAX) {
 177         ShowErrorMessage("File too big", PP_ERROR_FILETOOBIG);
 178         return;
 179       }
 180       int64_t offset = 0;
 181       int32_t bytes_written = 0;
 182       do {
 183         bytes_written = file.Write(offset,
 184                                    file_contents.data() + offset,
 185                                    file_contents.length(),
 186                                    pp::BlockUntilComplete());
 187         if (bytes_written > 0) {
 188           offset += bytes_written;
 189         } else {
 190           ShowErrorMessage("File write failed", bytes_written);
 191           return;
 192         }
 193       } while (bytes_written < static_cast<int64_t>(file_contents.length()));
 194     }
 195     // All bytes have been written, flush the write buffer to complete
 196     int32_t flush_result = file.Flush(pp::BlockUntilComplete());
 197     if (flush_result != PP_OK) {
 198       ShowErrorMessage("File fail to flush", flush_result);
 199       return;
 200     }
 201     ShowStatusMessage("Save success");
 202   }
 203
 204   void Load(int32_t /* result */, const std::string& file_name) {
 205     if (!file_system_ready_) {
 206       ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
 207       return;
 208     }
 209     pp::FileRef ref(file_system_, file_name.c_str());
 210     pp::FileIO file(this);
 211
 212     int32_t open_result =
 213         file.Open(ref, PP_FILEOPENFLAG_READ, pp::BlockUntilComplete());
 214     if (open_result == PP_ERROR_FILENOTFOUND) {
 215       ShowErrorMessage("File not found", open_result);
 216       return;
 217     } else if (open_result != PP_OK) {
 218       ShowErrorMessage("File open for read failed", open_result);
 219       return;
 220     }
 221     PP_FileInfo info;
 222     int32_t query_result = file.Query(&info, pp::BlockUntilComplete());
 223     if (query_result != PP_OK) {
 224       ShowErrorMessage("File query failed", query_result);
 225       return;
 226     }
 227     // FileIO.Read() can only handle int32 sizes
 228     if (info.size > INT32_MAX) {
 229       ShowErrorMessage("File too big", PP_ERROR_FILETOOBIG);
 230       return;
 231     }
 232
 233     std::vector<char> data(info.size);
 234     int64_t offset = 0;
 235     int32_t bytes_read = 0;
 236     int32_t bytes_to_read = info.size;
 237     while (bytes_to_read > 0) {
 238       bytes_read = file.Read(offset,
 239                              &data[offset],
 240                              data.size() - offset,
 241                              pp::BlockUntilComplete());
 242       if (bytes_read > 0) {
 243         offset += bytes_read;
 244         bytes_to_read -= bytes_read;
 245       } else if (bytes_read < 0) {
 246         // If bytes_read < PP_OK then it indicates the error code.
 247         ShowErrorMessage("File read failed", bytes_read);
 248         return;
 249       }
 250     }
 251     // Done reading, send content to the user interface
 252     std::string string_data(data.begin(), data.end());
 253     PostMessage("DISP|" + string_data);
 254     ShowStatusMessage("Load success");
 255   }
 256
 257   void Delete(int32_t /* result */, const std::string& file_name) {
 258     if (!file_system_ready_) {
 259       ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
 260       return;
 261     }
 262     pp::FileRef ref(file_system_, file_name.c_str());
 263
 264     int32_t result = ref.Delete(pp::BlockUntilComplete());
 265     if (result == PP_ERROR_FILENOTFOUND) {
 266       ShowStatusMessage("File/Directory not found");
 267       return;
 268     } else if (result != PP_OK) {
 269       ShowErrorMessage("Deletion failed", result);
 270       return;
 271     }
 272     ShowStatusMessage("Delete success");
 273   }
 274
 275   void List(int32_t /* result */, const std::string& dir_name) {
 276     if (!file_system_ready_) {
 277       ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
 278       return;
 279     }
 280
 281     pp::FileRef ref(file_system_, dir_name.c_str());
 282
 283     // Pass ref along to keep it alive.
 284     ref.ReadDirectoryEntries(callback_factory_.NewCallbackWithOutput(
 285         &FileIoInstance::ListCallback, ref));
 286   }
 287
 288   void ListCallback(int32_t result,
 289                     const std::vector<pp::DirectoryEntry>& entries,
 290                     pp::FileRef /* unused_ref */) {
 291     if (result != PP_OK) {
 292       ShowErrorMessage("List failed", result);
 293       return;
 294     }
 295
 296     std::stringstream ss;
 297     ss << "LIST";
 298     for (size_t i = 0; i < entries.size(); ++i) {
 299       pp::Var name = entries[i].file_ref().GetName();
 300       if (name.is_string()) {
 301         ss << "|" << name.AsString();
 302       }
 303     }
 304     PostMessage(ss.str());
 305     ShowStatusMessage("List success");
 306   }
 307
 308   void MakeDir(int32_t /* result */, const std::string& dir_name) {
 309     if (!file_system_ready_) {
 310       ShowErrorMessage("File system is not open", PP_ERROR_FAILED);
 311       return;
 312     }
 313     pp::FileRef ref(file_system_, dir_name.c_str());
 314
 315     int32_t result = ref.MakeDirectory(
 316         PP_MAKEDIRECTORYFLAG_NONE, pp::BlockUntilComplete());
 317     if (result != PP_OK) {
 318       ShowErrorMessage("Make directory failed", result);
 319       return;
 320     }
 321     ShowStatusMessage("Make directory success");
 322   }
 323
 324   /// Encapsulates our simple javascript communication protocol
 325   void ShowErrorMessage(const std::string& message, int32_t result) {
 326     std::stringstream ss;
 327     ss << "ERR|" << message << " -- Error #: " << result;
 328     PostMessage(ss.str());
 329   }
 330
 331   /// Encapsulates our simple javascript communication protocol
 332   void ShowStatusMessage(const std::string& message) {
 333     std::stringstream ss;
 334     ss << "STAT|" << message;
 335     PostMessage(ss.str());
 336   }
 337 };
 338
 339 /// The Module class.  The browser calls the CreateInstance() method to create
 340 /// an instance of your NaCl module on the web page.  The browser creates a new
 341 /// instance for each <embed> tag with type="application/x-nacl".
 342 class FileIoModule : public pp::Module {
 343  public:
 344   FileIoModule() : pp::Module() {}
 345   virtual ~FileIoModule() {}
 346
 347   /// Create and return a FileIoInstance object.
 348   /// @param[in] instance The browser-side instance.
 349   /// @return the plugin-side instance.
 350   virtual pp::Instance* CreateInstance(PP_Instance instance) {
 351     return new FileIoInstance(instance);
 352   }
 353 };
 354
 355 namespace pp {
 356 /// Factory function called by the browser when the module is first loaded.
 357 /// The browser keeps a singleton of this module.  It calls the
 358 /// CreateInstance() method on the object you return to make instances.  There
 359 /// is one instance per <embed> tag on the page.  This is the main binding
 360 /// point for your NaCl module with the browser.
 361 Module* CreateModule() { return new FileIoModule(); }
 362 }  // namespace pp