Refactor NetLog::LogLevel --> NetLogCaptureMode.

net/log/net_log_unittest.cc

 // Copyright (c) 2013 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_unittest.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
 
 const int kThreads = 10;
 const int kEvents = 100;
 
-base::Value* NetLogLevelCallback(NetLog::LogLevel log_level) {
+base::Value* NetCaptureModeCallback(NetLogCaptureMode capture_mode) {
   base::DictionaryValue* dict = new base::DictionaryValue();
-  dict->SetInteger("log_level", log_level);
+  dict->SetInteger("log_level", capture_mode.level());
   return dict;
 }
 
 TEST(NetLogTest, Basic) {
   CapturingNetLog net_log;
   CapturingNetLog::CapturedEntryList entries;
   net_log.GetEntries(&entries);
   EXPECT_EQ(0u, entries.size());
 
   net_log.AddGlobalEntry(NetLog::TYPE_CANCELLED);
 
   net_log.GetEntries(&entries);
   ASSERT_EQ(1u, entries.size());
   EXPECT_EQ(NetLog::TYPE_CANCELLED, entries[0].type);
   EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
   EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
   EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
   EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
   EXPECT_FALSE(entries[0].params);
 }
 
-// Check that the correct LogLevel is sent to NetLog Value callbacks.
-TEST(NetLogTest, LogLevels) {
+// Check that the correct CaptureMode is sent to NetLog Value callbacks.
+TEST(NetLogTest, CaptureModes) {
   CapturingNetLog net_log;
-  for (int log_level = NetLog::LOG_ALL; log_level < NetLog::LOG_NONE;
-       ++log_level) {
-    net_log.SetLogLevel(static_cast<NetLog::LogLevel>(log_level));
-    EXPECT_EQ(log_level, net_log.GetLogLevel());
+
+  NetLogCaptureMode kModes[] = {NetLogCaptureMode::All(),
+                                NetLogCaptureMode::StripPrivateData(),
+                                NetLogCaptureMode::AllButBytes()};
+
+  for (NetLogCaptureMode mode : kModes) {
+    net_log.SetCaptureMode(mode);
+    EXPECT_EQ(mode.level(), net_log.GetCaptureMode().level());
 
     net_log.AddGlobalEntry(NetLog::TYPE_SOCKET_ALIVE,
-                           base::Bind(NetLogLevelCallback));
+                           base::Bind(NetCaptureModeCallback));
 
     CapturingNetLog::CapturedEntryList entries;
     net_log.GetEntries(&entries);
 
     ASSERT_EQ(1u, entries.size());
     EXPECT_EQ(NetLog::TYPE_SOCKET_ALIVE, entries[0].type);
     EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
     EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
     EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
     EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
 
-    int logged_log_level;
-    ASSERT_TRUE(entries[0].GetIntegerValue("log_level", &logged_log_level));
-    EXPECT_EQ(log_level, logged_log_level);
+    int logged_capture_mode;
+    ASSERT_TRUE(entries[0].GetIntegerValue("log_level", &logged_capture_mode));
+    EXPECT_EQ(mode.level(), logged_capture_mode);
 
     net_log.Clear();
   }
 }
 
 class CountingObserver : public NetLog::ThreadSafeObserver {
  public:
   CountingObserver() : count_(0) {}
 
   ~CountingObserver() override {
@@ skipping 25 matching lines @@
     values_.push_back(dict);
   }
 
   size_t GetNumValues() const { return values_.size(); }
   base::DictionaryValue* GetValue(size_t index) const { return values_[index]; }
 
  private:
   ScopedVector<base::DictionaryValue> values_;
 };
 
-base::Value* LogLevelToValue(NetLog::LogLevel log_level) {
-  return new base::FundamentalValue(log_level);
+base::Value* CaptureModeToValue(NetLogCaptureMode capture_mode) {
+  return new base::FundamentalValue(capture_mode.level());
 }
 
 void AddEvent(NetLog* net_log) {
-  net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED, base::Bind(LogLevelToValue));
+  net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED,
+                          base::Bind(CaptureModeToValue));
 }
 
 // A thread that waits until an event has been signalled before calling
 // RunTestThread.
 class NetLogTestThread : public base::SimpleThread {
  public:
   NetLogTestThread()
       : base::SimpleThread("NetLogTest"), net_log_(NULL), start_event_(NULL) {}
 
   // We'll wait for |start_event| to be triggered before calling a subclass's
@@ skipping 43 matching lines @@
  public:
   AddRemoveObserverTestThread() {}
 
   ~AddRemoveObserverTestThread() override { EXPECT_TRUE(!observer_.net_log()); }
 
  private:
   void RunTestThread() override {
     for (int i = 0; i < kEvents; ++i) {
       ASSERT_FALSE(observer_.net_log());
 
-      net_log_->DeprecatedAddObserver(&observer_, NetLog::LOG_ALL_BUT_BYTES);
+      net_log_->DeprecatedAddObserver(&observer_,
+                                      NetLogCaptureMode::AllButBytes());
       ASSERT_EQ(net_log_, observer_.net_log());
-      ASSERT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer_.log_level());
-      ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL_BUT_BYTES);
+      ASSERT_EQ(NetLogCaptureMode::AllButBytes(), observer_.capture_mode());
+      ASSERT_GE(net_log_->GetCaptureMode().level(),
+                NetLogCaptureMode::ALL_BUT_BYTES);
 
-      net_log_->SetObserverLogLevel(&observer_, NetLog::LOG_ALL);
+      net_log_->SetObserverCaptureMode(&observer_, NetLogCaptureMode::All());
       ASSERT_EQ(net_log_, observer_.net_log());
-      ASSERT_EQ(NetLog::LOG_ALL, observer_.log_level());
-      ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL);
+      ASSERT_EQ(NetLogCaptureMode::All(), observer_.capture_mode());
+      ASSERT_GE(net_log_->GetCaptureMode().level(), NetLogCaptureMode::ALL);
 
       net_log_->DeprecatedRemoveObserver(&observer_);
       ASSERT_TRUE(!observer_.net_log());
     }
   }
 
   CountingObserver observer_;
 
   DISALLOW_COPY_AND_ASSIGN(AddRemoveObserverTestThread);
 };
