Update NetLog to be thread safe.

net/base/capturing_net_log.h

 // 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.
 
 #ifndef NET_BASE_CAPTURING_NET_LOG_H_
 #define NET_BASE_CAPTURING_NET_LOG_H_
 #pragma once
 
 #include <vector>
 
+#include "base/atomicops.h"
 #include "base/basictypes.h"
+#include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "net/base/net_log.h"
 
 namespace net {
 
 // CapturingNetLog is an implementation of NetLog that saves messages to a
 // bounded buffer.
 class CapturingNetLog : public NetLog {
@@ skipping 26 matching lines @@
   // NetLog implementation:
   virtual void AddEntry(EventType type,
                         const base::TimeTicks& time,
                         const Source& source,
                         EventPhase phase,
                         EventParameters* extra_parameters);
   virtual uint32 NextID();
   virtual LogLevel GetLogLevel() const { return LOG_ALL_BUT_BYTES; }
 
   // Returns the list of all entries in the log.
-  const EntryList& entries() const { return entries_; }
+  void GetEntries(EntryList* entry_list) const;
 
   void Clear();
 
  private:
-  uint32 next_id_;
+  // Needs to be "mutable" so can use it in GetEntries().
+  mutable Lock lock_;
+  base::subtle::Atomic32 next_id_;

[eroman, 2010/11/18 18:04:03]

nit: For consistency with ChromeNetLog, you should either call this last_event_
or call ChromeNetLog's one next_id_.

[mmenke, 2010/11/23 16:48:45]

ChromeNetLog's is the id of the last event that occurred, meaning the next id is
last_id_+1, while this is the id of the next event.  The difference is because
they're both initialized to 0, but ChromeNetLog starts with an id of 0, while
CapturingNetLog starts with an id of 1.  I'll go ahead and rename
CapturingNetLog's and initialize it to -1.

   size_t max_num_entries_;
   EntryList entries_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingNetLog);
 };
 
 // Helper class that exposes a similar API as BoundNetLog, but uses a
 // CapturingNetLog rather than the more generic NetLog.
 //
 // CapturingBoundNetLog can easily be converted to a BoundNetLog using the
 // bound() method.
 class CapturingBoundNetLog {
  public:
-  CapturingBoundNetLog(const NetLog::Source& source, CapturingNetLog* net_log);
+  CapturingBoundNetLog(const NetLog::Source& source,
+                       scoped_refptr<CapturingNetLog>& net_log);

[eroman, 2010/11/18 18:04:03]

I didn't think CapturingNetLog was refcounted?

[mmenke, 2010/11/23 16:48:45]

Thanks.  Holdover from the first pass.

 
   explicit CapturingBoundNetLog(size_t max_num_entries);
 
   ~CapturingBoundNetLog();
 
   // The returned BoundNetLog is only valid while |this| is alive.
   BoundNetLog bound() const {
     return BoundNetLog(source_, capturing_net_log_.get());
   }
 
   // Returns the list of all entries in the log.

[eroman, 2010/11/18 18:04:03]

nit: "Returns" --> "Fills" ?

-  const CapturingNetLog::EntryList& entries() const {
-    return capturing_net_log_->entries();
-  }
+  void GetEntries(CapturingNetLog::EntryList* entry_list) const;
 
   void Clear();
 
   // Sends all of captured messages to |net_log|, using the same source ID
   // as |net_log|.
   void AppendTo(const BoundNetLog& net_log) const;

[eroman, 2010/11/18 18:04:03]

I wander if we still need this method now?

[mmenke, 2010/11/23 16:48:45]

I can't see a use for it.

 
  private:
   NetLog::Source source_;
   scoped_ptr<CapturingNetLog> capturing_net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingBoundNetLog);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_CAPTURING_NET_LOG_H_