replace NULL->nullptr in src/remoting.

remoting/host/win/elevated_controller.cc

 // Copyright (c) 2012 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/win/elevated_controller.h"
 
 #include "base/file_version_info.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 52 matching lines @@
 // Determines if the client runs in the security context that allows performing
 // administrative tasks (i.e. the user belongs to the adminstrators group and
 // the client runs elevated).
 bool IsClientAdmin() {
   HRESULT hr = CoImpersonateClient();
   if (FAILED(hr)) {
     return false;
   }
 
   SID_IDENTIFIER_AUTHORITY nt_authority = SECURITY_NT_AUTHORITY;
-  PSID administrators_group = NULL;
+  PSID administrators_group = nullptr;
   BOOL result = AllocateAndInitializeSid(&nt_authority,
                                          2,
                                          SECURITY_BUILTIN_DOMAIN_RID,
                                          DOMAIN_ALIAS_RID_ADMINS,
                                          0, 0, 0, 0, 0, 0,
                                          &administrators_group);
   if (result) {
-    if (!CheckTokenMembership(NULL, administrators_group, &result)) {
+    if (!CheckTokenMembership(nullptr, administrators_group, &result)) {
       result = false;
     }
     FreeSid(administrators_group);
   }
 
   hr = CoRevertToSelf();
   CHECK(SUCCEEDED(hr));
 
   return !!result;
 }
 
 // Reads and parses the configuration file up to |kMaxConfigFileSize| in
 // size.
 HRESULT ReadConfig(const base::FilePath& filename,
                    scoped_ptr<base::DictionaryValue>* config_out) {
 
   // Read raw data from the configuration file.
   base::win::ScopedHandle file(
       CreateFileW(filename.value().c_str(),
                   GENERIC_READ,
                   FILE_SHARE_READ | FILE_SHARE_WRITE,
-                  NULL,
+                  nullptr,
                   OPEN_EXISTING,
                   FILE_FLAG_SEQUENTIAL_SCAN,
-                  NULL));
+                  nullptr));
 
   if (!file.IsValid()) {
     DWORD error = GetLastError();
     PLOG(ERROR) << "Failed to open '" << filename.value() << "'";
     return HRESULT_FROM_WIN32(error);
   }
 
   scoped_ptr<char[]> buffer(new char[kMaxConfigFileSize]);
   DWORD size = kMaxConfigFileSize;
