replace NULL->nullptr in src/remoting.

remoting/host/setup/daemon_controller_delegate_win.cc

 // Copyright 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 "remoting/host/setup/daemon_controller_delegate_win.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 72 matching lines @@
 
   default:
     NOTREACHED();
     return DaemonController::STATE_UNKNOWN;
   }
 }
 
 DWORD OpenService(ScopedScHandle* service_out) {
   // Open the service and query its current state.
   ScopedScHandle scmanager(
-      ::OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASE,
+      ::OpenSCManagerW(nullptr, SERVICES_ACTIVE_DATABASE,
                        SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
   if (!scmanager.IsValid()) {
     DWORD error = GetLastError();
     PLOG(ERROR) << "Failed to connect to the service control manager";
     return error;
   }
 
   ScopedScHandle service(::OpenServiceW(scmanager.Get(), kWindowsServiceName,
                                         SERVICE_QUERY_STATUS));
   if (!service.IsValid()) {
@@ skipping 24 matching lines @@
 
 void InvokeCompletionCallback(
     const DaemonController::CompletionCallback& done, HRESULT hr) {
   done.Run(HResultToAsyncResult(hr));
 }
 
 }  // namespace
 
 DaemonControllerDelegateWin::DaemonControllerDelegateWin()
     : control_is_elevated_(false),
-      window_handle_(NULL) {
+      window_handle_(nullptr) {
 }
 
 DaemonControllerDelegateWin::~DaemonControllerDelegateWin() {
 }
 
 DaemonController::State DaemonControllerDelegateWin::GetState() {
   if (base::win::GetVersion() < base::win::VERSION_XP) {
     return DaemonController::STATE_NOT_IMPLEMENTED;
   }
   // TODO(alexeypa): Make the thread alertable, so we can switch to APC
@@ skipping 86 matching lines @@
 void DaemonControllerDelegateWin::UpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const DaemonController::CompletionCallback& done) {
   HRESULT hr = ActivateElevatedController();
   if (FAILED(hr)) {
     InvokeCompletionCallback(done, hr);
     return;
   }
 
   // Update the configuration.
-  ScopedBstr config_str(NULL);
+  ScopedBstr config_str(nullptr);
   ConfigToString(*config, &config_str);
-  if (config_str == NULL) {
+  if (config_str == nullptr) {
     InvokeCompletionCallback(done, E_OUTOFMEMORY);
     return;
   }
 
   // Make sure that the PIN confirmation dialog is focused properly.
   hr = control_->SetOwnerWindow(
       reinterpret_cast<LONG_PTR>(GetTopLevelWindow(window_handle_)));
   if (FAILED(hr)) {
     InvokeCompletionCallback(done, hr);
     return;
@@ skipping 40 matching lines @@
   consent.set_by_policy = false;
 
   // Activate the Daemon Controller and see if it supports |IDaemonControl2|.
   HRESULT hr = ActivateController();
   if (FAILED(hr)) {
     // The host is not installed yet. Assume that the user didn't consent to
     // collecting crash dumps.
     return consent;
   }
 
-  if (control2_.get() == NULL) {
+  if (control2_.get() == nullptr) {
     // The host is installed and does not support crash dump reporting.
     return consent;
   }
 
   // Get the recorded user's consent.
   BOOL allowed;
   BOOL set_by_policy;
   hr = control2_->GetUsageStatsConsent(&allowed, &set_by_policy);
   if (FAILED(hr)) {
     // If the user's consent is not recorded yet, assume that the user didn't
     // consent to collecting crash dumps.
     return consent;
   }
 
   consent.allowed = !!allowed;
   consent.set_by_policy = !!set_by_policy;
   return consent;
 }
 
 HRESULT DaemonControllerDelegateWin::ActivateController() {
   if (!control_.get()) {
     CLSID class_id;
     HRESULT hr = CLSIDFromProgID(kDaemonController, &class_id);
     if (FAILED(hr)) {
       return hr;
     }
 
-    hr = CoCreateInstance(class_id, NULL, CLSCTX_LOCAL_SERVER,
+    hr = CoCreateInstance(class_id, nullptr, CLSCTX_LOCAL_SERVER,
                           IID_IDaemonControl, control_.ReceiveVoid());
     if (FAILED(hr)) {
       return hr;
     }
 
     // Ignore the error. IID_IDaemonControl2 is optional.
     control_.QueryInterface(IID_IDaemonControl2, control2_.ReceiveVoid());
 
     // Release |control_| upon expiration of the timeout.
     release_timer_.reset(new base::OneShotTimer<DaemonControllerDelegateWin>());
@@ skipping 78 matching lines @@
   // Record the user's consent.
   if (control2_.get()) {
     hr = control2_->SetUsageStatsConsent(consent);
     if (FAILED(hr)) {
       InvokeCompletionCallback(done, hr);
       return;
     }
   }
 
   // Set the configuration.
-  ScopedBstr config_str(NULL);
+  ScopedBstr config_str(nullptr);
   ConfigToString(*config, &config_str);
-  if (config_str == NULL) {
+  if (config_str == nullptr) {
     InvokeCompletionCallback(done, E_OUTOFMEMORY);
     return;
   }
 
   hr = control_->SetOwnerWindow(
       reinterpret_cast<LONG_PTR>(GetTopLevelWindow(window_handle_)));
   if (FAILED(hr)) {
     InvokeCompletionCallback(done, hr);
     return;
   }
 
   hr = control_->SetConfig(config_str);
   if (FAILED(hr)) {
     InvokeCompletionCallback(done, hr);
     return;
   }
 
   // Start daemon.
   hr = control_->StartDaemon();
   InvokeCompletionCallback(done, hr);
 }
 
 scoped_refptr<DaemonController> DaemonController::Create() {
   scoped_ptr<DaemonController::Delegate> delegate(
       new DaemonControllerDelegateWin());
   return new DaemonController(delegate.Pass());
 }
 
 }  // namespace remoting