Only support seeking file streams from the beginning of the file.

net/base/file_stream_context_win.cc

 // Copyright (c) 2012 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 "net/base/file_stream_context.h"
 
 #include <windows.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 96 matching lines @@
       IOCompletionIsPending(callback, buf);
     else
       LOG(WARNING) << "WriteFile failed: " << error.os_error;
     return static_cast<int>(error.result);
   }
 
   IOCompletionIsPending(callback, buf);
   return ERR_IO_PENDING;
 }
 
-FileStream::Context::IOResult FileStream::Context::SeekFileImpl(
-    base::File::Whence whence,
-    int64 offset) {
+FileStream::Context::IOResult FileStream::Context::SeekFileImpl(int64 offset) {

[davidben, 2015/05/21 17:22:12]

If I'm understanding this correctly, not calling seek on the underlying
base::File only works because we always use overlapped IO, correct? This seems
to be correct, but it's probably worth a comment to this effect and why we're
not seeking the file.

There is a file() accessor to FileStream::Context which would be sensitive to
this. If we're relying on it, probably best to not leak that method. It's only
used to implement FileStream::IsOpen and FileStream::GetFileForTesting, which is
only used to assert on things redundant with asserting on IsOpen. Perhaps
replace both of those with FileStream::Context::IsOpen. That way we can be sure
that the base::File doesn't leak.

Actually, does this work if the file doesn't support overlapped IO? Is that
meaningful? This seems to suggest it matters whether the file was opened for
overlapped IO? Though if it wasn't, presumably we'd have problems with doing
disk on the IO thread. I see line 65 has a TODO to check it... perhaps checking
that file_.async() is true is sufficient?

https://msdn.microsoft.com/en-us/library/windows/desktop/aa365747%28v=vs.85%2...

   LARGE_INTEGER result;
-  result.QuadPart = file_.Seek(whence, offset);
-  if (result.QuadPart >= 0) {
-    SetOffset(&io_context_.overlapped, result);
-    return IOResult(result.QuadPart, 0);
-  }
-
-  return IOResult::FromOSError(GetLastError());
+  result.QuadPart = offset;
+  SetOffset(&io_context_.overlapped, result);
+  return IOResult(result.QuadPart, 0);
 }
 
 void FileStream::Context::OnFileOpened() {
   base::MessageLoopForIO::current()->RegisterIOHandler(file_.GetPlatformFile(),
                                                        this);
 }
 
 void FileStream::Context::IOCompletionIsPending(
     const CompletionCallback& callback,
     IOBuffer* buf) {
@@ skipping 103 matching lines @@
 
   IOResult error = IOResult::FromOSError(os_error);
   if (error.os_error == ERROR_IO_PENDING) {
     InvokeUserCallback();
   } else {
     OnIOCompleted(&io_context_, 0, error.os_error);
   }
 }
 
 }  // namespace net