-  if (!::ReadFile(file.Get(), &buffer[0], size, &size, NULL)) {
+  if (!::ReadFile(file.Get(), &buffer[0], size, &size, nullptr)) {
     DWORD error = GetLastError();
     PLOG(ERROR) << "Failed to read '" << filename.value() << "'";
     return HRESULT_FROM_WIN32(error);
   }
 
   // Parse the JSON configuration, expecting it to contain a dictionary.
   std::string file_content(buffer.get(), size);
   scoped_ptr<base::Value> value(
       base::JSONReader::Read(file_content, base::JSON_ALLOW_TRAILING_COMMAS));
 
   base::DictionaryValue* dictionary;
-  if (value.get() == NULL || !value->GetAsDictionary(&dictionary)) {
+  if (value.get() == nullptr || !value->GetAsDictionary(&dictionary)) {
     LOG(ERROR) << "Failed to read '" << filename.value() << "'.";
     return E_FAIL;
   }
 
   value.release();
   config_out->reset(dictionary);
   return S_OK;
 }
 
 base::FilePath GetTempLocationFor(const base::FilePath& filename) {
@@ skipping 21 matching lines @@
 
   // Create a temporary file and write configuration to it.
   base::FilePath tempname = GetTempLocationFor(filename);
   base::win::ScopedHandle file(
       CreateFileW(tempname.value().c_str(),
                   GENERIC_WRITE,
                   0,
                   &security_attributes,
                   CREATE_ALWAYS,
                   FILE_FLAG_SEQUENTIAL_SCAN,
-                  NULL));
+                  nullptr));
 
   if (!file.IsValid()) {
     DWORD error = GetLastError();
     PLOG(ERROR) << "Failed to create '" << filename.value() << "'";
     return HRESULT_FROM_WIN32(error);
   }
 
   DWORD written;
   if (!WriteFile(file.Get(), content, static_cast<DWORD>(length), &written,
-                 NULL)) {
+                 nullptr)) {
     DWORD error = GetLastError();
     PLOG(ERROR) << "Failed to write to '" << filename.value() << "'";
     return HRESULT_FROM_WIN32(error);
   }
 
   return S_OK;
 }
 
 // Moves a config file from its temporary location to its permanent location.
 HRESULT MoveConfigFileFromTemp(const base::FilePath& filename) {
@@ skipping 16 matching lines @@
 HRESULT WriteConfig(const char* content, size_t length, HWND owner_window) {
   if (length > kMaxConfigFileSize) {
       return E_FAIL;
   }
 
   // Extract the configuration data that the user will verify.
   scoped_ptr<base::Value> config_value(base::JSONReader::Read(content));
   if (!config_value.get()) {
     return E_FAIL;
   }
-  base::DictionaryValue* config_dict = NULL;
+  base::DictionaryValue* config_dict = nullptr;
   if (!config_value->GetAsDictionary(&config_dict)) {
     return E_FAIL;
   }
   std::string email;
   if (!config_dict->GetString(kHostOwnerEmailConfigPath, &email)) {
     if (!config_dict->GetString(kHostOwnerConfigPath, &email)) {
       if (!config_dict->GetString(kXmppLoginConfigPath, &email)) {
         return E_FAIL;
       }
     }
@@ skipping 59 matching lines @@
   hr = MoveConfigFileFromTemp(unprivileged_config_file_path);
   if (FAILED(hr)) {
     return hr;
   }
 
   return S_OK;
 }
 
 } // namespace
 
-ElevatedController::ElevatedController() : owner_window_(NULL) {
+ElevatedController::ElevatedController() : owner_window_(nullptr) {
 }
 
 HRESULT ElevatedController::FinalConstruct() {
   return S_OK;
 }
 
 void ElevatedController::FinalRelease() {
 }
 
 STDMETHODIMP ElevatedController::GetConfig(BSTR* config_out) {
   base::FilePath config_dir = remoting::GetConfigDir();
 
   // Read the unprivileged part of host configuration.
   scoped_ptr<base::DictionaryValue> config;
   HRESULT hr = ReadConfig(config_dir.Append(kUnprivilegedConfigFileName),
                           &config);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Convert the config back to a string and return it to the caller.
   std::string file_content;
   base::JSONWriter::Write(config.get(), &file_content);
 
   *config_out = ::SysAllocString(base::UTF8ToUTF16(file_content).c_str());
-  if (config_out == NULL) {
+  if (config_out == nullptr) {
     return E_OUTOFMEMORY;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ElevatedController::GetVersion(BSTR* version_out) {
   // Report the product version number of the daemon controller binary as
   // the host version.
   HMODULE binary = base::GetModuleFromAddress(
       reinterpret_cast<void*>(&ReadConfig));
   scoped_ptr<FileVersionInfo> version_info(
       FileVersionInfo::CreateFileVersionInfoForModule(binary));
 
   base::string16 version;
   if (version_info.get()) {
     version = version_info->product_version();
   }
 
   *version_out = ::SysAllocString(version.c_str());
-  if (version_out == NULL) {
+  if (version_out == nullptr) {
     return E_OUTOFMEMORY;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ElevatedController::SetConfig(BSTR config) {
   // Determine the config directory path and create it if necessary.
   base::FilePath config_dir = remoting::GetConfigDir();
   if (!base::CreateDirectory(config_dir)) {
@@ skipping 16 matching lines @@
   HRESULT hr = OpenService(&service);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Change the service start type to 'auto'.
   if (!::ChangeServiceConfigW(service.Get(),
                               SERVICE_NO_CHANGE,
                               SERVICE_AUTO_START,
                               SERVICE_NO_CHANGE,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL)) {
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr)) {
     DWORD error = GetLastError();
     PLOG(ERROR) << "Failed to change the '" << kWindowsServiceName
                 << "'service start type to 'auto'";
     return HRESULT_FROM_WIN32(error);
   }
 
   // Start the service.
-  if (!StartService(service.Get(), 0, NULL)) {
+  if (!StartService(service.Get(), 0, nullptr)) {
     DWORD error = GetLastError();
     if (error != ERROR_SERVICE_ALREADY_RUNNING) {
       PLOG(ERROR) << "Failed to start the '" << kWindowsServiceName
                   << "'service";
 
       return HRESULT_FROM_WIN32(error);
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ElevatedController::StopDaemon() {
   ScopedScHandle service;
   HRESULT hr = OpenService(&service);
   if (FAILED(hr)) {
     return hr;
   }
 
   // Change the service start type to 'manual'.
   if (!::ChangeServiceConfigW(service.Get(),
                               SERVICE_NO_CHANGE,
                               SERVICE_DEMAND_START,
                               SERVICE_NO_CHANGE,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL,
-                              NULL)) {
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr,
+                              nullptr)) {
     DWORD error = GetLastError();
     PLOG(ERROR) << "Failed to change the '" << kWindowsServiceName
                 << "'service start type to 'manual'";
     return HRESULT_FROM_WIN32(error);
   }
 
   // Stop the service.
   SERVICE_STATUS status;
   if (!ControlService(service.Get(), SERVICE_CONTROL_STOP, &status)) {
     DWORD error = GetLastError();
     if (error != ERROR_SERVICE_NOT_ACTIVE) {
       PLOG(ERROR) << "Failed to stop the '" << kWindowsServiceName
                   << "'service";
       return HRESULT_FROM_WIN32(error);
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ElevatedController::UpdateConfig(BSTR config) {
   // Parse the config.
   std::string config_str = base::UTF16ToUTF8(
     base::string16(static_cast<base::char16*>(config), ::SysStringLen(config)));
   scoped_ptr<base::Value> config_value(base::JSONReader::Read(config_str));
   if (!config_value.get()) {
     return E_FAIL;
   }
-  base::DictionaryValue* config_dict = NULL;
+  base::DictionaryValue* config_dict = nullptr;
   if (!config_value->GetAsDictionary(&config_dict)) {
     return E_FAIL;
   }
   // Check for bad keys.
   for (int i = 0; i < arraysize(kReadonlyKeys); ++i) {
     if (config_dict->HasKey(kReadonlyKeys[i])) {
       return HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED);
     }
   }
   // Get the old config.
@@ skipping 30 matching lines @@
     return S_OK;
   } else {
     return E_FAIL;
   }
 }
 
 HRESULT ElevatedController::OpenService(ScopedScHandle* service_out) {
   DWORD error;
 
   ScopedScHandle scmanager(
-      ::OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASE,
+      ::OpenSCManagerW(nullptr, SERVICES_ACTIVE_DATABASE,
                        SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE));
   if (!scmanager.IsValid()) {
     error = GetLastError();
     PLOG(ERROR) << "Failed to connect to the service control manager";
 
     return HRESULT_FROM_WIN32(error);
   }
 
   DWORD desired_access = SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS |
                          SERVICE_START | SERVICE_STOP;
   ScopedScHandle service(
       ::OpenServiceW(scmanager.Get(), kWindowsServiceName, desired_access));
   if (!service.IsValid()) {
     error = GetLastError();
     PLOG(ERROR) << "Failed to open to the '" << kWindowsServiceName
                 << "' service";
 
     return HRESULT_FROM_WIN32(error);
   }
 
   service_out->Set(service.Take());
   return S_OK;
 }
 
 } // namespace remoting