Bug 1309129: enable redirecting of nICEr logging to NSPR logging. r=bwc

MozReview-Commit-ID: ESB6F0MlKdQ

--HG--
rename : media/mtransport/rlogringbuffer.cpp => media/mtransport/rlogconnector.cpp
rename : media/mtransport/rlogringbuffer.h => media/mtransport/rlogconnector.h
rename : media/mtransport/test/rlogringbuffer_unittest.cpp => media/mtransport/test/rlogconnector_unittest.cpp
extra : rebase_source : 33ea6c07b909c1972a2e9150241536ba56890609

media/mtransport/build/moz.build

@@ -12,7 +12,7 @@ EXPORTS.mtransport += [
     '../nricectx.h',
     '../nricemediastream.h',
     '../nriceresolverfake.h',
-    '../rlogringbuffer.h',
+    '../rlogconnector.h',
     '../runnable_utils.h',
     '../sigslot.h',
     '../simpletokenbucket.h',

media/mtransport/common.build

@@ -14,7 +14,7 @@ mtransport_lcppsrcs = [
     'nriceresolver.cpp',
     'nriceresolverfake.cpp',
     'nrinterfaceprioritizer.cpp',
-    'rlogringbuffer.cpp',
+    'rlogconnector.cpp',
     'simpletokenbucket.cpp',
     'stun_socket_filter.cpp',
     'test_nr_socket.cpp',

media/mtransport/nricectx.cpp

@@ -92,7 +92,7 @@ extern "C" {
 #include "nricemediastream.h"
 #include "nr_socket_prsock.h"
 #include "nrinterfaceprioritizer.h"
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 #include "test_nr_socket.h"
 
 namespace mozilla {
@@ -664,7 +664,7 @@ int NrIceCtx::SetNat(const RefPtr<TestNat>& aNat) {
 void NrIceCtx::internal_DeinitializeGlobal() {
   NR_reg_del((char *)"stun");
   NR_reg_del((char *)"ice");
-  RLogRingBuffer::DestroyInstance();
+  RLogConnector::DestroyInstance();
   nr_crypto_vtbl = nullptr;
   initialized = false;
 }
@@ -986,7 +986,7 @@ void NrIceCtx::SetConnectionState(ConnectionState state) {
   if (connection_state_ == ICE_CTX_FAILED) {
     MOZ_MTLOG(ML_INFO, "NrIceCtx(" << name_ << "): dumping r_log ringbuffer... ");
     std::deque<std::string> logs;
-    RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+    RLogConnector::GetInstance()->GetAny(0, &logs);
     for (auto l = logs.begin(); l != logs.end(); ++l) {
       MOZ_MTLOG(ML_INFO, *l);
     }

media/mtransport/rlogconnector.cpp

@@ -9,10 +9,11 @@
 
 #include <cstdarg>
 
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 
 #include <deque>
 #include <string>
+#include "logging.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/Move.h" // Pinch hitting for <utility> and std::move
 #include "mozilla/Mutex.h"
@@ -30,79 +31,104 @@ static int ringbuffer_vlog(int facility,
                            int level,
                            const char *format,
                            va_list ap) {
-  MOZ_ASSERT(mozilla::RLogRingBuffer::GetInstance());
+  MOZ_ASSERT(mozilla::RLogConnector::GetInstance());
   // I could be evil and printf right into a std::string, but unless this
   // shows up in profiling, it is not worth doing.
   char temp[4096];
   VsprintfLiteral(temp, format, ap);
 
-  mozilla::RLogRingBuffer::GetInstance()->Log(std::string(temp));
+  mozilla::RLogConnector::GetInstance()->Log(level, std::string(temp));
   return 0;
 }
 
+static mozilla::LogLevel rLogLvlToMozLogLvl(int level) {
+  switch (level) {
+    case LOG_EMERG:
+    case LOG_ALERT:
+    case LOG_CRIT:
+    case LOG_ERR:
+      return mozilla::LogLevel::Error;
+    case LOG_WARNING:
+      return mozilla::LogLevel::Warning;
+    case LOG_NOTICE:
+      return mozilla::LogLevel::Info;
+    case LOG_INFO:
+      return mozilla::LogLevel::Debug;
+    case LOG_DEBUG:
+    default:
+      return mozilla::LogLevel::Verbose;
+  }
+}
+
+MOZ_MTLOG_MODULE("nicer");
+
 namespace mozilla {
 
-RLogRingBuffer* RLogRingBuffer::instance;
+RLogConnector* RLogConnector::instance;
 
-RLogRingBuffer::RLogRingBuffer()
+RLogConnector::RLogConnector()
   : log_limit_(4096),
-    mutex_("RLogRingBuffer::mutex_"),
+    mutex_("RLogConnector::mutex_"),
     disableCount_(0) {
 }
 
-RLogRingBuffer::~RLogRingBuffer() {
+RLogConnector::~RLogConnector() {
 }
 
-void RLogRingBuffer::SetLogLimit(uint32_t new_limit) {
+void RLogConnector::SetLogLimit(uint32_t new_limit) {
   OffTheBooksMutexAutoLock lock(mutex_);
   log_limit_ = new_limit;
   RemoveOld();
 }
 
-void RLogRingBuffer::Log(std::string&& log) {
-  OffTheBooksMutexAutoLock lock(mutex_);
-  if (disableCount_ == 0) {
-    AddMsg(Move(log));
+void RLogConnector::Log(int level, std::string&& log) {
+  MOZ_MTLOG(rLogLvlToMozLogLvl(level), log);
+
+  if (level <= LOG_INFO) {
+    OffTheBooksMutexAutoLock lock(mutex_);
+    if (disableCount_ == 0) {
+      AddMsg(Move(log));
+    }
   }
 }
 
-void RLogRingBuffer::AddMsg(std::string&& msg) {
+void RLogConnector::AddMsg(std::string&& msg) {
   log_messages_.push_front(Move(msg));
   RemoveOld();
 }
 
-inline void RLogRingBuffer::RemoveOld() {
+inline void RLogConnector::RemoveOld() {
   if (log_messages_.size() > log_limit_) {
     log_messages_.resize(log_limit_);
   }
 }
 
-RLogRingBuffer* RLogRingBuffer::CreateInstance() {
+RLogConnector* RLogConnector::CreateInstance() {
   if (!instance) {
-    instance = new RLogRingBuffer;
+    instance = new RLogConnector;
     NR_reg_init(NR_REG_MODE_LOCAL);
-    r_log_set_extra_destination(LOG_INFO, &ringbuffer_vlog);
+    r_log_set_extra_destination(LOG_DEBUG, &ringbuffer_vlog);
   }
   return instance;
 }
 
-RLogRingBuffer* RLogRingBuffer::GetInstance() {
+RLogConnector* RLogConnector::GetInstance() {
   return instance;
 }
 
-void RLogRingBuffer::DestroyInstance() {
+void RLogConnector::DestroyInstance() {
   // First param is ignored when passing null
-  r_log_set_extra_destination(LOG_INFO, nullptr);
+  r_log_set_extra_destination(LOG_DEBUG, nullptr);
   delete instance;
   instance = nullptr;
 }
 
 // As long as at least one PeerConnection exists in a Private Window rlog messages will not
-// be saved in the RLogRingBuffer. This is necessary because the log_messages buffer
+// be saved in the RLogConnector. This is necessary because the log_messages buffer
 // is shared across all instances of PeerConnectionImpls. There is no way with the current
 // structure of r_log to run separate logs.
 
-void RLogRingBuffer::EnterPrivateMode() {
+void RLogConnector::EnterPrivateMode() {
   OffTheBooksMutexAutoLock lock(mutex_);
   ++disableCount_;
   MOZ_ASSERT(disableCount_ != 0);
@@ -112,7 +138,7 @@ void RLogRingBuffer::EnterPrivateMode() {
   }
 }
 
-void RLogRingBuffer::ExitPrivateMode() {
+void RLogConnector::ExitPrivateMode() {
   OffTheBooksMutexAutoLock lock(mutex_);
   MOZ_ASSERT(disableCount_ != 0);
 
@@ -121,12 +147,12 @@ void RLogRingBuffer::ExitPrivateMode() {
   }
 }
 
-void RLogRingBuffer::Clear() {
+void RLogConnector::Clear() {
   OffTheBooksMutexAutoLock lock(mutex_);
   log_messages_.clear();
 }
 
-void RLogRingBuffer::Filter(const std::string& substring,
+void RLogConnector::Filter(const std::string& substring,
                             uint32_t limit,
                             std::deque<std::string>* matching_logs) {
   std::vector<std::string> substrings;
@@ -144,7 +170,7 @@ inline bool AnySubstringMatches(const std::vector<std::string>& substrings,
   return false;
 }
 
-void RLogRingBuffer::FilterAny(const std::vector<std::string>& substrings,
+void RLogConnector::FilterAny(const std::vector<std::string>& substrings,
                                uint32_t limit,
                                std::deque<std::string>* matching_logs) {
   OffTheBooksMutexAutoLock lock(mutex_);

media/mtransport/rlogconnector.h

@@ -50,8 +50,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    debug purposes on an about:webrtc page or similar.
 */
 
-#ifndef rlogringbuffer_h__
-#define rlogringbuffer_h__
+#ifndef rlogconnector_h__
+#define rlogconnector_h__
 
 #include <stdint.h>
 
@@ -65,14 +65,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace mozilla {
 
-class RLogRingBuffer {
+class RLogConnector {
   public:
     /*
        NB: These are not threadsafe, nor are they safe to call during static
        init/deinit.
     */
-    static RLogRingBuffer* CreateInstance();
-    static RLogRingBuffer* GetInstance();
+    static RLogConnector* CreateInstance();
+    static RLogConnector* GetInstance();
     static void DestroyInstance();
 
     /*
@@ -95,7 +95,7 @@ class RLogRingBuffer {
     }
 
     void SetLogLimit(uint32_t new_limit);
-    void Log(std::string&& log);
+    void Log(int level, std::string&& log);
     void Clear();
 
     // Methods to signal when a PeerConnection exists in a Private Window.
@@ -103,12 +103,12 @@ class RLogRingBuffer {
     void ExitPrivateMode();
 
   private:
-    RLogRingBuffer();
-    ~RLogRingBuffer();
+    RLogConnector();
+    ~RLogConnector();
     void RemoveOld();
     void AddMsg(std::string&& msg);
 
-    static RLogRingBuffer* instance;
+    static RLogConnector* instance;
 
     /*
      * Might be worthwhile making this a circular buffer, but I think it is
@@ -121,9 +121,9 @@ class RLogRingBuffer {
     OffTheBooksMutex mutex_;
     uint32_t disableCount_;
 
-    DISALLOW_COPY_ASSIGN(RLogRingBuffer);
-}; // class RLogRingBuffer
+    DISALLOW_COPY_ASSIGN(RLogConnector);
+}; // class RLogConnector
 
 } // namespace mozilla
 
-#endif // rlogringbuffer_h__
+#endif // rlogconnector_h__

media/mtransport/test/gtest_ringbuffer_dumper.h

@@ -16,9 +16,9 @@
 
 #include "mtransport_test_utils.h"
 #include "runnable_utils.h"
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 
-using mozilla::RLogRingBuffer;
+using mozilla::RLogConnector;
 using mozilla::WrapRunnable;
 
 namespace test {
@@ -29,20 +29,20 @@ class RingbufferDumper : public ::testing::EmptyTestEventListener {
     {}
 
     void ClearRingBuffer_s() {
-      RLogRingBuffer::CreateInstance();
+      RLogConnector::CreateInstance();
       // Set limit to zero to clear the ringbuffer
-      RLogRingBuffer::GetInstance()->SetLogLimit(0);
-      RLogRingBuffer::GetInstance()->SetLogLimit(UINT32_MAX);
+      RLogConnector::GetInstance()->SetLogLimit(0);
+      RLogConnector::GetInstance()->SetLogLimit(UINT32_MAX);
     }
 
     void DestroyRingBuffer_s() {
-      RLogRingBuffer::DestroyInstance();
+      RLogConnector::DestroyInstance();
     }
 
     void DumpRingBuffer_s() {
       std::deque<std::string> logs;
       // Get an unlimited number of log lines, with no filter
-      RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+      RLogConnector::GetInstance()->GetAny(0, &logs);
       for (auto l = logs.begin(); l != logs.end(); ++l) {
         std::cout << *l << std::endl;
       }
@@ -64,7 +64,7 @@ class RingbufferDumper : public ::testing::EmptyTestEventListener {
     // Called after a failed assertion or a SUCCEED() invocation.
     virtual void OnTestPartResult(const ::testing::TestPartResult& testResult) {
       if (testResult.failed()) {
-        // Dump (and empty) the RLogRingBuffer
+        // Dump (and empty) the RLogConnector
         mozilla::SyncRunnable::DispatchToThread(
             test_utils_->sts_target(),
             WrapRunnable(this, &RingbufferDumper::DumpRingBuffer_s));

media/mtransport/test/ice_unittest.cpp

@@ -31,7 +31,7 @@
 #include "nriceresolver.h"
 #include "nrinterfaceprioritizer.h"
 #include "gtest_ringbuffer_dumper.h"
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 #include "runnable_utils.h"
 #include "stunserver.h"
 #include "nr_socket_prsock.h"
@@ -141,9 +141,9 @@ public:
         WrapRunnableNM(&NrIceCtx::internal_DeinitializeGlobal),
         NS_DISPATCH_SYNC);
 
-    // NB: NrIceCtx::internal_DeinitializeGlobal destroys the RLogRingBuffer
+    // NB: NrIceCtx::internal_DeinitializeGlobal destroys the RLogConnector
     // singleton.
-    RLogRingBuffer::CreateInstance();
+    RLogConnector::CreateInstance();
 
     test_utils_->sts_target()->Dispatch(
         WrapRunnableNM(&TestStunServer::GetInstance, AF_INET),
@@ -171,7 +171,7 @@ public:
     test_utils_->sts_target()->Dispatch(
         WrapRunnableNM(&TestStunTcpServer::ShutdownInstance), NS_DISPATCH_SYNC);
 
-    RLogRingBuffer::DestroyInstance();
+    RLogConnector::DestroyInstance();
 
     MtransportTest::TearDown();
   }
@@ -3646,7 +3646,7 @@ TEST_F(WebRtcIceConnectTest, TestPollCandPairsDuringConnect) {
   ASSERT_TRUE(ContainsSucceededPair(pairs2));
 }
 
-TEST_F(WebRtcIceConnectTest, TestRLogRingBuffer) {
+TEST_F(WebRtcIceConnectTest, TestRLogConnector) {
   AddStream(1);
   ASSERT_TRUE(Gather());
 
@@ -3674,7 +3674,7 @@ TEST_F(WebRtcIceConnectTest, TestRLogRingBuffer) {
     std::deque<std::string> logs;
     std::string substring("CAND-PAIR(");
     substring += p->codeword;
-    RLogRingBuffer::GetInstance()->Filter(substring, 0, &logs);
+    RLogConnector::GetInstance()->Filter(substring, 0, &logs);
     ASSERT_NE(0U, logs.size());
   }
 
@@ -3682,7 +3682,7 @@ TEST_F(WebRtcIceConnectTest, TestRLogRingBuffer) {
     std::deque<std::string> logs;
     std::string substring("CAND-PAIR(");
     substring += p->codeword;
-    RLogRingBuffer::GetInstance()->Filter(substring, 0, &logs);
+    RLogConnector::GetInstance()->Filter(substring, 0, &logs);
     ASSERT_NE(0U, logs.size());
   }
 }

media/mtransport/test/moz.build

@@ -11,7 +11,7 @@ if CONFIG['OS_TARGET'] != 'WINNT' and CONFIG['MOZ_WIDGET_TOOLKIT'] != 'gonk':
         'multi_tcp_socket_unittest.cpp',
         'nrappkit_unittest.cpp',
         'proxy_tunnel_socket_unittest.cpp',
-        'rlogringbuffer_unittest.cpp',
+        'rlogconnector_unittest.cpp',
         'runnable_utils_unittest.cpp',
         'simpletokenbucket_unittest.cpp',
         'sockettransportservice_unittest.cpp',

media/mtransport/test/rlogconnector_unittest.cpp

@@ -6,7 +6,7 @@
 
 /* Original author: bcampen@mozilla.com */
 
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 
 extern "C" {
 #include "registry.h"
@@ -21,17 +21,17 @@ extern "C" {
 #include <string>
 #include <vector>
 
-using mozilla::RLogRingBuffer;
+using mozilla::RLogConnector;
 
 int NR_LOG_TEST = 0;
 
-class RLogRingBufferTest : public ::testing::Test {
+class RLogConnectorTest : public ::testing::Test {
   public:
-    RLogRingBufferTest() {
+    RLogConnectorTest() {
       Init();
     }
 
-    ~RLogRingBufferTest() {
+    ~RLogConnectorTest() {
       Free();
     }
 
@@ -39,16 +39,16 @@ class RLogRingBufferTest : public ::testing::Test {
       NR_reg_init(NR_REG_MODE_LOCAL);
       r_log_init();
       /* Would be nice to be able to unregister in the fixture */
-      const char* facility = "rlogringbuffer_test";
+      const char* facility = "rlogconnector_test";
       r_log_register(const_cast<char*>(facility), &NR_LOG_TEST);
     }
 
     void Init() {
-      RLogRingBuffer::CreateInstance();
+      RLogConnector::CreateInstance();
     }
 
     void Free() {
-      RLogRingBuffer::DestroyInstance();
+      RLogConnector::DestroyInstance();
     }
 
     void ReInit() {
@@ -57,106 +57,106 @@ class RLogRingBufferTest : public ::testing::Test {
     }
 };
 
-TEST_F(RLogRingBufferTest, TestGetFree) {
-  RLogRingBuffer* instance = RLogRingBuffer::GetInstance();
+TEST_F(RLogConnectorTest, TestGetFree) {
+  RLogConnector* instance = RLogConnector::GetInstance();
   ASSERT_NE(nullptr, instance);
 }
 
-TEST_F(RLogRingBufferTest, TestFilterEmpty) {
+TEST_F(RLogConnectorTest, TestFilterEmpty) {
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ(0U, logs.size());
 }
 
-TEST_F(RLogRingBufferTest, TestBasicFilter) {
+TEST_F(RLogConnectorTest, TestBasicFilter) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->Filter("Test", 0, &logs);
+  RLogConnector::GetInstance()->Filter("Test", 0, &logs);
   ASSERT_EQ(1U, logs.size());
 }
 
-TEST_F(RLogRingBufferTest, TestBasicFilterContent) {
+TEST_F(RLogConnectorTest, TestBasicFilterContent) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->Filter("Test", 0, &logs);
+  RLogConnector::GetInstance()->Filter("Test", 0, &logs);
   ASSERT_EQ("Test", logs.back());
 }
 
-TEST_F(RLogRingBufferTest, TestFilterAnyFrontMatch) {
+TEST_F(RLogConnectorTest, TestFilterAnyFrontMatch) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test");
   std::vector<std::string> substrings;
   substrings.push_back("foo");
   substrings.push_back("Test");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->FilterAny(substrings, 0, &logs);
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
   ASSERT_EQ("Test", logs.back());
 }
 
-TEST_F(RLogRingBufferTest, TestFilterAnyBackMatch) {
+TEST_F(RLogConnectorTest, TestFilterAnyBackMatch) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test");
   std::vector<std::string> substrings;
   substrings.push_back("Test");
   substrings.push_back("foo");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->FilterAny(substrings, 0, &logs);
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
   ASSERT_EQ("Test", logs.back());
 }
 
-TEST_F(RLogRingBufferTest, TestFilterAnyBothMatch) {
+TEST_F(RLogConnectorTest, TestFilterAnyBothMatch) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test");
   std::vector<std::string> substrings;
   substrings.push_back("Tes");
   substrings.push_back("est");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->FilterAny(substrings, 0, &logs);
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
   ASSERT_EQ("Test", logs.back());
 }
 
-TEST_F(RLogRingBufferTest, TestFilterAnyNeitherMatch) {
+TEST_F(RLogConnectorTest, TestFilterAnyNeitherMatch) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test");
   std::vector<std::string> substrings;
   substrings.push_back("tes");
   substrings.push_back("esT");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->FilterAny(substrings, 0, &logs);
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
   ASSERT_EQ(0U, logs.size());
 }
 
-TEST_F(RLogRingBufferTest, TestAllMatch) {
+TEST_F(RLogConnectorTest, TestAllMatch) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ(2U, logs.size());
 }
 
-TEST_F(RLogRingBufferTest, TestOrder) {
+TEST_F(RLogConnectorTest, TestOrder) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ("Test2", logs.back());
   ASSERT_EQ("Test1", logs.front());
 }
 
-TEST_F(RLogRingBufferTest, TestNoMatch) {
+TEST_F(RLogConnectorTest, TestNoMatch) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->Filter("foo", 0, &logs);
+  RLogConnector::GetInstance()->Filter("foo", 0, &logs);
   ASSERT_EQ(0U, logs.size());
 }
 
-TEST_F(RLogRingBufferTest, TestSubstringFilter) {
+TEST_F(RLogConnectorTest, TestSubstringFilter) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->Filter("t1", 0, &logs);
+  RLogConnector::GetInstance()->Filter("t1", 0, &logs);
   ASSERT_EQ(1U, logs.size());
   ASSERT_EQ("Test1", logs.back());
 }
 
-TEST_F(RLogRingBufferTest, TestFilterLimit) {
+TEST_F(RLogConnectorTest, TestFilterLimit) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   r_log(NR_LOG_TEST, LOG_INFO, "Test3");
@@ -164,13 +164,13 @@ TEST_F(RLogRingBufferTest, TestFilterLimit) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test5");
   r_log(NR_LOG_TEST, LOG_INFO, "Test6");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->Filter("Test", 2, &logs);
+  RLogConnector::GetInstance()->Filter("Test", 2, &logs);
   ASSERT_EQ(2U, logs.size());
   ASSERT_EQ("Test6", logs.back());
   ASSERT_EQ("Test5", logs.front());
 }
 
-TEST_F(RLogRingBufferTest, TestFilterAnyLimit) {
+TEST_F(RLogConnectorTest, TestFilterAnyLimit) {
   r_log(NR_LOG_TEST, LOG_INFO, "TestOne");
   r_log(NR_LOG_TEST, LOG_INFO, "TestTwo");
   r_log(NR_LOG_TEST, LOG_INFO, "TestThree");
@@ -184,14 +184,14 @@ TEST_F(RLogRingBufferTest, TestFilterAnyLimit) {
   substrings.push_back("r");
   substrings.push_back("S");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->FilterAny(substrings, 2, &logs);
+  RLogConnector::GetInstance()->FilterAny(substrings, 2, &logs);
   ASSERT_EQ(2U, logs.size());
   ASSERT_EQ("TestSix", logs.back());
   ASSERT_EQ("TestFour", logs.front());
 }
 
-TEST_F(RLogRingBufferTest, TestLimit) {
-  RLogRingBuffer::GetInstance()->SetLogLimit(3);
+TEST_F(RLogConnectorTest, TestLimit) {
+  RLogConnector::GetInstance()->SetLogLimit(3);
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   r_log(NR_LOG_TEST, LOG_INFO, "Test3");
@@ -199,58 +199,58 @@ TEST_F(RLogRingBufferTest, TestLimit) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test5");
   r_log(NR_LOG_TEST, LOG_INFO, "Test6");
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ(3U, logs.size());
   ASSERT_EQ("Test6", logs.back());
   ASSERT_EQ("Test4", logs.front());
 }
 
-TEST_F(RLogRingBufferTest, TestLimitBulkDiscard) {
+TEST_F(RLogConnectorTest, TestLimitBulkDiscard) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   r_log(NR_LOG_TEST, LOG_INFO, "Test3");
   r_log(NR_LOG_TEST, LOG_INFO, "Test4");
   r_log(NR_LOG_TEST, LOG_INFO, "Test5");
   r_log(NR_LOG_TEST, LOG_INFO, "Test6");
-  RLogRingBuffer::GetInstance()->SetLogLimit(3);
+  RLogConnector::GetInstance()->SetLogLimit(3);
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ(3U, logs.size());
   ASSERT_EQ("Test6", logs.back());
   ASSERT_EQ("Test4", logs.front());
 }
 
-TEST_F(RLogRingBufferTest, TestIncreaseLimit) {
-  RLogRingBuffer::GetInstance()->SetLogLimit(3);
+TEST_F(RLogConnectorTest, TestIncreaseLimit) {
+  RLogConnector::GetInstance()->SetLogLimit(3);
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   r_log(NR_LOG_TEST, LOG_INFO, "Test3");
   r_log(NR_LOG_TEST, LOG_INFO, "Test4");
   r_log(NR_LOG_TEST, LOG_INFO, "Test5");
   r_log(NR_LOG_TEST, LOG_INFO, "Test6");
-  RLogRingBuffer::GetInstance()->SetLogLimit(300);
+  RLogConnector::GetInstance()->SetLogLimit(300);
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ(3U, logs.size());
   ASSERT_EQ("Test6", logs.back());
   ASSERT_EQ("Test4", logs.front());
 }
 
-TEST_F(RLogRingBufferTest, TestClear) {
+TEST_F(RLogConnectorTest, TestClear) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   r_log(NR_LOG_TEST, LOG_INFO, "Test3");
   r_log(NR_LOG_TEST, LOG_INFO, "Test4");
   r_log(NR_LOG_TEST, LOG_INFO, "Test5");
   r_log(NR_LOG_TEST, LOG_INFO, "Test6");
-  RLogRingBuffer::GetInstance()->SetLogLimit(0);
-  RLogRingBuffer::GetInstance()->SetLogLimit(4096);
+  RLogConnector::GetInstance()->SetLogLimit(0);
+  RLogConnector::GetInstance()->SetLogLimit(4096);
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ(0U, logs.size());
 }
 
-TEST_F(RLogRingBufferTest, TestReInit) {
+TEST_F(RLogConnectorTest, TestReInit) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test1");
   r_log(NR_LOG_TEST, LOG_INFO, "Test2");
   r_log(NR_LOG_TEST, LOG_INFO, "Test3");
@@ -259,6 +259,6 @@ TEST_F(RLogRingBufferTest, TestReInit) {
   r_log(NR_LOG_TEST, LOG_INFO, "Test6");
   ReInit();
   std::deque<std::string> logs;
-  RLogRingBuffer::GetInstance()->GetAny(0, &logs);
+  RLogConnector::GetInstance()->GetAny(0, &logs);
   ASSERT_EQ(0U, logs.size());
 }

media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp

@@ -95,7 +95,7 @@
 #include "nsIScriptGlobalObject.h"
 #include "MediaStreamGraph.h"
 #include "DOMMediaStream.h"
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 #include "WebrtcGlobalInformation.h"
 #include "mozilla/dom/Event.h"
 #include "nsIDOMCustomEvent.h"
@@ -347,7 +347,7 @@ PeerConnectionImpl::PeerConnectionImpl(const GlobalObject* aGlobal)
 {
 #if !defined(MOZILLA_EXTERNAL_LINKAGE)
   MOZ_ASSERT(NS_IsMainThread());
-  auto log = RLogRingBuffer::CreateInstance();
+  auto log = RLogConnector::CreateInstance();
   if (aGlobal) {
     mWindow = do_QueryInterface(aGlobal->GetAsSupports());
     if (IsPrivateBrowsing(mWindow)) {
@@ -381,7 +381,7 @@ PeerConnectionImpl::~PeerConnectionImpl()
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
 #if !defined(MOZILLA_EXTERNAL_LINKAGE)
   if (mPrivateWindow) {
-    auto * log = RLogRingBuffer::GetInstance();
+    auto * log = RLogConnector::GetInstance();
     if (log) {
       log->ExitPrivateMode();
     }

media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h

@@ -739,7 +739,7 @@ private:
 
   // When ICE completes, we record a bunch of statistics that outlive the
   // PeerConnection. This is just telemetry right now, but this can also
-  // include things like dumping the RLogRingbuffer somewhere, saving away
+  // include things like dumping the RLogConnector somewhere, saving away
   // an RTCStatsReport somewhere so it can be inspected after the call is over,
   // or other things.
   void RecordLongtermICEStatistics();

media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp

@@ -30,7 +30,7 @@
 #include "mozilla/StaticMutex.h"
 #include "mozilla/RefPtr.h"
 
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 #include "runnable_utils.h"
 #include "PeerConnectionCtx.h"
 #include "PeerConnectionImpl.h"
@@ -359,7 +359,7 @@ static void GetLogging_s(WebrtcGlobalChild* aThisChild,
                          const std::string& aPattern)
 {
   // Request log while not on the main thread.
-  RLogRingBuffer* logs = RLogRingBuffer::GetInstance();
+  RLogConnector* logs = RLogConnector::GetInstance();
   nsAutoPtr<std::deque<std::string>> result(new std::deque<std::string>);
   // Might not exist yet.
   if (logs) {
@@ -558,7 +558,7 @@ RunLogQuery(const nsCString& aPattern,
 static void ClearLogs_s()
 {
   // Make call off main thread.
-  RLogRingBuffer* logs = RLogRingBuffer::GetInstance();
+  RLogConnector* logs = RLogConnector::GetInstance();
   if (logs) {
     logs->Clear();
   }

media/webrtc/signaling/test/signaling_unittests.cpp

@@ -36,7 +36,7 @@
 #include "nsQueryObject.h"
 #include "nsWeakReference.h"
 #include "nricectx.h"
-#include "rlogringbuffer.h"
+#include "rlogconnector.h"
 #include "mozilla/SyncRunnable.h"
 #include "logging.h"
 #include "stunserver.h"