Removed LOG_GETLASTERROR and LOG_ERRNO macros.

remoting/host/setup/me2me_native_messaging_host.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/me2me_native_messaging_host.h"
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 523 matching lines @@
     return;
   }
 
   // Create a security descriptor that gives full access to the caller and
   // denies access by anyone else.
   std::string security_descriptor = base::StringPrintf(
       "O:%1$sG:%1$sD:(A;;GA;;;%1$s)", base::UTF16ToASCII(user_sid).c_str());
 
   ScopedSd sd = ConvertSddlToSd(security_descriptor);
   if (!sd) {
-    LOG_GETLASTERROR(ERROR) << "Failed to create a security descriptor for the"
-                            << "Chromoting Me2Me native messaging host.";
+    PLOG(ERROR) << "Failed to create a security descriptor for the"
+                << "Chromoting Me2Me native messaging host.";
     OnError();
     return;
   }
 
   SECURITY_ATTRIBUTES security_attributes = {0};
   security_attributes.nLength = sizeof(security_attributes);
   security_attributes.lpSecurityDescriptor = sd.get();
   security_attributes.bInheritHandle = FALSE;
 
   // Generate a unique name for the input channel.
   std::string input_pipe_name(kChromePipeNamePrefix);
   input_pipe_name.append(IPC::Channel::GenerateUniqueRandomChannelID());
 
   base::win::ScopedHandle delegate_write_handle(::CreateNamedPipe(
       base::ASCIIToUTF16(input_pipe_name).c_str(),
       PIPE_ACCESS_OUTBOUND,
       PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_REJECT_REMOTE_CLIENTS,
       1,
       kBufferSize,
       kBufferSize,
       kTimeOutMilliseconds,
       &security_attributes));
 
   if (!delegate_write_handle.IsValid()) {
-    LOG_GETLASTERROR(ERROR) <<
-        "Failed to create named pipe '" << input_pipe_name << "'";
+    PLOG(ERROR) << "Failed to create named pipe '" << input_pipe_name << "'";
     OnError();
     return;
   }
 
   // Generate a unique name for the input channel.
   std::string output_pipe_name(kChromePipeNamePrefix);
   output_pipe_name.append(IPC::Channel::GenerateUniqueRandomChannelID());
 
   base::win::ScopedHandle delegate_read_handle(::CreateNamedPipe(
       base::ASCIIToUTF16(output_pipe_name).c_str(),
       PIPE_ACCESS_INBOUND,
       PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_REJECT_REMOTE_CLIENTS,
       1,
       kBufferSize,
       kBufferSize,
       kTimeOutMilliseconds,
       &security_attributes));
 
   if (!delegate_read_handle.IsValid()) {
-    LOG_GETLASTERROR(ERROR) <<
-        "Failed to create named pipe '" << output_pipe_name << "'";
+    PLOG(ERROR) << "Failed to create named pipe '" << output_pipe_name << "'";
     OnError();
     return;
   }
 
   const CommandLine* current_command_line = CommandLine::ForCurrentProcess();
   const CommandLine::SwitchMap& switches = current_command_line->GetSwitches();
   CommandLine::StringVector args = current_command_line->GetArgs();
 
   // Create the child process command line by copying switches from the current
   // command line.
@@ skipping 21 matching lines @@
   memset(&info, 0, sizeof(info));
   info.cbSize = sizeof(info);
   info.hwnd = reinterpret_cast<HWND>(parent_window_handle_);
   info.lpVerb = L"runas";
   info.lpFile = binary.value().c_str();
   info.lpParameters = parameters.c_str();
   info.nShow = SW_HIDE;
 
   if (!ShellExecuteEx(&info)) {
     DWORD error = ::GetLastError();
-    LOG_GETLASTERROR(ERROR) << "Unable to launch '" << binary.value() << "'";
+    PLOG(ERROR) << "Unable to launch '" << binary.value() << "'";
     if (error != ERROR_CANCELLED) {
       OnError();
     }
     return;
   }
 
   if (!::ConnectNamedPipe(delegate_write_handle.Get(), NULL)) {
     DWORD error = ::GetLastError();
     if (error != ERROR_PIPE_CONNECTED) {
-      LOG_GETLASTERROR(ERROR) << "Unable to connect '"
-                              << input_pipe_name << "'";
+      PLOG(ERROR) << "Unable to connect '" << input_pipe_name << "'";
       OnError();
       return;
     }
   }
 
   if (!::ConnectNamedPipe(delegate_read_handle.Get(), NULL)) {
     DWORD error = ::GetLastError();
     if (error != ERROR_PIPE_CONNECTED) {
-      LOG_GETLASTERROR(ERROR) << "Unable to connect '"
-                              << output_pipe_name << "'";
+      PLOG(ERROR) << "Unable to connect '" << output_pipe_name << "'";
       OnError();
       return;
     }
   }
 
   // Set up the native messaging channel to talk to the elevated host.
   // Note that input for the elevate channel is output forthe elevated host.
   elevated_channel_.reset(new NativeMessagingChannel(
       base::File(delegate_read_handle.Take()),
       base::File(delegate_write_handle.Take())));
@@ skipping 26 matching lines @@
 
 bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
     scoped_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting