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

net/base/file_stream.h

 // 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.
 
 // This file defines FileStream, a basic interface for reading and writing files
 // synchronously or asynchronously with support for seeking to an offset.
 // Note that even when used asynchronously, only one operation is supported at
 // a time.
 
 #ifndef NET_BASE_FILE_STREAM_H_
@@ skipping 44 matching lines @@
 
   // Returns ERR_IO_PENDING and closes the file asynchronously, calling
   // |callback| when done.
   // It is invalid to request any asynchronous operations while there is an
   // in-flight asynchronous operation.
   virtual int Close(const CompletionCallback& callback);
 
   // Returns true if Open succeeded and Close has not been called.
   virtual bool IsOpen() const;
 
-  // Adjust the position from where data is read asynchronously.
-  // Upon success, ERR_IO_PENDING is returned and |callback| will be run
-  // on the thread where Seek() was called with the the stream position
-  // relative to the start of the file.  Otherwise, an error code is returned.
-  // It is invalid to request any asynchronous operations while there is an
-  // in-flight asynchronous operation.
-  virtual int Seek(base::File::Whence whence, int64 offset,
-                   const Int64CompletionCallback& callback);
+  // Adjust the position from the start of the file where data is read
+  // asynchronously. Upon success, ERR_IO_PENDING is returned and |callback|
+  // will be run on the thread where Seek() was called with the the stream
+  // position relative to the start of the file.  Otherwise, an error code is
+  // returned. It is invalid to request any asynchronous operations while there
+  // is an in-flight asynchronous operation.
+  virtual int Seek(int64 offset, const Int64CompletionCallback& callback);
 
   // Call this method to read data from the current stream position
   // asynchronously. Up to buf_len bytes will be copied into buf.  (In
   // other words, partial reads are allowed.)  Returns the number of bytes
   // copied, 0 if at end-of-file, or an error code if the operation could
   // not be performed.
   //
   // The file must be opened with FLAG_ASYNC, and a non-null
   // callback must be passed to this method. If the read could not
   // complete synchronously, then ERR_IO_PENDING is returned, and the
@@ skipping 50 matching lines @@
   // It is valid to destroy or close the file stream while there is an
   // asynchronous flush in progress.  That will cancel the flush and allow
   // the buffer to be freed.
   //
   // It is invalid to request any asynchronous operations while there is an
   // in-flight asynchronous operation.
   //
   // This method should not be called if the stream was opened READ_ONLY.
   virtual int Flush(const CompletionCallback& callback);
 
-  // Returns the underlying file for testing.
-  const base::File& GetFileForTesting() const;
-
  private:
   class Context;
 
   // Context performing I/O operations. It was extracted into a separate class
   // to perform asynchronous operations because FileStream can be destroyed
   // before completion of an async operation. Also if a FileStream is destroyed
   // without explicitly calling Close, the file should be closed asynchronously
   // without delaying FileStream's destructor.
   scoped_ptr<Context> context_;
 
   DISALLOW_COPY_AND_ASSIGN(FileStream);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_FILE_STREAM_H_