Add net log to UploadDataStream.

net/base/upload_data_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.
 
 #ifndef NET_BASE_UPLOAD_DATA_STREAM_H_
 #define NET_BASE_UPLOAD_DATA_STREAM_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
+#include "net/log/net_log.h"
 
 namespace net {
 
 class DrainableIOBuffer;
 class IOBuffer;
 class UploadElementReader;
 
 // A class for retrieving all data to be sent as a request body. Supports both
 // chunked and non-chunked uploads.
 class NET_EXPORT UploadDataStream {
@@ skipping 10 matching lines @@
   // destructor) if Init() fails. This method can be called multiple times.
   // Calling this method after an Init() success results in resetting the
   // state (i.e. the stream is rewound).
   //
   // Does the initialization synchronously and returns the result if possible,
   // otherwise returns ERR_IO_PENDING and runs the callback with the result.
   //
   // Returns OK on success. Returns ERR_UPLOAD_FILE_CHANGED if the expected
   // file modification time is set (usually not set, but set for sliced
   // files) and the target file is changed.
-  int Init(const CompletionCallback& callback);
+  int Init(const CompletionCallback& callback, const BoundNetLog& net_log);
 
   // When possible, reads up to |buf_len| bytes synchronously from the upload
   // data stream to |buf| and returns the number of bytes read; otherwise,
   // returns ERR_IO_PENDING and calls |callback| with the number of bytes read.
   // Partial reads are allowed. Zero is returned on a call to Read when there
   // are no remaining bytes in the stream, and IsEof() will return true
   // hereafter.
   //
   // If there's less data to read than we initially observed (i.e. the actual
   // upload data is smaller than size()), zeros are padded to ensure that
@@ skipping 43 matching lines @@
   void SetSize(uint64_t size);
 
   // Must be called for chunked uploads before the final ReadInternal call
   // completes. Must not be called for non-chunked uploads.
   void SetIsFinalChunk();
 
  private:
   // See Init(). If it returns ERR_IO_PENDING, OnInitCompleted must be called
   // once it completes. If the upload is not chunked, SetSize must be called
   // before it completes.
-  virtual int InitInternal() = 0;
+  virtual int InitInternal(const BoundNetLog& net_log) = 0;
 
   // See Read(). For chunked uploads, must call SetIsFinalChunk if this is the
   // final chunk. For non-chunked uploads, the UploadDataStream determins which
   // read is the last based on size. Must read 1 or more bytes on every call,
   // though the final chunk may be 0 bytes, for chunked requests. If it returns
   // ERR_IO_PENDING, OnInitCompleted must be called once it completes. Must not
   // return any error, other than ERR_IO_PENDING.
   virtual int ReadInternal(IOBuffer* buf, int buf_len) = 0;
 
   // Resets state and cancels any pending callbacks. Guaranteed to be called
   // before all but the first call to InitInternal.
   virtual void ResetInternal() = 0;
 
   uint64_t total_size_;
   uint64_t current_position_;
 
   const int64_t identifier_;
 
   const bool is_chunked_;
 
   // True if the initialization was successful.
   bool initialized_successfully_;
 
   bool is_eof_;
 
   CompletionCallback callback_;
 
+  BoundNetLog net_log_;
+
   DISALLOW_COPY_AND_ASSIGN(UploadDataStream);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_UPLOAD_DATA_STREAM_H_