Add ongoing events to net-export log when logging starts

components/cronet/android/cronet_url_request_context_adapter.cc

 // Copyright 2014 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 "components/cronet/android/cronet_url_request_context_adapter.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <map>
+#include <set>

[xunjieli, 2017/02/24 18:49:03]

why is this needed?

[wangyix1, 2017/02/24 22:07:19]

The first param to CreateNetLogEntriesForActiveObjects() at line 1030 is const
std::set<URLRequestContext*>& contexts; I just used an initializer list for that
param.

[xunjieli, 2017/02/24 22:10:08]

Acknowledged.

[eroman, 2017/02/24 23:43:45]

I don't think you quite answered Helen's question.

cronet_url_request_context_adapter.cc was already including <set> transitively
by way of "net/log/net_log_util.h".

So in that sense, the addition of <set> should not have been needed for
compilation sake (if you remove the line it still compiles right?). In general
APIs that take a std::set<> will end up polluting <set> since it can't be
forward declared.

Including <set> in this file explicitly isn't necessarily a bad thing. Adherents
of the include-what-you-use would encourage doing so.

However we don't enforce IWYU in Chrome thanks to lack of tooling support, so I
would say this include is entirely optional, and Helen's question still stands.

I don't really care whether we include <set> here or not. But would like to see
the motivation explained one way or another.

Thanks!

 #include <utility>
 #include <vector>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ skipping 992 matching lines @@
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
 
   // Do nothing if already logging to a directory.
   if (bounded_file_observer_)
     return;
 
   // Filepath for NetLog files must exist and be writable.
   base::FilePath file_path(dir_path);
   DCHECK(base::PathIsWritable(file_path));
 
-  bounded_file_observer_.reset(
-      new net::FileNetLogObserver(GetFileThread()->task_runner()));
+  bounded_file_observer_ = net::FileNetLogObserver::CreateBounded(
+      GetFileThread()->task_runner(), file_path, size, kNumNetLogEventFiles,
+      /*constants=*/nullptr);
+
+  CreateNetLogEntriesForActiveObjects({context_.get()},
+                                      bounded_file_observer_.get());
 
   net::NetLogCaptureMode capture_mode =
       include_socket_bytes ? net::NetLogCaptureMode::IncludeSocketBytes()
                            : net::NetLogCaptureMode::Default();
-
-  bounded_file_observer_->StartObservingBounded(
-      g_net_log.Get().net_log(), capture_mode, file_path,
-      /*constants=*/nullptr, context_.get(), size, kNumNetLogEventFiles);
+  bounded_file_observer_->StartObserving(g_net_log.Get().net_log(),
+                                         capture_mode);
 }
 
 void CronetURLRequestContextAdapter::StopBoundedFileNetLogOnNetworkThread() {
   DCHECK(GetNetworkTaskRunner()->BelongsToCurrentThread());
   bounded_file_observer_->StopObserving(
       net::GetNetInfo(context_.get(), net::NET_INFO_ALL_SOURCES),
       base::Bind(&CronetURLRequestContextAdapter::StopNetLogCompleted,
                  base::Unretained(this)));
   bounded_file_observer_.reset();
 }
@@ skipping 145 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jclass>& jcaller) {
   base::StatisticsRecorder::Initialize();
   std::vector<uint8_t> data;
   if (!HistogramManager::GetInstance()->GetDeltas(&data))
     return ScopedJavaLocalRef<jbyteArray>();
   return base::android::ToJavaByteArray(env, &data[0], data.size());
 }
 
 }  // namespace cronet