Create a separate NetLog source type QUIC_STREAM_FACTORY_JOB

net/quic/chromium/quic_stream_factory.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/quic/chromium/quic_stream_factory.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 74 matching lines @@
   INITIAL_RTT_SOURCE_MAX,
 };
 
 // The maximum receive window sizes for QUIC sessions and streams.
 const int32_t kQuicSessionMaxRecvWindowSize = 15 * 1024 * 1024;  // 15 MB
 const int32_t kQuicStreamMaxRecvWindowSize = 6 * 1024 * 1024;    // 6 MB
 
 // Set the maximum number of undecryptable packets the connection will store.
 const int32_t kMaxUndecryptablePackets = 100;
 
+std::unique_ptr<base::Value> NetLogQuicStreamFactoryJobCallback(
+    const QuicServerId& server_id,
+    NetLogCaptureMode capture_mode) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  dict->SetString("server_id", server_id.ToString());
+  return std::move(dict);
+}
+
 std::unique_ptr<base::Value> NetLogQuicConnectionMigrationTriggerCallback(
     std::string trigger,
     NetLogCaptureMode capture_mode) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("trigger", trigger);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogQuicConnectionMigrationFailureCallback(
     QuicConnectionId connection_id,
@@ skipping 274 matching lines @@
                             const NetLogWithSource& net_log)
     : io_state_(STATE_RESOLVE_HOST),
       factory_(factory),
       host_resolver_(host_resolver),
       key_(key),
       cert_verify_flags_(cert_verify_flags),
       was_alternative_service_recently_broken_(
           was_alternative_service_recently_broken),
       server_info_(std::move(server_info)),
       started_another_job_(false),
-      net_log_(net_log),
+      net_log_(
+          NetLogWithSource::Make(net_log.net_log(),
+                                 NetLogSourceType::QUIC_STREAM_FACTORY_JOB)),
       num_sent_client_hellos_(0),
       session_(nullptr),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  std::string server_id = key_.server_id().ToString();

[eroman, 2017/04/07 19:16:40]

Delete this.

[Zhongyi Shi, 2017/04/07 20:33:56]

Whoops, forgot to delete this.

+  net_log_.BeginEvent(
+      NetLogEventType::QUIC_STREAM_FACTORY_JOB,
+      base::Bind(&NetLogQuicStreamFactoryJobCallback, key_.server_id()));

[eroman, 2017/04/07 19:16:40]

This is still making a copy of the server ID (just now it is part of the bound
function).

Either pass a pointer, or base::ConstRef(key_.server_id()), or pass a pointer.

I prefer making NetLogQuicStreamFactoryJobCallback() take a const pointer, that
way it is harder for callers to inadvertently make copies when binding the
function.

[Zhongyi Shi, 2017/04/07 20:33:56]

Done.

+  // Associate |net_log_| with |net_log|.
+  net_log_.AddEvent(
+      NetLogEventType::QUIC_STREAM_FACTORY_JOB_BOUND_TO_HTTP_STREAM_JOB,
+      net_log.source().ToEventParametersCallback());
+  net_log.AddEvent(
+      NetLogEventType::HTTP_STREAM_JOB_BOUND_TO_QUIC_STREAM_FACTORY_JOB,
+      net_log_.source().ToEventParametersCallback());
+}
 
 QuicStreamFactory::Job::~Job() {
+  net_log_.EndEvent(NetLogEventType::QUIC_STREAM_FACTORY_JOB);
   DCHECK(callback_.is_null());
 
   // If disk cache has a pending WaitForDataReadyCallback, cancel that callback.
   if (server_info_)
     server_info_->ResetWaitForDataReadyCallback();
 }
 
 int QuicStreamFactory::Job::Run(const CompletionCallback& callback) {
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
@@ skipping 1480 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net