Remove NetLog::GetCaptureMode() and NetLogCaptureMode::None()

net/log/net_log.h

 // 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.
 
 #ifndef NET_LOG_NET_LOG_H_
 #define NET_LOG_NET_LOG_H_
 
 #include <string>
 
 #include "build/build_config.h"
@@ skipping 189 matching lines @@
 
   // Emits a global event to the log stream, with its own unique source ID.
   void AddGlobalEntry(EventType type);
   void AddGlobalEntry(EventType type,
                       const NetLog::ParametersCallback& parameters_callback);
 
   // Returns a unique ID which can be used as a source ID.  All returned IDs
   // will be unique and greater than 0.
   uint32 NextID();
 
-  // Returns the capture mode for this NetLog. This is used to avoid computing
-  // and saving expensive log entries.
-  NetLogCaptureMode GetCaptureMode() const;
+  // Returns true if there are any observers attached to the NetLog. This can be
+  // used as an optimization to avoid emitting log entries.
+  bool HasObservers() const;
 
   // Adds an observer and sets its log capture mode.  The observer must not be
   // watching any NetLog, including this one, when this is called.
   //
   // NetLog implementations must call NetLog::OnAddObserver to update the
   // observer's internal state.
   //
   // DEPRECATED: The ability to watch the netlog stream is being phased out
   // (crbug.com/472693) as it can be misused in production code. Please consult
   // with a net/log OWNER before introducing a new dependency on this.
@@ skipping 64 matching lines @@
                                            const base::string16* value);
 
  private:
   friend class BoundNetLog;
 
   void AddEntry(EventType type,
                 const Source& source,
                 EventPhase phase,
                 const NetLog::ParametersCallback* parameters_callback);
 
-  // Called whenever an observer is added or removed, or has its log
-  // capture mode changed.  Must have acquired |lock_| prior to calling.
-  void UpdateCaptureMode();
+  // Called whenever an observer is added or removed, to update has_observers_.

[mmenke, 2015/05/05 19:45:15]

|observers_| is more consistent with the other comments in this file.

[eroman, 2015/05/05 22:54:38]

Done (I presume you meant |has_observers_|)

+  // Must have acquired |lock_| prior to calling.
+  void UpdateHasObservers();
 
   // |lock_| protects access to |observers_|.
   base::Lock lock_;
 
   // Last assigned source ID.  Incremented to get the next one.
   base::subtle::Atomic32 last_id_;
 
-  // The current capture mode. Note that the capture mode is stored as an
-  // integer rather than a NetLogCaptureMode so that it can be easily
-  // read/written without a lock using Atomic32.
-  base::subtle::Atomic32 effective_capture_mode_int32_;
+  // Whether there are any observers in |observers_|. Note that this is stored
+  // as an Atomic32 rather than a boolean so it can be accessed/written without
+  // needing a lock.
+  base::subtle::Atomic32 has_observers_;
 
   // |lock_| must be acquired whenever reading or writing to this.
   ObserverList<ThreadSafeObserver, true> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLog);
 };
 
 // Helper that binds a Source to a NetLog, and exposes convenience methods to
 // output log messages without needing to pass in the source.
 class NET_EXPORT BoundNetLog {
@@ skipping 34 matching lines @@
   // |net_error| must not be ERR_IO_PENDING, as it's not a true error.
   void EndEventWithNetErrorCode(NetLog::EventType event_type,
                                 int net_error) const;
 
   // Logs a byte transfer event to the NetLog.  Determines whether to log the
   // received bytes or not based on the current logging level.
   void AddByteTransferEvent(NetLog::EventType event_type,
                             int byte_count,
                             const char* bytes) const;
 
-  NetLogCaptureMode GetCaptureMode() const;
+  bool HasObservers() const;

[mmenke, 2015/05/05 19:45:15]

Maybe IsLogging?  I don't think consumers of the BoundNetLog really need to know
why we're logging events.  Also, when we get rid of observers, it won't need to
be renamed, though admittedly, we may want to remove this method at that point,
anyways.

[eroman, 2015/05/05 22:54:38]

Renamed to IsCapturing().
Which I think is in line with "NetLogCaptureMode != None" of old naming.

 
   // Helper to create a BoundNetLog given a NetLog and a SourceType. Takes care
   // of creating a unique source ID, and handles the case of NULL net_log.
   static BoundNetLog Make(NetLog* net_log, NetLog::SourceType source_type);
 
   const NetLog::Source& source() const { return source_; }
   NetLog* net_log() const { return net_log_; }
 
  private:
   // TODO(eroman): Temporary until crbug.com/467797 is solved.
@@ skipping 11 matching lines @@
   NetLog::Source source_;
   NetLog* net_log_;
 
   // TODO(eroman): Temporary until crbug.com/467797 is solved.
   Liveness liveness_ = ALIVE;
 };
 
 }  // namespace net
 
 #endif  // NET_LOG_NET_LOG_H_