Removed LOG_GETLASTERROR and LOG_ERRNO macros.

remoting/host/win/host_service.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.
 //
 // This file implements the Windows service controlling Me2Me host processes
 // running within user sessions.
 
 #include "remoting/host/win/host_service.h"
 
 #include <sddl.h>
@@ skipping 206 matching lines @@
       base::Bind(&HostService::StopDaemonProcess, weak_ptr_));
 }
 
 int HostService::RunAsService() {
   SERVICE_TABLE_ENTRYW dispatch_table[] = {
     { const_cast<LPWSTR>(kWindowsServiceName), &HostService::ServiceMain },
     { NULL, NULL }
   };
 
   if (!StartServiceCtrlDispatcherW(dispatch_table)) {
-    LOG_GETLASTERROR(ERROR)
-        << "Failed to connect to the service control manager";
+    PLOG(ERROR) << "Failed to connect to the service control manager";
     return kInitializationFailed;
   }
 
   // Wait until the service thread completely exited to avoid concurrent
   // teardown of objects registered with base::AtExitManager and object
   // destoyed by the service thread.
   stopped_event_.Wait();
 
   return kSuccessExitCode;
 }
 
 void HostService::RunAsServiceImpl() {
   base::MessageLoopForUI message_loop;
   base::RunLoop run_loop;
   main_task_runner_ = message_loop.message_loop_proxy();
   weak_ptr_ = weak_factory_.GetWeakPtr();
 
   // Register the service control handler.
   service_status_handle_ = RegisterServiceCtrlHandlerExW(
       kWindowsServiceName, &HostService::ServiceControlHandler, this);
   if (service_status_handle_ == 0) {
-    LOG_GETLASTERROR(ERROR)
-        << "Failed to register the service control handler";
+    PLOG(ERROR) << "Failed to register the service control handler";
     return;
   }
 
   // Report running status of the service.
   SERVICE_STATUS service_status;
   ZeroMemory(&service_status, sizeof(service_status));
   service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
   service_status.dwCurrentState = SERVICE_RUNNING;
   service_status.dwControlsAccepted = SERVICE_ACCEPT_SHUTDOWN |
                                       SERVICE_ACCEPT_STOP |
                                       SERVICE_ACCEPT_SESSIONCHANGE;
   service_status.dwWin32ExitCode = kSuccessExitCode;
   if (!SetServiceStatus(service_status_handle_, &service_status)) {
-    LOG_GETLASTERROR(ERROR)
+    PLOG(ERROR)
         << "Failed to report service status to the service control manager";
     return;
   }
 
   // Initialize COM.
   base::win::ScopedCOMInitializer com_initializer;
   if (!com_initializer.succeeded())
     return;
 
   if (!InitializeComSecurity(base::WideToUTF8(kComProcessSd),
                              base::WideToUTF8(kComProcessMandatoryLabel),
                              false)) {
     return;
   }
 
   CreateLauncher(scoped_refptr<AutoThreadTaskRunner>(
       new AutoThreadTaskRunner(main_task_runner_,
                                run_loop.QuitClosure())));
 
   // Run the service.
   run_loop.Run();
   weak_factory_.InvalidateWeakPtrs();
 
   // Tell SCM that the service is stopped.
   service_status.dwCurrentState = SERVICE_STOPPED;
   service_status.dwControlsAccepted = 0;
   if (!SetServiceStatus(service_status_handle_, &service_status)) {
-    LOG_GETLASTERROR(ERROR)
+    PLOG(ERROR)
         << "Failed to report service status to the service control manager";
     return;
   }
 }
 
 int HostService::RunInConsole() {
   base::MessageLoopForUI message_loop;
   base::RunLoop run_loop;
   main_task_runner_ = message_loop.message_loop_proxy();
   weak_ptr_ = weak_factory_.GetWeakPtr();
 
   int result = kInitializationFailed;
 
   // Initialize COM.
   base::win::ScopedCOMInitializer com_initializer;
   if (!com_initializer.succeeded())
     return result;
 
   if (!InitializeComSecurity(base::WideToUTF8(kComProcessSd),
                              base::WideToUTF8(kComProcessMandatoryLabel),
                              false)) {
     return result;
   }
 
   // Subscribe to Ctrl-C and other console events.
   if (!SetConsoleCtrlHandler(&HostService::ConsoleControlHandler, TRUE)) {
-    LOG_GETLASTERROR(ERROR)
-        << "Failed to set console control handler";
+    PLOG(ERROR) << "Failed to set console control handler";
     return result;
   }
 
   // Create a window for receiving session change notifications.
   base::win::MessageWindow window;
   if (!window.Create(base::Bind(&HostService::HandleMessage,
                                 base::Unretained(this)))) {
-    LOG_GETLASTERROR(ERROR)
-        << "Failed to create the session notification window";
+    PLOG(ERROR) << "Failed to create the session notification window";
     goto cleanup;
   }
 
   // Subscribe to session change notifications.
   if (WTSRegisterSessionNotification(window.hwnd(),
                                      NOTIFY_FOR_ALL_SESSIONS) != FALSE) {
     CreateLauncher(scoped_refptr<AutoThreadTaskRunner>(
         new AutoThreadTaskRunner(main_task_runner_,
                                  run_loop.QuitClosure())));
 
@@ skipping 97 matching lines @@
 int DaemonProcessMain() {
   HostService* service = HostService::GetInstance();
   if (!service->InitWithCommandLine(CommandLine::ForCurrentProcess())) {
     return kUsageExitCode;
   }
 
   return service->Run();
 }
 
 } // namespace remoting