Run clang-modernize -use-nullptr over src/extensions/.

extensions/browser/api/cast_channel/logger_unittest.cc

 // 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.
 
 #include "base/test/simple_test_tick_clock.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/browser/api/cast_channel/logger_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/zlib.h"
@@ skipping 12 matching lines @@
 class CastChannelLoggerTest : public testing::Test {
  public:
   // |logger_| will take ownership of |clock_|.
   CastChannelLoggerTest()
       : clock_(new base::SimpleTestTickClock),
         logger_(new Logger(scoped_ptr<base::TickClock>(clock_),
                            base::TimeTicks())) {}
   virtual ~CastChannelLoggerTest() {}
 
   bool Uncompress(const char* input, int length, std::string* output) {
-    z_stream stream = {0};
+    z_stream stream = {nullptr};
 
     stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(input));
     stream.avail_in = length;
     stream.next_out = reinterpret_cast<uint8*>(&(*output)[0]);
     stream.avail_out = output->size();
 
     bool success = false;
     while (stream.avail_in > 0 && stream.avail_out > 0) {
       // 16 is added to read in gzip format.
       int result = inflateInit2(&stream, MAX_WBITS + 16);
@@ skipping 67 matching lines @@
   logger_->LogSocketChallengeReplyEvent(2, auth_result);
 
   LastErrors last_errors = logger_->GetLastErrors(2);
   EXPECT_EQ(last_errors.event_type, proto::AUTH_CHALLENGE_REPLY);
   EXPECT_EQ(last_errors.net_return_value, 0);
   EXPECT_EQ(last_errors.challenge_reply_error_type,
             proto::CHALLENGE_REPLY_ERROR_NSS_CERT_PARSING_FAILED);
   EXPECT_EQ(last_errors.nss_error_code, kTestNssErrorCode);
 
   scoped_ptr<Log> log = GetLog();
-  ASSERT_TRUE(log.get() != NULL);
+  ASSERT_TRUE(log.get() != nullptr);
 
   ASSERT_EQ(2, log->aggregated_socket_event_size());
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log->aggregated_socket_event(0);
     EXPECT_EQ(1, aggregated_socket_event.id());
     EXPECT_EQ(3, aggregated_socket_event.socket_event_size());
     {
       const SocketEvent& event = aggregated_socket_event.socket_event(0);
       EXPECT_EQ(EventType::CAST_SOCKET_CREATED, event.type());
@@ skipping 61 matching lines @@
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
   logger_->LogSocketEventWithRv(2, EventType::SOCKET_READ, 100);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEventWithRv(2, EventType::SOCKET_WRITE, 100);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEventWithRv(2, EventType::SOCKET_WRITE, -5);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
   scoped_ptr<Log> log = GetLog();
-  ASSERT_TRUE(log.get() != NULL);
+  ASSERT_TRUE(log.get() != nullptr);
 
   ASSERT_EQ(2, log->aggregated_socket_event_size());
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log->aggregated_socket_event(0);
     EXPECT_EQ(1, aggregated_socket_event.id());
     EXPECT_EQ(4, aggregated_socket_event.socket_event_size());
     EXPECT_EQ(80, aggregated_socket_event.bytes_read());
     EXPECT_EQ(20, aggregated_socket_event.bytes_written());
   }
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log->aggregated_socket_event(1);
     EXPECT_EQ(2, aggregated_socket_event.id());
     EXPECT_EQ(3, aggregated_socket_event.socket_event_size());
     EXPECT_EQ(100, aggregated_socket_event.bytes_read());
     EXPECT_EQ(100, aggregated_socket_event.bytes_written());
   }
 }
 
 TEST_F(CastChannelLoggerTest, TooManySockets) {
   for (int i = 0; i < kMaxSocketsToLog + 5; i++) {
     logger_->LogSocketEvent(i, EventType::CAST_SOCKET_CREATED);
   }
 
   scoped_ptr<Log> log = GetLog();
-  ASSERT_TRUE(log.get() != NULL);
+  ASSERT_TRUE(log.get() != nullptr);
 
   ASSERT_EQ(kMaxSocketsToLog, log->aggregated_socket_event_size());
   EXPECT_EQ(5, log->num_evicted_aggregated_socket_events());
   EXPECT_EQ(5, log->num_evicted_socket_events());
 
   const AggregatedSocketEvent& aggregated_socket_event =
       log->aggregated_socket_event(0);
   EXPECT_EQ(5, aggregated_socket_event.id());
 }
 
 TEST_F(CastChannelLoggerTest, TooManyEvents) {
   for (int i = 0; i < kMaxEventsPerSocket + 5; i++) {
     logger_->LogSocketEvent(1, EventType::CAST_SOCKET_CREATED);
     clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   }
 
   scoped_ptr<Log> log = GetLog();
-  ASSERT_TRUE(log.get() != NULL);
+  ASSERT_TRUE(log.get() != nullptr);
 
   ASSERT_EQ(1, log->aggregated_socket_event_size());
   EXPECT_EQ(0, log->num_evicted_aggregated_socket_events());
   EXPECT_EQ(5, log->num_evicted_socket_events());
 
   const AggregatedSocketEvent& aggregated_socket_event =
       log->aggregated_socket_event(0);
   ASSERT_EQ(kMaxEventsPerSocket, aggregated_socket_event.socket_event_size());
   EXPECT_EQ(5, aggregated_socket_event.socket_event(0).timestamp_micros());
 }
 
 TEST_F(CastChannelLoggerTest, Reset) {
   logger_->LogSocketEvent(1, EventType::CAST_SOCKET_CREATED);
 
   scoped_ptr<Log> log = GetLog();
-  ASSERT_TRUE(log.get() != NULL);
+  ASSERT_TRUE(log.get() != nullptr);
 
   EXPECT_EQ(1, log->aggregated_socket_event_size());
 
   logger_->Reset();
 
   log = GetLog();
-  ASSERT_TRUE(log.get() != NULL);
+  ASSERT_TRUE(log.get() != nullptr);
 
   EXPECT_EQ(0, log->aggregated_socket_event_size());
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions