[NaCl SDK] Add URLLoader fake pepper interface.

native_client_sdk/src/libraries/nacl_io/mount_node_http.cc

 // Copyright (c) 2013 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 "nacl_io/mount_node_http.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 133 matching lines @@
   return EIO;
 }
 
 }  // namespace
 
 void MountNodeHttp::SetCachedSize(off_t size) {
   has_cached_size_ = true;
   stat_.st_size = size;
 }
 
-Error MountNodeHttp::FSync() { return ENOSYS; }
+Error MountNodeHttp::FSync() { return EACCES; }
 
 Error MountNodeHttp::GetDents(size_t offs,
                               struct dirent* pdir,
                               size_t count,
                               int* out_bytes) {
   *out_bytes = 0;
-  return ENOSYS;
+  return EACCES;
 }
 
 Error MountNodeHttp::GetStat(struct stat* stat) {
   AUTO_LOCK(node_lock_);
 
   // Assume we need to 'HEAD' if we do not know the size, otherwise, assume
   // that the information is constant.  We can add a timeout if needed.
   MountHttp* mount = static_cast<MountHttp*>(mount_);
   if (stat_.st_size == 0 || !mount->cache_stat_) {
     StringMap_t headers;
@@ skipping 14 matching lines @@
 
     ScopedResource scoped_loader(mount_->ppapi(), loader);
     ScopedResource scoped_request(mount_->ppapi(), request);
     ScopedResource scoped_response(mount_->ppapi(), response);
 
     size_t entity_length;
     if (ParseContentLength(response_headers, &entity_length)) {
       SetCachedSize(static_cast<off_t>(entity_length));
     } else if (cache_content_ && !has_cached_size_) {
       error = DownloadToCache();
-      // TODO(binji): this error should not be dropped, but it requires a bit
-      // of a refactor of the tests. See crbug.com/245431
-      // if (error)
-      //   return error;
+      if (error)
+        return error;
     } else {
       // Don't use SetCachedSize here -- it is actually unknown.
       stat_.st_size = 0;
     }
 
     stat_.st_atime = 0;  // TODO(binji): Use "Last-Modified".
     stat_.st_mtime = 0;
     stat_.st_ctime = 0;
 
     stat_.st_mode |= S_IFREG;
@@ skipping 19 matching lines @@
       if (error)
         return error;
     }
 
     return ReadPartialFromCache(attr.offs, buf, count, out_bytes);
   }
 
   return DownloadPartial(attr.offs, buf, count, out_bytes);
 }
 
-Error MountNodeHttp::FTruncate(off_t size) { return ENOSYS; }
+Error MountNodeHttp::FTruncate(off_t size) { return EACCES; }
 
 Error MountNodeHttp::Write(const HandleAttr& attr,
                            const void* buf,
                            size_t count,
                            int* out_bytes) {
   // TODO(binji): support POST?
   *out_bytes = 0;
-  return ENOSYS;
+  return EACCES;
 }
 
 Error MountNodeHttp::GetSize(size_t* out_size) {
   *out_size = 0;
 
   // TODO(binji): This value should be cached properly; i.e. obey the caching
   // headers returned by the server.
   AUTO_LOCK(node_lock_);
   if (!has_cached_size_) {
     // Even if DownloadToCache fails, the best result we can return is what
@@ skipping 77 matching lines @@
   uint32_t response_headers_length;
   const char* response_headers_str =
       var_interface->VarToUtf8(response_headers_var, &response_headers_length);
 
   *out_loader = loader.Release();
   *out_request = request.Release();
   *out_response = response.Release();
   *out_response_headers =
       ParseHeaders(response_headers_str, response_headers_length);
 
+  var_interface->Release(response_headers_var);
+
   return 0;
 }
 
 Error MountNodeHttp::DownloadToCache() {
   StringMap_t headers;
   PP_Resource loader;
   PP_Resource request;
   PP_Resource response;
   int32_t statuscode;
   StringMap_t response_headers;
@@ skipping 47 matching lines @@
 
     cached_data_.resize(total_bytes_read + bytes_to_read);
   }
 }
 
 Error MountNodeHttp::ReadPartialFromCache(size_t offs,
                                           void* buf,
                                           int count,
                                           int* out_bytes) {
   *out_bytes = 0;
+  size_t size = cached_data_.size();
 
-  if (offs > cached_data_.size())
-    return EINVAL;
+  if (offs + count > size)
+    count = size - offs;

[Sam Clegg, 2013/11/20 20:00:54]

So this function can no longer fail?  Might be worth changing
the signature accordingly.

Can you explain this part of the change a bit?

[binji, 2013/11/20 20:34:17]

Hm. I like that it has the same signature as the rest of the read functions
(actually, it should probably change to use HandleAttr instead of offset...)
It was a bug that it was failing at all. It is not an error to read past the end
of the data, you should just get 0 bytes read.

 
-  count = std::min(count, static_cast<int>(cached_data_.size() - offs));
+  if (count <= 0)
+    return 0;
+
   memcpy(buf, &cached_data_.data()[offs], count);
-
   *out_bytes = count;
   return 0;
 }
 
 Error MountNodeHttp::DownloadPartial(size_t offs,
                                      void* buf,
                                      size_t count,
                                      int* out_bytes) {
   *out_bytes = 0;
 
@@ skipping 113 matching lines @@
     bytes_to_read -= bytes_read;
     out_buffer += bytes_read;
   }
 
   *out_bytes = count;
   return 0;
 }
 
 }  // namespace nacl_io