Removed LOG_GETLASTERROR and LOG_ERRNO macros.

remoting/host/win/wts_session_process_delegate.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/wts_session_process_delegate.h"
 
 #include "base/bind.h"
@@ skipping 158 matching lines @@
     CHECK(kernel32 != NULL);
 
     get_named_pipe_client_pid_ =
         reinterpret_cast<GetNamedPipeClientProcessIdFn>(
             GetProcAddress(kernel32, "GetNamedPipeClientProcessId"));
     CHECK(get_named_pipe_client_pid_ != NULL);
 
     ScopedHandle job;
     job.Set(CreateJobObject(NULL, NULL));
     if (!job.IsValid()) {
-      LOG_GETLASTERROR(ERROR) << "Failed to create a job object";
+      PLOG(ERROR) << "Failed to create a job object";
       return false;
     }
 
     // Limit the number of active processes in the job to two (the helper
     // process performing elevation and the worker process itself) and make sure
     // that all processes will be killed once the job object is destroyed.
     JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
     memset(&info, 0, sizeof(info));
     info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_ACTIVE_PROCESS |
         JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
     info.BasicLimitInformation.ActiveProcessLimit = 2;
     if (!SetInformationJobObject(job,
                                  JobObjectExtendedLimitInformation,
                                  &info,
                                  sizeof(info))) {
-      LOG_GETLASTERROR(ERROR) << "Failed to set limits on the job object";
+      PLOG(ERROR) << "Failed to set limits on the job object";
       return false;
     }
 
     // ScopedHandle is not compatible with base::Passed, so we wrap it to
     // a scoped pointer.
     scoped_ptr<ScopedHandle> job_wrapper(new ScopedHandle());
     *job_wrapper = job.Pass();
 
     // To receive job object notifications the job object is registered with
     // the completion port represented by |io_task_runner|. The registration has
@@ skipping 94 matching lines @@
 
 void WtsSessionProcessDelegate::Core::OnChannelConnected(int32 peer_pid) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Report the worker PID now if the worker process is launched indirectly.
   // Note that in this case the pipe's security descriptor is the only
   // protection against a malicious processed connecting to the pipe.
   if (launch_elevated_) {
     DWORD pid;
     if (!get_named_pipe_client_pid_(pipe_, &pid)) {
-      LOG_GETLASTERROR(ERROR) << "Failed to retrive PID of the client";
+      PLOG(ERROR) << "Failed to retrive PID of the client";
       ReportFatalError();
       return;
     }
 
     if (pid != static_cast<DWORD>(peer_pid)) {
       LOG(ERROR) << "The actual client PID " << pid
                  << " does not match the one reported by the client: "
                  << peer_pid;
       ReportFatalError();
       return;
     }
 
     DWORD desired_access =
         SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
     ScopedHandle worker_process(OpenProcess(desired_access, false, pid));
     if (!worker_process.IsValid()) {
-      LOG_GETLASTERROR(ERROR) << "Failed to open process " << pid;
+      PLOG(ERROR) << "Failed to open process " << pid;
       ReportFatalError();
       return;
     }
 
     ReportProcessLaunched(worker_process.Pass());
   }
 
   if (event_handler_)
     event_handler_->OnChannelConnected(peer_pid);
 }
@@ skipping 63 matching lines @@
                               CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB,
                               base::UTF8ToUTF16(kDefaultDesktopName).c_str(),
                               &worker_process,
                               &worker_thread)) {
     ReportFatalError();
     return;
   }
 
   if (launch_elevated_) {
     if (!AssignProcessToJobObject(job_, worker_process)) {
-      LOG_GETLASTERROR(ERROR)
-          << "Failed to assign the worker to the job object";
+      PLOG(ERROR) << "Failed to assign the worker to the job object";
       ReportFatalError();
       return;
     }
   }
 
   if (!ResumeThread(worker_thread)) {
-    LOG_GETLASTERROR(ERROR) << "Failed to resume the worker thread";
+    PLOG(ERROR) << "Failed to resume the worker thread";
     ReportFatalError();
     return;
   }
 
   channel_ = channel.Pass();
   pipe_ = pipe.Pass();
 
   // Report success if the worker process is lauched directly. Otherwise, PID of
   // the client connected to the pipe will be used later. See
   // OnChannelConnected().
@@ skipping 23 matching lines @@
         &Core::DrainJobNotifications, this));
   }
 }
 
 void WtsSessionProcessDelegate::Core::InitializeJob(
     scoped_ptr<base::win::ScopedHandle> job) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // Register to receive job notifications via the I/O thread's completion port.
   if (!base::MessageLoopForIO::current()->RegisterJobObject(job->Get(), this)) {
-    LOG_GETLASTERROR(ERROR)
-        << "Failed to associate the job object with a completion port";
+    PLOG(ERROR) << "Failed to associate the job object with a completion port";
     return;
   }
 
   // Let the main thread know that initialization is complete.
   caller_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Core::InitializeJobCompleted, this, base::Passed(&job)));
 }
 
 void WtsSessionProcessDelegate::Core::InitializeJobCompleted(
     scoped_ptr<ScopedHandle> job) {
@@ skipping 39 matching lines @@
   DWORD desired_access =
       SYNCHRONIZE | PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
   HANDLE temp_handle;
   if (!DuplicateHandle(GetCurrentProcess(),
                        worker_process_,
                        GetCurrentProcess(),
                        &temp_handle,
                        desired_access,
                        FALSE,
                        0)) {
-    LOG_GETLASTERROR(ERROR) << "Failed to duplicate a handle";
+    PLOG(ERROR) << "Failed to duplicate a handle";
     ReportFatalError();
     return;
   }
   ScopedHandle limited_handle(temp_handle);
 
   event_handler_->OnProcessLaunched(limited_handle.Pass());
 }
 
 WtsSessionProcessDelegate::WtsSessionProcessDelegate(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
@@ skipping 25 matching lines @@
 
 void WtsSessionProcessDelegate::CloseChannel() {
   core_->CloseChannel();
 }
 
 void WtsSessionProcessDelegate::KillProcess() {
   core_->KillProcess();
 }
 
 } // namespace remoting