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

net/log/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 "net/log/net_log.h"
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 187 matching lines @@
 }
 
 NetLog* NetLog::ThreadSafeObserver::net_log() const {
   return net_log_;
 }
 
 void NetLog::ThreadSafeObserver::OnAddEntryData(const EntryData& entry_data) {
   OnAddEntry(Entry(&entry_data, capture_mode()));
 }
 
-NetLog::NetLog()
-    : last_id_(0),
-      effective_capture_mode_int32_(
-          NetLogCaptureMode::None().ToInternalValue()) {
+NetLog::NetLog() : last_id_(0), is_capturing_(0) {
 }
 
 NetLog::~NetLog() {
 }
 
 void NetLog::AddGlobalEntry(EventType type) {
   AddEntry(type, Source(NetLog::SOURCE_NONE, NextID()), NetLog::PHASE_NONE,
            NULL);
 }
 
 void NetLog::AddGlobalEntry(
     EventType type,
     const NetLog::ParametersCallback& parameters_callback) {
   AddEntry(type, Source(NetLog::SOURCE_NONE, NextID()), NetLog::PHASE_NONE,
            &parameters_callback);
 }
 
 uint32 NetLog::NextID() {
   return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
 }
 
-NetLogCaptureMode NetLog::GetCaptureMode() const {
-  base::subtle::Atomic32 capture_mode =
-      base::subtle::NoBarrier_Load(&effective_capture_mode_int32_);
-  return NetLogCaptureMode::FromInternalValue(capture_mode);
+bool NetLog::IsCapturing() const {
+  return base::subtle::NoBarrier_Load(&is_capturing_) != 0;
 }
 
 void NetLog::DeprecatedAddObserver(NetLog::ThreadSafeObserver* observer,
                                    NetLogCaptureMode capture_mode) {
-  DCHECK(capture_mode.enabled());
-
   base::AutoLock lock(lock_);
 
   DCHECK(!observer->net_log_);
-  DCHECK(!observer->capture_mode_.enabled());
   observers_.AddObserver(observer);
   observer->net_log_ = this;
   observer->capture_mode_ = capture_mode;
-  UpdateCaptureMode();
+  UpdateIsCapturing();
 }
 
 void NetLog::SetObserverCaptureMode(NetLog::ThreadSafeObserver* observer,
                                     NetLogCaptureMode capture_mode) {
-  DCHECK(capture_mode.enabled());
   base::AutoLock lock(lock_);
 
   DCHECK(observers_.HasObserver(observer));
   DCHECK_EQ(this, observer->net_log_);
-  DCHECK(observer->capture_mode_.enabled());
   observer->capture_mode_ = capture_mode;
-  UpdateCaptureMode();
 }
 
 void NetLog::DeprecatedRemoveObserver(NetLog::ThreadSafeObserver* observer) {
   base::AutoLock lock(lock_);
 
   DCHECK(observers_.HasObserver(observer));
   DCHECK_EQ(this, observer->net_log_);
-  DCHECK(observer->capture_mode_.enabled());
   observers_.RemoveObserver(observer);
   observer->net_log_ = NULL;
   observer->capture_mode_ = NetLogCaptureMode();
-  UpdateCaptureMode();
+  UpdateIsCapturing();
 }
 
-void NetLog::UpdateCaptureMode() {
+void NetLog::UpdateIsCapturing() {
   lock_.AssertAcquired();
-
-  // Accumulate the capture mode of all the observers to find the maximum level.
-  NetLogCaptureMode new_capture_mode = NetLogCaptureMode::None();
-  ObserverListBase<ThreadSafeObserver>::Iterator it(&observers_);
-  ThreadSafeObserver* observer;
-  while ((observer = it.GetNext()) != NULL) {
-    new_capture_mode =
-        NetLogCaptureMode::Max(new_capture_mode, observer->capture_mode());
-  }
-  base::subtle::NoBarrier_Store(&effective_capture_mode_int32_,
-                                new_capture_mode.ToInternalValue());
+  base::subtle::NoBarrier_Store(&is_capturing_,
+                                observers_.might_have_observers() ? 1 : 0);
 }
 
 // static
 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
   int64 delta_time = (time - base::TimeTicks()).InMilliseconds();
   return base::Int64ToString(delta_time);
 }
 
 // static
 const char* NetLog::EventTypeToString(EventType event) {
@@ skipping 83 matching lines @@
 NetLog::ParametersCallback NetLog::StringCallback(const char* name,
                                                   const base::string16* value) {
   DCHECK(value);
   return base::Bind(&NetLogString16Callback, name, value);
 }
 
 void NetLog::AddEntry(EventType type,
                       const Source& source,
                       EventPhase phase,
                       const NetLog::ParametersCallback* parameters_callback) {
-  if (!GetCaptureMode().enabled())
+  if (!IsCapturing())
     return;
   EntryData entry_data(type, source, phase, base::TimeTicks::Now(),
                        parameters_callback);
 
   // Notify all of the log observers.
   base::AutoLock lock(lock_);
   FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntryData(entry_data));
 }
 
 BoundNetLog::~BoundNetLog() {
@@ skipping 69 matching lines @@
     EndEvent(event_type, NetLog::IntegerCallback("net_error", net_error));
   }
 }
 
 void BoundNetLog::AddByteTransferEvent(NetLog::EventType event_type,
                                        int byte_count,
                                        const char* bytes) const {
   AddEvent(event_type, base::Bind(BytesTransferredCallback, byte_count, bytes));
 }
 
-NetLogCaptureMode BoundNetLog::GetCaptureMode() const {
+bool BoundNetLog::IsCapturing() const {
   CrashIfInvalid();
-
-  if (net_log_)
-    return net_log_->GetCaptureMode();
-  return NetLogCaptureMode();
+  return net_log_ && net_log_->IsCapturing();
 }
 
 // static
 BoundNetLog BoundNetLog::Make(NetLog* net_log, NetLog::SourceType source_type) {
   if (!net_log)
     return BoundNetLog();
 
   NetLog::Source source(source_type, net_log->NextID());
   return BoundNetLog(source, net_log);
 }
 
 void BoundNetLog::CrashIfInvalid() const {
   Liveness liveness = liveness_;
 
   if (liveness == ALIVE)
     return;
 
   base::debug::Alias(&liveness);
   CHECK_EQ(ALIVE, liveness);
 }
 
 }  // namespace net