@@ skipping 17 matching lines @@
 }
 
 // Makes sure that events on multiple threads are dispatched to all observers.
 TEST(NetLogTest, NetLogEventThreads) {
   NetLog net_log;
 
   // Attach some observers.  Since they're created after |net_log|, they'll
   // safely detach themselves on destruction.
   CountingObserver observers[3];
   for (size_t i = 0; i < arraysize(observers); ++i)
-    net_log.DeprecatedAddObserver(&observers[i], NetLog::LOG_ALL);
+    net_log.DeprecatedAddObserver(&observers[i], NetLogCaptureMode::All());
 
   // Run a bunch of threads to completion, each of which will emit events to
   // |net_log|.
   RunTestThreads<AddEventsTestThread>(&net_log);
 
   // Check that each observer saw the emitted events.
   const int kTotalEvents = kThreads * kEvents;
   for (size_t i = 0; i < arraysize(observers); ++i)
     EXPECT_EQ(kTotalEvents, observers[i].count());
 }
 
 // Test adding and removing a single observer.
 TEST(NetLogTest, NetLogAddRemoveObserver) {
   NetLog net_log;
   CountingObserver observer;
 
   AddEvent(&net_log);
   EXPECT_EQ(0, observer.count());
   EXPECT_EQ(NULL, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel());
+  EXPECT_FALSE(net_log.GetCaptureMode().enabled());
 
   // Add the observer and add an event.
-  net_log.DeprecatedAddObserver(&observer, NetLog::LOG_ALL_BUT_BYTES);
+  net_log.DeprecatedAddObserver(&observer, NetLogCaptureMode::AllButBytes());
   EXPECT_EQ(&net_log, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer.log_level());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
+  EXPECT_EQ(NetLogCaptureMode::AllButBytes(), observer.capture_mode());
+  EXPECT_EQ(NetLogCaptureMode::AllButBytes(), net_log.GetCaptureMode());
 
   AddEvent(&net_log);
   EXPECT_EQ(1, observer.count());
 
   // Change the observer's logging level and add an event.
-  net_log.SetObserverLogLevel(&observer, NetLog::LOG_ALL);
+  net_log.SetObserverCaptureMode(&observer, NetLogCaptureMode::All());
   EXPECT_EQ(&net_log, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_ALL, observer.log_level());
-  EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel());
+  EXPECT_EQ(NetLogCaptureMode::All(), observer.capture_mode());
+  EXPECT_EQ(NetLogCaptureMode::All(), net_log.GetCaptureMode());
 
   AddEvent(&net_log);
   EXPECT_EQ(2, observer.count());
 
   // Remove observer and add an event.
   net_log.DeprecatedRemoveObserver(&observer);
   EXPECT_EQ(NULL, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel());
+  EXPECT_FALSE(net_log.GetCaptureMode().enabled());
 
   AddEvent(&net_log);
   EXPECT_EQ(2, observer.count());
 
   // Add the observer a final time, and add an event.
