Update NetLog to be thread safe.

chrome/browser/net/chrome_net_log.cc

 // Copyright (c) 2010 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 <algorithm>
 
 #include "base/command_line.h"
+#include "base/lock.h"
 #include "base/logging.h"
 #include "base/string_util.h"
-#include "chrome/browser/browser_thread.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/passive_log_collector.h"
 #include "chrome/common/chrome_switches.h"
 
 ChromeNetLog::Observer::Observer(LogLevel log_level) : log_level_(log_level) {}
 
 net::NetLog::LogLevel ChromeNetLog::Observer::log_level() const {
   return log_level_;
 }
 
-void ChromeNetLog::Observer::set_log_level(net::NetLog::LogLevel log_level) {
+void ChromeNetLog::Observer::set_log_level(net::NetLog::LogLevel log_level,
+                                           ChromeNetLog* net_log) {
   log_level_ = log_level;
+  if (net_log) {

[eroman, 2010/11/16 17:51:14]

Are there any existing cases where this would be NULL?

If not we can probably just avoid this 'if' (to avoid people passing in NULL
each time but then failing to properly update).

[mmenke, 2010/11/16 21:34:49]

Never happens at the moment.  Change made (Description updated to indicate this,
too).

+    AutoLock lock(net_log->lock_);
+    net_log->UpdateLogLevel_();
+  }
 }
 
+ChromeNetLog::Entry::Entry(uint32 order,
+                           net::NetLog::EventType type,
+                           const base::TimeTicks& time,
+                           net::NetLog::Source source,
+                           net::NetLog::EventPhase phase,
+                           net::NetLog::EventParameters* params)
+    : order(order),
+      type(type),
+      time(time),
+      source(source),
+      phase(phase),
+      params(params) {
+}
+
+ChromeNetLog::Entry::~Entry() {}
+
 ChromeNetLog::ChromeNetLog()
-    : next_id_(1),
+    : last_id_(0),
       passive_collector_(new PassiveLogCollector),
       load_timing_observer_(new LoadTimingObserver) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   AddObserver(passive_collector_.get());
   AddObserver(load_timing_observer_.get());
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kLogNetLog)) {
     net_log_logger_.reset(new NetLogLogger());
     AddObserver(net_log_logger_.get());
   }
 }
 
 ChromeNetLog::~ChromeNetLog() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   RemoveObserver(passive_collector_.get());
   RemoveObserver(load_timing_observer_.get());
   if (net_log_logger_.get()) {
     RemoveObserver(net_log_logger_.get());
   }
 }
 
 void ChromeNetLog::AddEntry(EventType type,
                             const base::TimeTicks& time,
                             const Source& source,
                             EventPhase phase,
                             EventParameters* params) {
-  // This must be invoked when we're on the IO thread, or if the IO thread's
-  // message loop isn't valid. The later can happen if this is invoked when the
-  // IOThread is shuting down the MessageLoop.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO) ||
-         !BrowserThread::IsMessageLoopValid(BrowserThread::IO));
+  AutoLock lock(lock_);
 
   // Notify all of the log observers.
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnAddEntry(type, time, source, phase, params));
 }
 
 uint32 ChromeNetLog::NextID() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  return next_id_++;
+  return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
 }
 
 net::NetLog::LogLevel ChromeNetLog::GetLogLevel() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  base::subtle::Atomic32 log_level = base::subtle::NoBarrier_Load(&log_level_);
+  return static_cast<net::NetLog::LogLevel>(log_level);
+}
 
+void ChromeNetLog::AddObserver(Observer* observer) {
+  AutoLock lock(lock_);
+  observers_.AddObserver(observer);
+  UpdateLogLevel_();
+}
+
+void ChromeNetLog::RemoveObserver(Observer* observer) {
+  AutoLock lock(lock_);
+  observers_.RemoveObserver(observer);
+  UpdateLogLevel_();
+}
+
+void ChromeNetLog::AddObserverAndGetAllCapturedEvents(
+    Observer* observer,
+    EntryList* passive_entries) {
+  AutoLock lock(lock_);
+  observers_.AddObserver(observer);
+  UpdateLogLevel_();
+  passive_collector_->GetAllCapturedEvents(passive_entries);
+}
+
+void ChromeNetLog::UpdateLogLevel_() {

[eroman, 2010/11/16 17:51:14]

Can you call lock_.AssertAcquired() ?

[mmenke, 2010/11/16 21:34:49]

Done.

   // Look through all the observers and find the finest granularity
   // log level (higher values of the enum imply *lower* log levels).
-  LogLevel log_level = LOG_BASIC;
+  LogLevel new_log_level = LOG_BASIC;
   ObserverListBase<Observer>::Iterator it(observers_);
   Observer* observer;
   while ((observer = it.GetNext()) != NULL) {
-    log_level = std::min(log_level, observer->log_level());
+    new_log_level = std::min(new_log_level, observer->log_level());
   }
-  return log_level;
+  base::subtle::NoBarrier_Store(&log_level_, new_log_level);
 }
 
-void ChromeNetLog::AddObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  observers_.AddObserver(observer);
-}
-
-void ChromeNetLog::RemoveObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  observers_.RemoveObserver(observer);
-}