Added Net logging to FileStream.

net/base/file_stream.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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_
 #pragma once
 
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
+#include "net/base/net_log.h"
 
 class FilePath;
 
 namespace net {
 
 // TODO(darin): Move this to a more generic location.
 // This explicit mapping matches both FILE_ on Windows and SEEK_ on Linux.
 enum Whence {
   FROM_BEGIN   = 0,
   FROM_CURRENT = 1,
   FROM_END     = 2
 };
 
 class NET_EXPORT FileStream {
  public:
-  FileStream();
+  // 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);
 
   // Construct a FileStream with an existing file handle and opening flags.
   // |file| is valid file handle.
   // |flags| is a bitfield of base::PlatformFileFlags when the file handle was
   // opened.
+  // |net_log| is the net log pointer to use to create a |BoundNetLog|.  May be
+  // NULL if logging is not needed.
   // The already opened file will not be automatically closed when FileStream
   // is destructed.
-  FileStream(base::PlatformFile file, int flags);
+  FileStream(base::PlatformFile file, int flags, net::NetLog* net_log);
 
   virtual ~FileStream();
 
   // Call this method to close the FileStream.  It is OK to call Close
   // multiple times.  Redundant calls are ignored.
   // Note that if there are any pending async operations, they'll be aborted.
   virtual void Close();
 
   // Call this method to open the FileStream.  The remaining methods
   // cannot be used unless this method returns OK.  If the file cannot be
@@ skipping 77 matching lines @@
   // calling.
   //
   /// Returns an error code if the operation could not be performed.
   //
   // This method should not be called if the stream was opened READ_ONLY.
   virtual int Flush();
 
   // Turns on UMA error statistics gathering.
   void EnableErrorStatistics();
 
+  // Sets the source reference for net-internals logging.
+  // Creates source dependency events between |owner_bound_net_log| and
+  // |bound_net_log_|.  Each gets an event showing the dependency on the other.
+  // If only one of those is valid, it gets an event showing that a change
+  // of ownership happened, but without details.
+  void SetBoundNetLogSource(const net::BoundNetLog& owner_bound_net_log);
+
  private:
   class AsyncContext;
   friend class AsyncContext;
   friend class FileStreamTest;
 
   // This member is used to support asynchronous reads.  It is non-null when
   // the FileStream was opened with PLATFORM_FILE_ASYNC.
   scoped_ptr<AsyncContext> async_context_;
 
   base::PlatformFile file_;
   int open_flags_;
   bool auto_closed_;
   bool record_uma_;
+  net::BoundNetLog bound_net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(FileStream);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_FILE_STREAM_H_