Made sure NativeMessagingHostTest.All can handle out of order responses.

remoting/host/setup/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/native_messaging_host.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 58 matching lines @@
     base::PlatformFile output,
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     const base::Closure& quit_closure)
     : caller_task_runner_(caller_task_runner),
       quit_closure_(quit_closure),
       native_messaging_reader_(input),
       native_messaging_writer_(output),
       daemon_controller_(daemon_controller.Pass()),
       pairing_registry_(pairing_registry),
       oauth_client_(oauth_client.Pass()),
+      pending_requests_(0),
+      shutdown_(false),
       weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
 }
 
 NativeMessagingHost::~NativeMessagingHost() {}
 
 void NativeMessagingHost::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   native_messaging_reader_.Start(
       base::Bind(&NativeMessagingHost::ProcessMessage, weak_ptr_),
       base::Bind(&NativeMessagingHost::Shutdown, weak_ptr_));
 }
 
 void NativeMessagingHost::Shutdown() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  if (!quit_closure_.is_null()) {
+
+  if (shutdown_)
+    return;
+
+  shutdown_ = true;
+  if (!pending_requests_)
     caller_task_runner_->PostTask(FROM_HERE, quit_closure_);
-    quit_closure_.Reset();
-  }
 }
 
 void NativeMessagingHost::ProcessMessage(scoped_ptr<base::Value> message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Don't process any more messages if Shutdown() has been called.
-  if (quit_closure_.is_null())
+  if (shutdown_)
     return;
 
   const base::DictionaryValue* message_dict;
   if (!message->GetAsDictionary(&message_dict)) {
     LOG(ERROR) << "Expected DictionaryValue";
     Shutdown();
     return;
   }
 
   scoped_ptr<base::DictionaryValue> response_dict(new base::DictionaryValue());
 
   // If the client supplies an ID, it will expect it in the response. This
   // might be a string or a number, so cope with both.
   const base::Value* id;
   if (message_dict->Get("id", &id))
     response_dict->Set("id", id->DeepCopy());
 
   std::string type;
   if (!message_dict->GetString("type", &type)) {
     LOG(ERROR) << "'type' not found";
     Shutdown();
     return;
   }
 
   response_dict->SetString("type", type + "Response");
 
+  DCHECK_GE(pending_requests_, 0);
+  pending_requests_++;
+
   bool success = false;
   if (type == "hello") {
     success = ProcessHello(*message_dict, response_dict.Pass());
   } else if (type == "clearPairedClients") {
     success = ProcessClearPairedClients(*message_dict, response_dict.Pass());
   } else if (type == "deletePairedClient") {
     success = ProcessDeletePairedClient(*message_dict, response_dict.Pass());
   } else if (type == "getHostName") {
     success = ProcessGetHostName(*message_dict, response_dict.Pass());
   } else if (type == "getPinHash") {
@@ skipping 16 matching lines @@
     success = ProcessGetDaemonState(*message_dict, response_dict.Pass());
   } else if (type == "getHostClientId") {
     success = ProcessGetHostClientId(*message_dict, response_dict.Pass());
   } else if (type == "getCredentialsFromAuthCode") {
     success = ProcessGetCredentialsFromAuthCode(
         *message_dict, response_dict.Pass());
   } else {
     LOG(ERROR) << "Unsupported request type: " << type;
   }
 
-  if (!success)
+  if (!success) {
+    pending_requests_--;
+    DCHECK_GE(pending_requests_, 0);
+
     Shutdown();
+  }
 }
 
 bool NativeMessagingHost::ProcessHello(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   response->SetString("version", STRINGIZE(VERSION));
   scoped_ptr<base::ListValue> supported_features_list(new base::ListValue());
   supported_features_list->AppendStrings(std::vector<std::string>(
       kSupportedFeatures, kSupportedFeatures + arraysize(kSupportedFeatures)));
   response->Set("supportedFeatures", supported_features_list.release());
@@ skipping 219 matching lines @@
     scoped_ptr<base::DictionaryValue> response) {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&NativeMessagingHost::SendResponse, weak_ptr_,
                               base::Passed(&response)));
     return;
   }
 
   if (!native_messaging_writer_.WriteMessage(*response))
     Shutdown();
+
+  pending_requests_--;
+  DCHECK_GE(pending_requests_, 0);
+
+  if (shutdown_ && !pending_requests_)
+    caller_task_runner_->PostTask(FROM_HERE, quit_closure_);
 }
 
 void NativeMessagingHost::SendConfigResponse(
     scoped_ptr<base::DictionaryValue> response,
     scoped_ptr<base::DictionaryValue> config) {
   if (config) {
     response->Set("config", config.release());
   } else {
     response->Set("config", Value::CreateNullValue());
   }
@@ skipping 81 matching lines @@
                                      oauth_client.Pass(),
                                      read_file, write_file,
                                      message_loop.message_loop_proxy(),
                                      run_loop.QuitClosure());
   host.Start();
   run_loop.Run();
   return kSuccessExitCode;
 }
 
 }  // namespace remoting