Fixing a hang in the native messaging hosts on Windows

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 <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 175 matching lines @@
   response->Set("supportedFeatures", supported_features_list.release());
   SendMessageToClient(std::move(response));
 }
 
 void Me2MeNativeMessagingHost::ProcessClearPairedClients(
     std::unique_ptr<base::DictionaryValue> message,
     std::unique_ptr<base::DictionaryValue> response) {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(std::move(message)))
+    if (!DelegateToElevatedHost(std::move(message))) {
       SendBooleanResult(std::move(response), false);
+    }
     return;
   }
 
   if (pairing_registry_.get()) {
     pairing_registry_->ClearAllPairings(
         base::Bind(&Me2MeNativeMessagingHost::SendBooleanResult, weak_ptr_,
                    base::Passed(&response)));
   } else {
     SendBooleanResult(std::move(response), false);
   }
 }
 
 void Me2MeNativeMessagingHost::ProcessDeletePairedClient(
     std::unique_ptr<base::DictionaryValue> message,
     std::unique_ptr<base::DictionaryValue> response) {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(std::move(message)))
+    if (!DelegateToElevatedHost(std::move(message))) {
       SendBooleanResult(std::move(response), false);
+    }
     return;
   }
 
   std::string client_id;
   if (!message->GetString(protocol::PairingRegistry::kClientIdKey,
                           &client_id)) {
     OnError("'" + std::string(protocol::PairingRegistry::kClientIdKey) +
             "' string not found.");
     return;
   }
@@ skipping 49 matching lines @@
   response->SetString("publicKey", key_pair->GetPublicKey());
   SendMessageToClient(std::move(response));
 }
 
 void Me2MeNativeMessagingHost::ProcessUpdateDaemonConfig(
     std::unique_ptr<base::DictionaryValue> message,
     std::unique_ptr<base::DictionaryValue> response) {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(std::move(message)))
+    if (!DelegateToElevatedHost(std::move(message))) {
       SendAsyncResult(std::move(response), DaemonController::RESULT_FAILED);
+    }
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(std::move(message));
   if (!config_dict) {
     OnError("'config' dictionary not found");
     return;
   }
 
@@ skipping 38 matching lines @@
       base::Bind(&Me2MeNativeMessagingHost::SendUsageStatsConsentResponse,
                  weak_ptr_, base::Passed(&response)));
 }
 
 void Me2MeNativeMessagingHost::ProcessStartDaemon(
     std::unique_ptr<base::DictionaryValue> message,
     std::unique_ptr<base::DictionaryValue> response) {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(std::move(message)))
+    if (!DelegateToElevatedHost(std::move(message))) {
       SendAsyncResult(std::move(response), DaemonController::RESULT_FAILED);
+    }
     return;
   }
 
   bool consent;
   if (!message->GetBoolean("consent", &consent)) {
     OnError("'consent' not found.");
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(std::move(message));
   if (!config_dict) {
     OnError("'config' dictionary not found");
     return;
   }
 
   daemon_controller_->SetConfigAndStart(
       std::move(config_dict), consent,
       base::Bind(&Me2MeNativeMessagingHost::SendAsyncResult, weak_ptr_,
                  base::Passed(&response)));
 }
 
 void Me2MeNativeMessagingHost::ProcessStopDaemon(
     std::unique_ptr<base::DictionaryValue> message,
     std::unique_ptr<base::DictionaryValue> response) {
   DCHECK(task_runner()->BelongsToCurrentThread());
 
   if (needs_elevation_) {
-    if (!DelegateToElevatedHost(std::move(message)))
+    if (!DelegateToElevatedHost(std::move(message))) {
       SendAsyncResult(std::move(response), DaemonController::RESULT_FAILED);
+    }
     return;
   }
 
   daemon_controller_->Stop(
       base::Bind(&Me2MeNativeMessagingHost::SendAsyncResult, weak_ptr_,
                  base::Passed(&response)));
 }
 
 void Me2MeNativeMessagingHost::ProcessGetDaemonState(
     std::unique_ptr<base::DictionaryValue> message,
@@ skipping 192 matching lines @@
     return;
 
   base::win::ScopedHandle read_handle;
   base::win::ScopedHandle write_handle;
   // Get the name of the binary to launch.
   base::FilePath binary = base::CommandLine::ForCurrentProcess()->GetProgram();
   ProcessLaunchResult result = LaunchNativeMessagingHostProcess(
       binary, parent_window_handle_,
       /*elevate_process=*/true, &read_handle, &write_handle);
   if (result != PROCESS_LAUNCH_RESULT_SUCCESS) {
-    if (result != PROCESS_LAUNCH_RESULT_CANCELLED) {
-      OnError(std::string());
-    }
     return;
   }
 
   // Set up the native messaging channel to talk to the elevated host.
   // Note that input for the elevated channel is output for the elevated host.
   elevated_channel_.reset(new PipeMessagingChannel(
       base::File(read_handle.Take()), base::File(write_handle.Take())));
 
   elevated_channel_event_handler_.reset(
       new Me2MeNativeMessagingHost::ElevatedChannelEventHandler(client_));
@@ skipping 15 matching lines @@
 
 bool Me2MeNativeMessagingHost::DelegateToElevatedHost(
     std::unique_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting