Add ability for NetLogLogger to gather data from more than just NetLog

net/base/net_log_logger.h

 // Copyright 2013 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_NET_LOG_LOGGER_H_
 #define NET_BASE_NET_LOG_LOGGER_H_
 
 #include <stdio.h>
 
 #include "base/files/scoped_file.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "net/base/net_log.h"
 
 namespace base {
 class DictionaryValue;
 class FilePath;
 class Value;
 }
 
 namespace net {
 
+class URLRequestContext;
+
 // NetLogLogger watches the NetLog event stream, and sends all entries to
 // a file specified on creation.
 //
 // The text file will contain a single JSON object.
 class NET_EXPORT NetLogLogger : public NetLog::ThreadSafeObserver {
  public:
-  // Takes ownership of |file| and will write network events to it once logging
-  // starts.  |file| must be non-NULL handle and be open for writing.
-  // |constants| is a legend for decoding constant values used in the log.
-  NetLogLogger(FILE* file, const base::Value& constants);
+  NetLogLogger();
   ~NetLogLogger() override;
 
   // Sets the log level to log at. Must be called before StartObserving.
   void set_log_level(NetLog::LogLevel log_level);
 
-  // Starts observing specified NetLog.  Must not already be watching a NetLog.
-  // Separate from constructor to enforce thread safety.
-  void StartObserving(NetLog* net_log);
+  // Starts observing |net_log| and writes output to |file|.  Must not already
+  // be watching a NetLog.  Separate from constructor to enforce thread safety.
+  //
+  // |file| must be a non-NULL empty file that's open for writing.
+  //
+  // |constants| is an optional legend for decoding constant values used in the
+  // log.  It should generally be a modified version of GetNetConstants().  If
+  // not present, the output of GetNetConstants() will be used.
+  //
+  // |url_request_context| is an optional URLRequestContext to collect
+  // additional information from.  When non-NULL, StartObserving and
+  // StopObserving must be called on the context's thread, while the context is

[eroman, 2015/03/05 19:25:58]

I don't like this second requirement. How about instead of storing
url_request_context_ in the NetLogger, making it a parameter to StopObserving()
?

[mmenke, 2015/03/05 22:04:17]

Done. May make StartObserving take a list of contexts at some point, to get
closer to feature parity with net-export.

+  // still valid.
+  void StartObserving(NetLog* net_log,
+                      base::ScopedFILE file,
+                      base::Value* constants,
+                      net::URLRequestContext* url_request_context);

[mmenke, 2015/03/03 18:33:58]

One downside of this approach is that we can't get anything other than net/
info...  So no prerender information, not DRP information (Though that's
currently pretty useless, and stored in prefs/ anyways), etc.  We also only get
hung requests information from one URLRequestContext, while net-internals
includes several.

So we go from having 2 different types of logs to three.  For most purposes the
new type will be as good as net-internals logs, but not all.

 
-  // Stops observing net_log().  Must already be watching.
+  // Stops observing net_log().  Must already be watching.  Must be called
+  // before destruction of the NetLogLogger and the NetLog.  If a
+  // URLRequestContext was passed in to StartObserving, must be called on that
+  // context's thread.
   void StopObserving();
 
   // net::NetLog::ThreadSafeObserver implementation:
   void OnAddEntry(const NetLog::Entry& entry) override;
 
-  // Create a dictionary containing legend for net/ constants.  Caller takes
-  // ownership of returned value.
-  // TODO(mmenke):  Get rid of this, and have embedders use GetNetConstants
-  // directly.  Also maybe call that function by default, so only embedders
-  // that need more constants need to worry about it.
-  static base::DictionaryValue* GetConstants();
-
  private:
   base::ScopedFILE file_;
 
+  URLRequestContext* url_request_context_;
+
   // The LogLevel to log at.
   NetLog::LogLevel log_level_;
 
   // True if OnAddEntry() has been called at least once.
   bool added_events_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogLogger);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_LOGGER_H_