Moving ScopedMockLog from net/test to base/test.

base/test/scoped_mock_log.h

 // Copyright 2014 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_QUIC_TEST_TOOLS_SCOPED_MOCK_LOG_H_
-#define NET_QUIC_TEST_TOOLS_SCOPED_MOCK_LOG_H_
+#ifndef BASE_TEST_SCOPED_MOCK_LOG_H_
+#define BASE_TEST_SCOPED_MOCK_LOG_H_
+
+#include <string>
 
 #include "base/logging.h"
+#include "base/synchronization/lock.h"
 #include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
 
-namespace net {
-namespace test {

[rvargas (doing something else), 2015/03/03 19:45:34]

Almost all files on the new destination are outside of test::, but I lean
towards thinking that test stuff is different enough from normal code to justify
the extra namespace. Besides, looks like the last file added here has
base::test::. I think we should keep this namespace.

[Łukasz Anforowicz, 2015/03/04 00:23:01]

Good point.  I was torn on this myself and ended up trying to be consistent. 
I've changed to base::test as suggested.

+namespace base {
 
 // A ScopedMockLog object intercepts LOG() messages issued during its
 // lifespan.  Using this together with gMock, it's very easy to test
 // how a piece of code calls LOG().  The typical usage:
 //
 //   TEST(FooTest, LogsCorrectly) {
 //     ScopedMockLog log;
 //
 //     // We expect the WARNING "Something bad!" exactly twice.
 //     EXPECT_CALL(log, Log(WARNING, _, "Something bad!"))
 //         .Times(2);
 //
 //     // We allow foo.cc to call LOG(INFO) any number of times.
 //     EXPECT_CALL(log, Log(INFO, HasSubstr("/foo.cc"), _))
 //         .Times(AnyNumber());
 //
 //     log.StartCapturingLogs();  // Call this after done setting expectations.
 //     Foo();  // Exercises the code under test.
 //   }
 //
 // CAVEAT: base/logging does not allow a thread to call LOG() again
 // when it's already inside a LOG() call.  Doing so will cause a
 // deadlock.  Therefore, it's the user's responsibility to not call
 // LOG() in an action triggered by ScopedMockLog::Log().  You may call
 // RAW_LOG() instead.
 class ScopedMockLog {

[rvargas (doing something else), 2015/03/03 19:45:34]

I generally don't like "Scoped" named classes unless they wrap another type for
the sole purpose of providing RAII semantics. That's not the case here so we
should drop that prefix.

[Łukasz Anforowicz, 2015/03/04 00:23:01]

Done.

  public:
   // Creates a ScopedMockLog object that is not capturing logs.
   // If it were to start to capture logs, it could be a problem if

[rvargas (doing something else), 2015/03/03 19:45:34]

nit: comments should wrap as close to the limit as possible (this file is not
following that).

[Łukasz Anforowicz, 2015/03/04 00:23:01]

I re-wrapped where it was saving lines and/or where I felt it was improving
readability.

   // some other threads already exist and are logging, as the user
   // hasn't had a chance to set up expectation on this object yet
   // (calling a mock method before setting the expectation is
   // UNDEFINED behavior).
   ScopedMockLog();
 
   // When the object is destructed, it stops intercepting logs.
   ~ScopedMockLog();
 
   // Starts log capturing if the object isn't already doing so.
   // Otherwise crashes.  Usually this method is called in the same
   // thread that created this object.  It is the user's responsibility
   // to not call this method if another thread may be calling it or
   // StopCapturingLogs() at the same time.

[rvargas (doing something else), 2015/03/03 19:45:34]

This comment looks stale now.

[Łukasz Anforowicz, 2015/03/04 00:23:01]

Oh, right.  Thanks.

   void StartCapturingLogs();
 
   // Stops log capturing if the object is capturing logs.  Otherwise
   // crashes.  Usually this method is called in the same thread that
   // created this object.  It is the user's responsibility to not call
   // this method if another thread may be calling it or
   // StartCapturingLogs() at the same time.
   void StopCapturingLogs();
 
   // Sets the Log Message Handler that gets passed every log message before

[rvargas (doing something else), 2015/03/03 19:45:34]

nit: This is the documentation of logging::SetLogMessageHandler, which is
confusing given that this is a message handler.

[Łukasz Anforowicz, 2015/03/04 00:23:01]

Good catch.  I reworded the comment.

   // it's sent to other log destinations (if any).
   // Returns true to signal that it handled the message and the message
   // should not be sent to other log destinations.
-  MOCK_METHOD5(Log, bool(int severity,
-                         const char* file,
-                         int line,
-                         size_t message_start,
-                         const std::string& str));
+  MOCK_METHOD5(Log,
+               bool(int severity,
+                    const char* file,
+                    int line,
+                    size_t message_start,
+                    const std::string& str));
 
  private:
   // The currently active scoped mock log.
   static ScopedMockLog* g_instance_;
 
+  // Lock protecting access to g_instance_.
+  static Lock g_lock;
+
   // Static function which is set as the logging message handler.
   // Called once for each message.
   static bool LogMessageHandler(int severity,
                                 const char* file,
                                 int line,
                                 size_t message_start,
                                 const std::string& str);
 
   // True if this object is currently capturing logs.
   bool is_capturing_logs_;
 
   // The previous handler to restore when the ScopedMockLog is destroyed.
   logging::LogMessageHandlerFunction previous_handler_;
 };

[rvargas (doing something else), 2015/03/03 19:45:34]

DISALLOW_COPY_AND_ASSIGN ?

[Łukasz Anforowicz, 2015/03/04 00:23:01]

Done.

 
-}  // namespace test
-}  // namespace net
+}  // namespace base
 
-#endif  // NET_QUIC_TEST_TOOLS_SCOPED_MOCK_LOG_H_
+#endif  // BASE_TEST_SCOPED_MOCK_LOG_H_