First cut at UI for saving net_logs data into a temporary file on

chrome/browser/net/chrome_net_log.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 "chrome/browser/net/chrome_net_log.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/net/load_timing_observer.h"
 #include "chrome/browser/net/net_log_logger.h"
+#include "chrome/browser/net/net_log_temp_file.h"
 #include "chrome/common/chrome_switches.h"
 
 ChromeNetLog::ChromeNetLog()
     : last_id_(0),
       base_log_level_(LOG_BASIC),
       effective_log_level_(LOG_BASIC),
-      load_timing_observer_(new LoadTimingObserver()) {
+      load_timing_observer_(new LoadTimingObserver()),
+      net_log_temp_file_(new NetLogTempFile(this)) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   // Adjust base log level based on command line switch, if present.
   // This is done before adding any observers so the call to UpdateLogLevel when
   // an observers is added will set |effective_log_level_| correctly.
   if (command_line->HasSwitch(switches::kNetLogLevel)) {
     std::string log_level_string =
         command_line->GetSwitchValueASCII(switches::kNetLogLevel);
     int command_line_log_level;
     if (base::StringToInt(log_level_string, &command_line_log_level) &&
         command_line_log_level >= LOG_ALL &&
         command_line_log_level <= LOG_BASIC) {
       base_log_level_ = static_cast<LogLevel>(command_line_log_level);
     }
   }
 
   load_timing_observer_->StartObserving(this);
 
   if (command_line->HasSwitch(switches::kLogNetLog)) {
     net_log_logger_.reset(new NetLogLogger(
         command_line->GetSwitchValuePath(switches::kLogNetLog)));
     net_log_logger_->StartObserving(this);
   }
 }
 
 ChromeNetLog::~ChromeNetLog() {
+  net_log_temp_file_.reset();

[mmenke, 2013/01/18 15:58:00]

Think we should have the temp file stop watching the NetLog, if it currently is
doing so.  Can this happen?  It's not clear.  I pretty sure we destroy all tabs
(And thus the WebUI's) before we destroy the FILE_THREAD_USER_BLOCKING, but I'm
not completely positive, and would be more comfortable not relying on that
behavior on all platforms.

Simplest thing would be:

if (net_log_temp_file_->net_log())
  net_log_temp_file_->StopObserving();

[mmenke, 2013/01/18 15:58:00]

Also, there's no need to delete this.  Just need to make sure it isn't watching
the NetLog.

[ramant (doing other things), 2013/01/18 23:22:33]

We do the above in NetLogTempFile::~NetLogTempFile(). Wanted to keep the
knowledge of Start/Stop  observing to net_log_temp_file. If you feel strongly,
will move that code here and remove the reset.

   // Remove the observers we own before we're destroyed.
   RemoveThreadSafeObserver(load_timing_observer_.get());
   if (net_log_logger_.get())
     RemoveThreadSafeObserver(net_log_logger_.get());
 }
 
 void ChromeNetLog::OnAddEntry(const net::NetLog::Entry& entry) {
   base::AutoLock lock(lock_);
 
   // Notify all of the log observers.
@@ skipping 48 matching lines @@
   LogLevel new_effective_log_level = base_log_level_;
   ObserverListBase<ThreadSafeObserver>::Iterator it(observers_);
   ThreadSafeObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
     new_effective_log_level =
         std::min(new_effective_log_level, observer->log_level());
   }
   base::subtle::NoBarrier_Store(&effective_log_level_,
                                 new_effective_log_level);
 }