-  net_log.DeprecatedAddObserver(&observer, NetLog::LOG_ALL);
+  net_log.DeprecatedAddObserver(&observer, NetLogCaptureMode::All());
   EXPECT_EQ(&net_log, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_ALL, observer.log_level());
-  EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel());
+  EXPECT_EQ(NetLogCaptureMode::All(), observer.capture_mode());
+  EXPECT_EQ(NetLogCaptureMode::All(), net_log.GetCaptureMode());
 
   AddEvent(&net_log);
   EXPECT_EQ(3, observer.count());
 }
 
 // Test adding and removing two observers at different log levels.
 TEST(NetLogTest, NetLogTwoObservers) {
   NetLog net_log;
   LoggingObserver observer[2];
 
   // Add first observer.
-  net_log.DeprecatedAddObserver(&observer[0], NetLog::LOG_ALL_BUT_BYTES);
+  net_log.DeprecatedAddObserver(&observer[0], NetLogCaptureMode::AllButBytes());
   EXPECT_EQ(&net_log, observer[0].net_log());
   EXPECT_EQ(NULL, observer[1].net_log());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
+  EXPECT_EQ(NetLogCaptureMode::AllButBytes(), observer[0].capture_mode());
+  EXPECT_EQ(NetLogCaptureMode::AllButBytes(), net_log.GetCaptureMode());
 
   // Add second observer observer.
-  net_log.DeprecatedAddObserver(&observer[1], NetLog::LOG_ALL);
+  net_log.DeprecatedAddObserver(&observer[1], NetLogCaptureMode::All());
   EXPECT_EQ(&net_log, observer[0].net_log());
   EXPECT_EQ(&net_log, observer[1].net_log());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
-  EXPECT_EQ(NetLog::LOG_ALL, observer[1].log_level());
-  EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel());
+  EXPECT_EQ(NetLogCaptureMode::AllButBytes(), observer[0].capture_mode());
+  EXPECT_EQ(NetLogCaptureMode::All(), observer[1].capture_mode());
+  EXPECT_EQ(NetLogCaptureMode::All(), net_log.GetCaptureMode());
 
   // Add event and make sure both observers receive it at their respective log
   // levels.
   int param;
   AddEvent(&net_log);
   ASSERT_EQ(1U, observer[0].GetNumValues());
   ASSERT_TRUE(observer[0].GetValue(0)->GetInteger("params", &param));
-  EXPECT_EQ(observer[0].log_level(), param);
+  EXPECT_EQ(observer[0].capture_mode().level(), param);
   ASSERT_EQ(1U, observer[1].GetNumValues());
   ASSERT_TRUE(observer[1].GetValue(0)->GetInteger("params", &param));
-  EXPECT_EQ(observer[1].log_level(), param);
+  EXPECT_EQ(observer[1].capture_mode().level(), param);
 
   // Remove second observer.
   net_log.DeprecatedRemoveObserver(&observer[1]);
   EXPECT_EQ(&net_log, observer[0].net_log());
   EXPECT_EQ(NULL, observer[1].net_log());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
+  EXPECT_EQ(NetLogCaptureMode::AllButBytes(), observer[0].capture_mode());
+  EXPECT_EQ(NetLogCaptureMode::AllButBytes(), net_log.GetCaptureMode());
 
   // Add event and make sure only second observer gets it.
   AddEvent(&net_log);
   EXPECT_EQ(2U, observer[0].GetNumValues());
   EXPECT_EQ(1U, observer[1].GetNumValues());
 
   // Remove first observer.
   net_log.DeprecatedRemoveObserver(&observer[0]);
   EXPECT_EQ(NULL, observer[0].net_log());
   EXPECT_EQ(NULL, observer[1].net_log());
-  EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel());
+  EXPECT_FALSE(net_log.GetCaptureMode().enabled());
 
   // Add event and make sure neither observer gets it.
   AddEvent(&net_log);
   EXPECT_EQ(2U, observer[0].GetNumValues());
   EXPECT_EQ(1U, observer[1].GetNumValues());
 }
 
 // Makes sure that adding and removing observers simultaneously on different
 // threads works.
 TEST(NetLogTest, NetLogAddRemoveObserverThreads) {
   NetLog net_log;
 
   // Run a bunch of threads to completion, each of which will repeatedly add
   // and remove an observer, and set its logging level.
   RunTestThreads<AddRemoveObserverTestThread>(&net_log);
 }
 
 }  // namespace
 
 }  // namespace net