[NaCl SDK] Modifying size_t and int to off_t.

native_client_sdk/src/libraries/nacl_io/httpfs/http_fs_node.cc

 // Copyright 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/httpfs/http_fs_node.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 65 matching lines @@
           start = &headers[i + 1];
           state = FINDING_KEY;
         }
         break;
     }
   }
 
   return result;
 }
 
-bool ParseContentLength(const StringMap_t& headers, size_t* content_length) {
+bool ParseContentLength(const StringMap_t& headers, off_t* content_length) {
   StringMap_t::const_iterator iter = headers.find("Content-Length");
   if (iter == headers.end())
     return false;
 
-  *content_length = strtoul(iter->second.c_str(), NULL, 10);
+  *content_length = strtoull(iter->second.c_str(), NULL, 10);
   return true;
 }
 
 bool ParseContentRange(const StringMap_t& headers,
-                       size_t* read_start,
-                       size_t* read_end,
-                       size_t* entity_length) {
+                       off_t* read_start,
+                       off_t* read_end,
+                       off_t* entity_length) {
   StringMap_t::const_iterator iter = headers.find("Content-Range");
   if (iter == headers.end())
     return false;
 
   // The key should look like "bytes ##-##/##" or "bytes ##-##/*". The last
   // value is the entity length, which can potentially be * (i.e. unknown).
-  size_t read_start_int;
-  size_t read_end_int;
-  size_t entity_length_int;
+  off_t read_start_int;
+  off_t read_end_int;
+  off_t entity_length_int;
   int result = sscanf(iter->second.c_str(),
-                      "bytes %" SCNuS "-%" SCNuS "/%" SCNuS,
+                      "bytes %" SCNi64 "-%" SCNi64 "/%" SCNi64,
                       &read_start_int,
                       &read_end_int,
                       &entity_length_int);
 
   // The Content-Range header specifies an inclusive range: e.g. the first ten
   // bytes is "bytes 0-9/*". Convert it to a half-open range by incrementing
   // read_end.
   if (result == 2) {
     *read_start = read_start_int;
     *read_end = read_end_int + 1;
@@ skipping 71 matching lines @@
 
 Error HttpFsNode::Write(const HandleAttr& attr,
                         const void* buf,
                         size_t count,
                         int* out_bytes) {
   // TODO(binji): support POST?
   *out_bytes = 0;
   return EACCES;
 }
 
-Error HttpFsNode::GetSize(size_t* out_size) {
+Error HttpFsNode::GetSize(off_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_);
   struct stat statbuf;
   Error error = GetStat_Locked(&statbuf);
   if (error)
     return error;
 
@@ skipping 25 matching lines @@
     Error error = OpenUrl("HEAD",
                           &headers,
                           &loader,
                           &request,
                           &response,
                           &statuscode,
                           &response_headers);
     if (error)
       return error;
 
-    size_t entity_length;
+    off_t entity_length;
     if (ParseContentLength(response_headers, &entity_length)) {
       SetCachedSize(static_cast<off_t>(entity_length));
     } else if (cache_content_) {
       // The server didn't give a content length; download the data to memory
       // via DownloadToCache, which will also set stat_.st_size;
       error = DownloadToCache();
       if (error)
         return error;
     } else {
       // The user doesn't want to cache content, but we didn't get a
       // "Content-Length" header. Read the entire entity, and throw it away.
       // Don't use DownloadToCache, as that will still allocate enough memory
       // for the entire entity.
-      int bytes_read;
+      off_t bytes_read;
       error = DownloadToTemp(&bytes_read);
       if (error)
         return error;
 
       SetCachedSize(bytes_read);
     }
 
     stat_.st_atime = 0;  // TODO(binji): Use "Last-Modified".
     stat_.st_mtime = 0;
     stat_.st_ctime = 0;
@@ skipping 88 matching lines @@
   Error error = OpenUrl("GET",
                         &headers,
                         &loader,
                         &request,
                         &response,
                         &statuscode,
                         &response_headers);
   if (error)
     return error;
 
-  size_t content_length = 0;
+  off_t content_length = 0;
   if (ParseContentLength(response_headers, &content_length)) {
     cached_data_.resize(content_length);
     int real_size;
     error = ReadResponseToBuffer(
         loader, cached_data_.data(), content_length, &real_size);
     if (error)
       return error;
 
     SetCachedSize(real_size);
     cached_data_.resize(real_size);
     return 0;
   }
 
   int bytes_read;
   error = ReadEntireResponseToCache(loader, &bytes_read);
   if (error)
     return error;
 
   SetCachedSize(bytes_read);
   return 0;
 }
 
 Error HttpFsNode::ReadPartialFromCache(const HandleAttr& attr,
                                        void* buf,
                                        int count,
                                        int* out_bytes) {
   *out_bytes = 0;
-  size_t size = cached_data_.size();
+  off_t size = cached_data_.size();
 
   if (attr.offs + count > size)
     count = size - attr.offs;
 
   if (count <= 0)
     return 0;
 
   memcpy(buf, &cached_data_.data()[attr.offs], count);
   *out_bytes = count;
   return 0;
 }
 
 Error HttpFsNode::DownloadPartial(const HandleAttr& attr,
                                   void* buf,
-                                  size_t count,
+                                  off_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,
+           "bytes=%" PRIi64 "-%" PRIi64,
            attr.offs,
            attr.offs + count - 1);
   headers["Range"] = buffer;
 
   ScopedResource loader(filesystem_->ppapi());
   ScopedResource request(filesystem_->ppapi());
   ScopedResource response(filesystem_->ppapi());
   int32_t statuscode;
   StringMap_t response_headers;
   Error error = OpenUrl("GET",
                         &headers,
                         &loader,
                         &request,
                         &response,
                         &statuscode,
                         &response_headers);
   if (error) {
     if (statuscode == STATUSCODE_REQUESTED_RANGE_NOT_SATISFIABLE) {
       // We're likely trying to read past the end. Return 0 bytes.
       *out_bytes = 0;
       return 0;
     }
 
     return error;
   }
 
-  size_t read_start = 0;
+  off_t read_start = 0;
   if (statuscode == STATUSCODE_OK) {
     // No partial result, read everything starting from the part we care about.
-    size_t content_length;
+    off_t content_length;
     if (ParseContentLength(response_headers, &content_length)) {
       if (attr.offs >= content_length)
         return EINVAL;
 
       // Clamp count, if trying to read past the end of the file.
       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;
+    off_t read_end;
+    off_t entity_length;
     if (ParseContentRange(
             response_headers, &read_start, &read_end, &entity_length)) {
       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 {
@@ skipping 17 matching lines @@
     // Tried to read past the end of the entity.
     if (bytes_read < bytes_to_read) {
       *out_bytes = 0;
       return 0;
     }
   }
 
   return ReadResponseToBuffer(loader, buf, count, out_bytes);
 }
 
-Error HttpFsNode::DownloadToTemp(int* out_bytes) {
+Error HttpFsNode::DownloadToTemp(off_t* out_bytes) {
   StringMap_t headers;
   ScopedResource loader(filesystem_->ppapi());
   ScopedResource request(filesystem_->ppapi());
   ScopedResource response(filesystem_->ppapi());
   int32_t statuscode;
   StringMap_t response_headers;
   Error error = OpenUrl("GET",
                         &headers,
                         &loader,
                         &request,
                         &response,
                         &statuscode,
                         &response_headers);
   if (error)
     return error;
 
-  size_t content_length = 0;
+  off_t content_length = 0;
   if (ParseContentLength(response_headers, &content_length)) {
     *out_bytes = content_length;
     return 0;
   }
 
   return ReadEntireResponseToTemp(loader, out_bytes);
 }
 
 Error HttpFsNode::ReadEntireResponseToTemp(const ScopedResource& loader,
-                                           int* out_bytes) {
+                                           off_t* out_bytes) {
   *out_bytes = 0;
 
   const int kBytesToRead = MAX_READ_BUFFER_SIZE;
   buffer_.resize(kBytesToRead);
 
   while (true) {
     int bytes_read;
     Error error =
         ReadResponseToBuffer(loader, buffer_.data(), kBytesToRead, &bytes_read);
     if (error)
@@ skipping 91 matching lines @@
     assert(bytes_read <= bytes_to_read);
     bytes_to_read -= bytes_read;
     out_buffer += bytes_read;
   }
 
   *out_bytes = count;
   return 0;
 }
 
 }  // namespace nacl_io