Add support for loading pak files from arbitrary file regions.

base/files/file.cc

 // Copyright (c) 2011 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 "base/files/file.h"
 #include "base/files/file_path.h"
 
 namespace base {
 
 File::Info::Info()
     : size(0),
       is_directory(false),
       is_symbolic_link(false) {
 }
 
 File::Info::~Info() {
 }
 
+File::Region::Region(int64 offset, int64 size) : offset(offset), size(size) {
+  DCHECK_GE(offset, 0);
+  DCHECK_GE(size, 0);
+}
+
+File::Region::~Region() {
+}
+
+bool File::Region::IsWholeFile() const {

[willchan no longer on Chromium, 2014/07/21 23:55:40]

Hmmm...what happens when |size| == the length of the whole file, which is less
than std::numeric_limits<int64>::max()?

[Primiano Tucci (use gerrit), 2014/07/22 10:32:01]

Good point, let me spend one minute to explain the rationale behind all this. If
you think to this end-to-end, there are two ways you can map fully a file on
Windows: MapViewOfFile(length=0, ...) and MVOF(length=file.size).
Now, from a conceptual viewpoint the two variants should behave in the same way.
On the other side, I'm an extremely paranoid person (especially when it comes to
changes to base::) and I won't be surprised if some tiny corner case would hide
behind this.

In the very essence all this is a way to make it so that the existing code paths
in chromium, which before this change did only MVOF(length=0, ...), keep passing
length=0 at the end of their journey.

In more concrete words:
IsWholeFile() == true -->  MVOF(length=0)  # Make this change behave as a noop
end-to-end
IsWholeFile() == false -->  MVOF(length=~region.length)

Essentially, the way I intended IsWholeFile, is whether the caller expresses the
desire of an old-style full-cover mmap/MVOF to preserve the same exact current
behavior.

[willchan no longer on Chromium, 2014/07/22 20:45:47]

We chatted about this offline. Primiano explained that the reason for doing this
is to provide an API for mapping an entire file. We're going to try to achieve
this by replacing the accessor with a constant, something like
Region::kWholeFile. This will remove the confusion around the edge cases I
described.

+  return offset == 0 && size == std::numeric_limits<int64>::max();
+}
+
+// static
+File::Region File::Region::WholeFile() {
+  return File::Region(0, std::numeric_limits<int64>::max());
+}
+
 File::File()
     : error_details_(FILE_ERROR_FAILED),
       created_(false),
       async_(false) {
 }
 
 #if !defined(OS_NACL)
 File::File(const FilePath& name, uint32 flags)
     : error_details_(FILE_OK),
       created_(false),
@@ skipping 89 matching lines @@
       return "FILE_ERROR_IO";
     case FILE_ERROR_MAX:
       break;
   }
 
   NOTREACHED();
   return "";
 }
 
 }  // namespace base