Fixing a few crashes in the me2me native messaging host.

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 156 matching lines @@
   response->Set("supportedFeatures", supported_features_list.release());
   channel_->SendMessage(response.Pass());
 }
 
 void Me2MeNativeMessagingHost::ProcessClearPairedClients(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (needs_elevation_) {
-    DelegateToElevatedHost(message.Pass(), response.Pass());
+    if (!DelegateToElevatedHost(message.Pass()))
+      SendBooleanResult(response.Pass(), false);
     return;
   }
 
   if (pairing_registry_) {
     pairing_registry_->ClearAllPairings(
         base::Bind(&Me2MeNativeMessagingHost::SendBooleanResult, weak_ptr_,
                    base::Passed(&response)));
   } else {
     SendBooleanResult(response.Pass(), false);
   }
 }
 
 void Me2MeNativeMessagingHost::ProcessDeletePairedClient(
     scoped_ptr<base::DictionaryValue> message,
     scoped_ptr<base::DictionaryValue> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (needs_elevation_) {
-    DelegateToElevatedHost(message.Pass(), response.Pass());
+    if (!DelegateToElevatedHost(message.Pass()))
+      SendBooleanResult(response.Pass(), false);
     return;
   }
 
   std::string client_id;
   if (!message->GetString(protocol::PairingRegistry::kClientIdKey,
                           &client_id)) {
     LOG(ERROR) << "'" << protocol::PairingRegistry::kClientIdKey
                << "' string not found.";
     OnError();
     return;
@@ skipping 287 matching lines @@
 
 void Me2MeNativeMessagingHost::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!quit_closure_.is_null())
     base::ResetAndReturn(&quit_closure_).Run();
 }
 
 #if defined(OS_WIN)
 
-void Me2MeNativeMessagingHost::DelegateToElevatedHost(
-    scoped_ptr<base::DictionaryValue> message,
-    scoped_ptr<base::DictionaryValue> response) {
+bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
+    scoped_ptr<base::DictionaryValue> message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   EnsureElevatedHostCreated();
 
-  DCHECK(elevated_channel_);
-  elevated_channel_->SendMessage(message.Pass());
+  // elevated_channel_ will be null if user rejects the UAC request.
+  if (elevated_channel_)
+    elevated_channel_->SendMessage(message.Pass());
+
+  return elevated_channel_ != NULL;
 }
 
 void Me2MeNativeMessagingHost::EnsureElevatedHostCreated() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(needs_elevation_);
 
   if (elevated_channel_)
     return;
 
   // presubmit: allow wstring
@@ skipping 19 matching lines @@
 
   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());
 
-  delegate_write_handle_.Set(CreateNamedPipe(
+  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()) {
+  if (!delegate_write_handle.IsValid()) {
     LOG_GETLASTERROR(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());
 
-  delegate_read_handle_.Set(CreateNamedPipe(
+  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()) {
+  if (!delegate_read_handle.IsValid()) {
     LOG_GETLASTERROR(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();
 
@@ skipping 21 matching lines @@
   // Launch the child process requesting elevation.
   SHELLEXECUTEINFO info;
   memset(&info, 0, sizeof(info));
   info.cbSize = sizeof(info);
   info.lpVerb = L"runas";
   info.lpFile = binary.value().c_str();
   info.lpParameters = parameters.c_str();
   info.nShow = SW_SHOWNORMAL;
 
   if (!ShellExecuteEx(&info)) {
+    DWORD error = ::GetLastError();
     LOG_GETLASTERROR(ERROR) << "Unable to launch '" << binary.value() << "'";
-    OnError();
+    if (error != ERROR_CANCELLED) {
+      OnError();
+    }
     return;
   }
 
-  if (!ConnectNamedPipe(delegate_write_handle_.Get(), NULL)) {
+  if (!::ConnectNamedPipe(delegate_write_handle.Get(), NULL)) {
     DWORD error = ::GetLastError();
     if (error != ERROR_PIPE_CONNECTED) {
-      LOG(ERROR) << "Unable to connect '" << input_pipe_name << "': " << error;
+      LOG_GETLASTERROR(ERROR) << "Unable to connect '"
+                              << input_pipe_name << "'";
       OnError();
-    return;
+      return;
     }
   }
 
-  if (!ConnectNamedPipe(delegate_read_handle_.Get(), NULL)) {
+  if (!::ConnectNamedPipe(delegate_read_handle.Get(), NULL)) {
     DWORD error = ::GetLastError();
     if (error != ERROR_PIPE_CONNECTED) {
-      LOG(ERROR) << "Unable to connect '" << output_pipe_name << "': " << error;
+      LOG_GETLASTERROR(ERROR) << "Unable to connect '"
+                              << output_pipe_name << "'";
       OnError();
-    return;
+      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(
-      delegate_read_handle_.Get(), delegate_write_handle_.Get()));
+      delegate_read_handle.Take(), delegate_write_handle.Take()));
 
   elevated_channel_->Start(
       base::Bind(&Me2MeNativeMessagingHost::ProcessDelegateResponse, weak_ptr_),
       base::Bind(&Me2MeNativeMessagingHost::Stop, weak_ptr_));
 }
 
 void Me2MeNativeMessagingHost::ProcessDelegateResponse(
     scoped_ptr<base::DictionaryValue> message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Simply pass along the response from the elevated host to the client.
   channel_->SendMessage(message.Pass());
 }
 
 #else  // defined(OS_WIN)
 
-void Me2MeNativeMessagingHost::DelegateToElevatedHost(
-    scoped_ptr<base::DictionaryValue> message,
-    scoped_ptr<base::DictionaryValue> response) {
+bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
+    scoped_ptr<base::DictionaryValue> message) {
   NOTREACHED();
+  return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting