Add net log to UploadDataStream.

net/base/upload_data_stream.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/upload_data_stream.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
+#include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
+namespace {
+
+std::unique_ptr<base::Value> NetLogInitEndInfoCallback(
+    int result,
+    int total_size,
+    bool is_chunked,
+    NetLogCaptureMode /* capture_mode */) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+
+  dict->SetInteger("result", result);
+  dict->SetInteger("total_size", total_size);
+  dict->SetBoolean("is_chunked", is_chunked);
+  return std::move(dict);
+}
+
+std::unique_ptr<base::Value> NetLogReadInfoCallback(
+    int current_position,
+    NetLogCaptureMode /* capture_mode */) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+
+  dict->SetInteger("current_position", current_position);
+  return std::move(dict);
+}
+
+std::unique_ptr<base::Value> NetLogReadEndInfoCallback(
+    int result,
+    NetLogCaptureMode /* capture_mode */) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+
+  dict->SetInteger("result", result);
+  return std::move(dict);
+}
+
+// Logs when an initialization has been completed.
+void LogInitEnd(const BoundNetLog& net_log,

[mmenke, 2016/08/16 15:40:06]

I don't think these methods really get us anything.  Can just inline them
instead.

[maksims (do not use this acc), 2016/08/16 18:45:37]

Done.

+                int result,
+                int total_size_,
+                bool is_chunked) {
+  net_log.EndEvent(
+      NetLog::TYPE_UPLOAD_DATA_STREAM_INIT,
+      base::Bind(&NetLogInitEndInfoCallback, result, total_size_, is_chunked));
+}
+
+// Logs when read has been started.
+void LogRead(const BoundNetLog& net_log, int current_position) {
+  net_log.BeginEvent(NetLog::TYPE_UPLOAD_DATA_STREAM_READ,
+                     base::Bind(&NetLogReadInfoCallback, current_position));
+}
+
+// Logs when read has been completed (before its callback is run).
+void LogReadEnd(const BoundNetLog& net_log, int result) {
+  net_log.EndEvent(NetLog::TYPE_UPLOAD_DATA_STREAM_READ,
+                   base::Bind(&NetLogReadEndInfoCallback, result));
+}
+
+// Logs when a read request has been cancelled.
+void LogCancelRead(const BoundNetLog& net_log) {
+  net_log.AddEventWithNetErrorCode(NetLog::TYPE_UPLOAD_DATA_STREAM_READ,
+                                   NetLog::TYPE_CANCELLED);

[mmenke, 2016/08/16 15:40:06]

TYPE_CANCELLED isn't a network error code, it's a NetLog event.

Can just get rid of this method, and use LogReadEnd(net_log, ERR_ABORTED)
instead.

[maksims (do not use this acc), 2016/08/16 18:45:37]

Done.

+  net_log.EndEvent(NetLog::TYPE_UPLOAD_DATA_STREAM_READ);
+}
+
+}  // namespace
+
 UploadDataStream::UploadDataStream(bool is_chunked, int64_t identifier)
     : total_size_(0),
       current_position_(0),
       identifier_(identifier),
       is_chunked_(is_chunked),
       initialized_successfully_(false),
       is_eof_(false) {
 }
 
 UploadDataStream::~UploadDataStream() {
 }
 
-int UploadDataStream::Init(const CompletionCallback& callback) {
+int UploadDataStream::Init(const CompletionCallback& callback,
+                           const BoundNetLog& net_log) {
   Reset();
   DCHECK(!initialized_successfully_);
   DCHECK(callback_.is_null());
   DCHECK(!callback.is_null() || IsInMemory());
-  int result = InitInternal();
+  net_log_ = net_log;
+  net_log_.BeginEvent(NetLog::TYPE_UPLOAD_DATA_STREAM_READ);

[mmenke, 2016/08/16 15:40:06]

TYPE_UPLOAD_DATA_STREAM_INIT

[maksims (do not use this acc), 2016/08/16 18:45:37]

oops.

+
+  int result = InitInternal(net_log_);
   if (result == ERR_IO_PENDING) {
     DCHECK(!IsInMemory());
     callback_ = callback;
   } else {
     OnInitCompleted(result);
   }
+
   return result;
 }
 
 int UploadDataStream::Read(IOBuffer* buf,
                            int buf_len,
                            const CompletionCallback& callback) {
   DCHECK(!callback.is_null() || IsInMemory());
   DCHECK(initialized_successfully_);
   DCHECK_GT(buf_len, 0);
-  if (is_eof_)
-    return 0;
-  int result = ReadInternal(buf, buf_len);
+
+  LogRead(net_log_, current_position_);
+
+  int result = 0;
+  if (!is_eof_)
+    result = ReadInternal(buf, buf_len);
+
   if (result == ERR_IO_PENDING) {
     DCHECK(!IsInMemory());
     callback_ = callback;
   } else {
     OnReadCompleted(result);
   }
+
   return result;
 }
 
 bool UploadDataStream::IsEOF() const {
   DCHECK(initialized_successfully_);
   DCHECK(is_chunked_ || is_eof_ == (current_position_ == total_size_));
   return is_eof_;
 }
 
 void UploadDataStream::Reset() {
+  if (!callback_.is_null())
+    LogCancelRead(net_log_);

[mmenke, 2016/08/16 15:40:06]

We may actually be completing initialization.  Can just check if
initialized_successfully_ is true or not (If it's true, we were reading, if
false, we were initializing).  The fact that we'd have to worry about both cases
didn't occur to me earlier.

[maksims (do not use this acc), 2016/08/16 18:45:37]

I though a bit different way. If callback is set, then anyway init() is
"successful"..almost. 

+
   current_position_ = 0;
   initialized_successfully_ = false;
   is_eof_ = false;
   total_size_ = 0;
   callback_.Reset();
   ResetInternal();
 }
 
 void UploadDataStream::SetSize(uint64_t size) {
   DCHECK(!initialized_successfully_);
@@ skipping 21 matching lines @@
   DCHECK_NE(ERR_IO_PENDING, result);
   DCHECK(!initialized_successfully_);
   DCHECK_EQ(0u, current_position_);
   DCHECK(!is_eof_);
 
   if (result == OK) {
     initialized_successfully_ = true;
     if (!is_chunked_ && total_size_ == 0)
       is_eof_ = true;
   }
+
+  LogInitEnd(net_log_, result, total_size_, is_chunked_);
+
   if (!callback_.is_null())
     base::ResetAndReturn(&callback_).Run(result);
 }
 
 void UploadDataStream::OnReadCompleted(int result) {
   DCHECK(initialized_successfully_);
   DCHECK(result != 0 || is_eof_);
   DCHECK_NE(ERR_IO_PENDING, result);
 
   if (result > 0) {
     current_position_ += result;
     if (!is_chunked_) {
       DCHECK_LE(current_position_, total_size_);
       if (current_position_ == total_size_)
         is_eof_ = true;
     }
   }
 
+  LogReadEnd(net_log_, result);
+
   if (!callback_.is_null())
     base::ResetAndReturn(&callback_).Run(result);
 }
 
 }  // namespace net