Add FilePath to base namespace.

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_
 #define NET_BASE_FILE_STREAM_H_
 
 #include "base/platform_file.h"
 #include "net/base/completion_callback.h"
 #include "net/base/file_stream_whence.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 
+namespace base {
 class FilePath;
+}
 
 namespace net {
 
 class IOBuffer;
 
 class NET_EXPORT FileStream {
  public:
   // Creates a |FileStream| with a new |BoundNetLog| (based on |net_log|)
   // attached.  |net_log| may be NULL if no logging is needed.
   explicit FileStream(net::NetLog* net_log);
@@ skipping 17 matching lines @@
   // started then an error code is returned.
   //
   // Once the operation is done, |callback| will be run on the thread where
   // Open() was called, with the result code. open_flags is a bitfield of
   // base::PlatformFileFlags.
   //
   // If the file stream is not closed manually, the underlying file will be
   // automatically closed when FileStream is destructed in an asynchronous
   // manner (i.e. the file stream is closed in the background but you don't
   // know when).
-  virtual int Open(const FilePath& path, int open_flags,
+  virtual int Open(const base::FilePath& path, int open_flags,
                    const CompletionCallback& callback);
 
   // Call this method to open the FileStream synchronously.
   // The remaining methods cannot be used unless this method returns OK.  If
   // the file cannot be opened then an error code is returned.  open_flags is
   // a bitfield of base::PlatformFileFlags
   //
   // If the file stream is not closed manually, the underlying file will be
   // automatically closed when FileStream is destructed.
-  virtual int OpenSync(const FilePath& path, int open_flags);
+  virtual int OpenSync(const base::FilePath& path, int open_flags);
 
   // 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.
@@ skipping 149 matching lines @@
   // delaying FileStream's destructor. To perform all that separate object is
   // necessary.
   scoped_ptr<Context> context_;
 
   DISALLOW_COPY_AND_ASSIGN(FileStream);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_FILE_STREAM_H_