unittests for Chromoting native messaging host.

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/bind.h"
 #include "base/callback.h"
@@ skipping 43 matching lines @@
     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_(DaemonController::Create()),
       weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
 }
 
-NativeMessagingHost::~NativeMessagingHost() {
-}
+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()) {
     caller_task_runner_->PostTask(FROM_HERE, quit_closure_);
     quit_closure_.Reset();
   }
 }
 
+void NativeMessagingHost::SetDaemonControllerForTest(
+    scoped_ptr<DaemonController> daemon_controller) {
+  daemon_controller_ = daemon_controller.Pass();
+}
+
 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())
+    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());
 
@@ skipping 92 matching lines @@
   daemon_controller_->UpdateConfig(
       config_dict.Pass(),
       base::Bind(&NativeMessagingHost::SendAsyncResult, base::Unretained(this),
                  base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetDaemonConfig(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
-  daemon_controller_->GetConfig(base::Bind(
-      &NativeMessagingHost::SendConfigResponse,
-      base::Unretained(this), base::Passed(&response)));
+  daemon_controller_->GetConfig(
+      base::Bind(&NativeMessagingHost::SendConfigResponse,
+                 base::Unretained(this), base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetUsageStatsConsent(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
-  daemon_controller_->GetUsageStatsConsent(base::Bind(
-      &NativeMessagingHost::SendUsageStatsConsentResponse,
-      base::Unretained(this), base::Passed(&response)));
+  daemon_controller_->GetUsageStatsConsent(
+      base::Bind(&NativeMessagingHost::SendUsageStatsConsentResponse,
+                 base::Unretained(this), base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessStartDaemon(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   bool consent;
   if (!message.GetBoolean("consent", &consent)) {
     LOG(ERROR) << "'consent' not found.";
     return false;
   }
 
   scoped_ptr<base::DictionaryValue> config_dict =
       ConfigDictionaryFromMessage(message);
   if (!config_dict)
     return false;
 
   daemon_controller_->SetConfigAndStart(
       config_dict.Pass(), consent,
       base::Bind(&NativeMessagingHost::SendAsyncResult, base::Unretained(this),
                  base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessStopDaemon(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
-  daemon_controller_->Stop(base::Bind(
-      &NativeMessagingHost::SendAsyncResult, base::Unretained(this),
-      base::Passed(&response)));
+  daemon_controller_->Stop(
+      base::Bind(&NativeMessagingHost::SendAsyncResult, base::Unretained(this),
+                 base::Passed(&response)));
   return true;
 }
 
 bool NativeMessagingHost::ProcessGetDaemonState(
     const base::DictionaryValue& message,
     scoped_ptr<base::DictionaryValue> response) {
   // TODO(lambroslambrou): Send the state as a string instead of an integer,
   // and update the web-app accordingly.
   DaemonController::State state = daemon_controller_->GetState();
   response->SetInteger("state", state);
   SendResponse(response.Pass());
   return true;
 }
 
 void NativeMessagingHost::SendResponse(
     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)));
+    caller_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&NativeMessagingHost::SendResponse, weak_ptr_,
+                              base::Passed(&response)));
     return;
   }
 
   if (!native_messaging_writer_.WriteMessage(*response))
     Shutdown();
 }
 
 void NativeMessagingHost::SendConfigResponse(
     scoped_ptr<base::DictionaryValue> response,
     scoped_ptr<base::DictionaryValue> config) {
@@ skipping 20 matching lines @@
 void NativeMessagingHost::SendAsyncResult(
     scoped_ptr<base::DictionaryValue> response,
     DaemonController::AsyncResult result) {
   // TODO(lambroslambrou): Send the result as a string instead of an integer,
   // and update the web-app accordingly. See http://crbug.com/232135.
   response->SetInteger("result", result);
   SendResponse(response.Pass());
 }
 
 }  // namespace remoting