[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 13 matching lines @@
   *out_bytes = 0;
 
   AUTO_LOCK(node_lock_);
   if (cache_content_) {
     if (cached_data_.empty()) {
       Error error = DownloadToCache();
       if (error)
         return error;
     }
 
-    return ReadPartialFromCache(attr.offs, buf, count, out_bytes);
+    return ReadPartialFromCache(attr, buf, count, out_bytes);
   }
 
-  return DownloadPartial(attr.offs, buf, count, out_bytes);
+  return DownloadPartial(attr, 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 42 matching lines @@
     if (bytes_read < bytes_to_read) {
       SetCachedSize(total_bytes_read);
       cached_data_.resize(total_bytes_read);
       return 0;
     }
 
     cached_data_.resize(total_bytes_read + bytes_to_read);
   }
 }
 
-Error MountNodeHttp::ReadPartialFromCache(size_t offs,
+Error MountNodeHttp::ReadPartialFromCache(const HandleAttr& attr,
                                           void* buf,
                                           int count,
                                           int* out_bytes) {
   *out_bytes = 0;
+  size_t size = cached_data_.size();
 
-  if (offs > cached_data_.size())
-    return EINVAL;
+  if (attr.offs + count > size)
+    count = size - attr.offs;
 
-  count = std::min(count, static_cast<int>(cached_data_.size() - offs));
-  memcpy(buf, &cached_data_.data()[offs], count);
+  if (count <= 0)
+    return 0;
 
+  memcpy(buf, &cached_data_.data()[attr.offs], count);
   *out_bytes = count;
   return 0;
 }
 
-Error MountNodeHttp::DownloadPartial(size_t offs,
+Error MountNodeHttp::DownloadPartial(const HandleAttr& attr,
                                      void* buf,
                                      size_t count,
                                      int* out_bytes) {
   *out_bytes = 0;
 
   StringMap_t headers;
 
   char buffer[100];
   // Range request is inclusive: 0-99 returns 100 bytes.
   snprintf(&buffer[0],
            sizeof(buffer),
            "bytes=%" PRIuS "-%" PRIuS,
-           offs,
-           offs + count - 1);
+           attr.offs,
+           attr.offs + count - 1);
   headers["Range"] = buffer;
 
   PP_Resource loader;
   PP_Resource request;
   PP_Resource response;
   int32_t statuscode;
   StringMap_t response_headers;
   Error error = OpenUrl("GET",
                         &headers,
                         &loader,
                         &request,
                         &response,
                         &statuscode,
                         &response_headers);
   if (error)
     return error;
 
   PepperInterface* ppapi = mount_->ppapi();
   ScopedResource scoped_loader(ppapi, loader);
   ScopedResource scoped_request(ppapi, request);
   ScopedResource scoped_response(ppapi, response);
 
   size_t read_start = 0;
   if (statuscode == STATUSCODE_OK) {
     // No partial result, read everything starting from the part we care about.
     size_t content_length;
     if (ParseContentLength(response_headers, &content_length)) {
-      if (offs >= content_length)
+      if (attr.offs >= content_length)
         return EINVAL;
 
       // Clamp count, if trying to read past the end of the file.
-      if (offs + count > content_length) {
-        count = content_length - offs;
+      if (attr.offs + count > content_length) {
+        count = content_length - attr.offs;
       }
     }
   } else if (statuscode == STATUSCODE_PARTIAL_CONTENT) {
     // Determine from the headers where we are reading.
     size_t read_end;
     size_t entity_length;
     if (ParseContentRange(
             response_headers, &read_start, &read_end, &entity_length)) {
-      if (read_start > offs || read_start > read_end) {
+      if (read_start > attr.offs || read_start > read_end) {
         // If this error occurs, the server is returning bogus values.
         return EINVAL;
       }
 
       // Clamp count, if trying to read past the end of the file.
       count = std::min(read_end - read_start, count);
     } else {
       // Partial Content without Content-Range. Assume that the server gave us
       // exactly what we asked for. This can happen even when the server
       // returns 200 -- the cache may return 206 in this case, but not modify
       // the headers.
-      read_start = offs;
+      read_start = attr.offs;
     }
   }
 
-  if (read_start < offs) {
+  if (read_start < attr.offs) {
     // We aren't yet at the location where we want to start reading. Read into
     // our dummy buffer until then.
-    size_t bytes_to_read = offs - read_start;
+    size_t bytes_to_read = attr.offs - read_start;
     if (buffer_.size() < bytes_to_read)
       buffer_.resize(std::min(bytes_to_read, MAX_READ_BUFFER_SIZE));
 
     while (bytes_to_read > 0) {
       int32_t bytes_read;
       Error error =
           DownloadToBuffer(loader, buffer_.data(), buffer_.size(), &bytes_read);
       if (error)
         return error;
 
@@ skipping 33 matching lines @@
     bytes_to_read -= bytes_read;
     out_buffer += bytes_read;
   }
 
   *out_bytes = count;
   return 0;
 }
 
 }  // namespace nacl_io