replace NULL->nullptr in src/remoting.

remoting/test/protocol_perftest.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/base64.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 93 matching lines @@
         connecting_loop_->Quit();
     }
   }
   void OnConnectionReady(bool ready) override {}
   void OnRouteChanged(const std::string& channel_name,
                       const protocol::TransportRoute& route) override {}
   void SetCapabilities(const std::string& capabilities) override {}
   void SetPairingResponse(
       const protocol::PairingResponse& pairing_response) override {}
   void DeliverHostMessage(const protocol::ExtensionMessage& message) override {}
-  protocol::ClipboardStub* GetClipboardStub() override { return NULL; }
+  protocol::ClipboardStub* GetClipboardStub() override { return nullptr; }
   protocol::CursorShapeStub* GetCursorShapeStub() override {
     return &cursor_shape_stub_;
   }
 
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override {}
-  ChromotingStats* GetStats() override { return NULL; }
+  ChromotingStats* GetStats() override { return nullptr; }
   void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
                           const base::Closure& done) override {
     if (video_packet->data().empty()) {
       // Ignore keep-alive packets
       done.Run();
       return;
     }
 
     last_video_packet_ = video_packet.Pass();
 
@@ skipping 131 matching lines @@
     base::Base64Encode(key_string, &key_base64);
     scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(key_base64);
     ASSERT_TRUE(key_pair.get());
 
 
     protocol::SharedSecretHash host_secret;
     host_secret.hash_function = protocol::AuthenticationMethod::NONE;
     host_secret.value = "123456";
     scoped_ptr<protocol::AuthenticatorFactory> auth_factory =
         protocol::Me2MeHostAuthenticatorFactory::CreateWithSharedSecret(
-            true, kHostOwner, host_cert, key_pair, host_secret, NULL);
+            true, kHostOwner, host_cert, key_pair, host_secret, nullptr);
     host_->SetAuthenticatorFactory(auth_factory.Pass());
 
     host_->AddStatusObserver(this);
     host_->set_protocol_config(protocol_config_->Clone());
     host_->Start(kHostOwner);
 
     message_loop_.PostTask(FROM_HERE,
                            base::Bind(&ProtocolPerfTest::StartClientAfterHost,
                                       base::Unretained(this)));
   }
@@ skipping 114 matching lines @@
         NetworkPerformanceParams(100000, 200000, 130, 5, 0.01)));
 
 TEST_P(ProtocolPerfTest, StreamFrameRate) {
   StartHostAndClient(protocol::ChannelConfig::CODEC_VP8);
   ASSERT_NO_FATAL_FAILURE(WaitConnected());
 
   base::TimeDelta latency;
 
   ReceiveFrame(&latency);
   LOG(INFO) << "First frame latency: " << latency.InMillisecondsF() << "ms";
-  ReceiveFrames(20, NULL);
+  ReceiveFrames(20, nullptr);
 
   base::TimeTicks started = base::TimeTicks::Now();
   ReceiveFrames(40, &latency);
   base::TimeDelta elapsed = base::TimeTicks::Now() - started;
   LOG(INFO) << "Frame rate: " << (40.0 / elapsed.InSecondsF());
   LOG(INFO) << "Maximum latency: " << latency.InMillisecondsF() << "ms";
 }
 
 const int kIntermittentFrameSize = 100 * 1000;
 
@@ skipping 39 matching lines @@
 };
 
 TEST_P(ProtocolPerfTest, IntermittentChanges) {
   desktop_environment_factory_.set_frame_generator(
       base::Bind(&IntermittentChangeFrameGenerator::GenerateFrame,
                  new IntermittentChangeFrameGenerator()));
 
   StartHostAndClient(protocol::ChannelConfig::CODEC_VERBATIM);
   ASSERT_NO_FATAL_FAILURE(WaitConnected());
 
-  ReceiveFrame(NULL);
+  ReceiveFrame(nullptr);
 
   base::TimeDelta expected = GetParam().latency_average;
   if (GetParam().bandwidth > 0) {
     expected += base::TimeDelta::FromSecondsD(kIntermittentFrameSize /
                                               GetParam().bandwidth);
   }
   LOG(INFO) << "Expected: " << expected.InMillisecondsF() << "ms";
 
   base::TimeDelta sum;
 
   const int kFrames = 5;
   for (int i = 0; i < kFrames; ++i) {
     base::TimeDelta latency;
     ReceiveFrame(&latency);
     LOG(INFO) << "Latency: " << latency.InMillisecondsF()
               << "ms Encode: " << last_video_packet_->encode_time_ms()
               << "ms Capture: " << last_video_packet_->capture_time_ms()
               << "ms";
     sum += latency;
   }
 
   LOG(INFO) << "Average: " << (sum / kFrames).InMillisecondsF();
 }
 
 }  // namespace remoting