Send enums as strings between Chromoting Native Messaging host and web-app.

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 223 matching lines @@
     scoped_ptr<base::DictionaryValue> 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);
+  switch (state) {
+    case DaemonController::STATE_NOT_IMPLEMENTED:

[Sergey Ulanov, 2013/05/30 23:14:52]

Take a look at "remoting/protocol/name_value_map.h". It would be useful here.
Maybe move it to base and use here.

In either case all consts from DaemonController used only here, so just remove
them and put the values here.

[Lambros, 2013/05/31 01:32:56]

Not worth moving, I'm only using value->name direction, and switch/case gives
compile-time checking.
Done.

+      response->SetString("state", DaemonController::kStateNotImplemented);
+      break;
+    case DaemonController::STATE_NOT_INSTALLED:
+      response->SetString("state", DaemonController::kStateNotInstalled);
+      break;
+    case DaemonController::STATE_INSTALLING:
+      response->SetString("state", DaemonController::kStateInstalling);
+      break;
+    case DaemonController::STATE_STOPPED:
+      response->SetString("state", DaemonController::kStateStopped);
+      break;
+    case DaemonController::STATE_STARTING:
+      response->SetString("state", DaemonController::kStateStarting);
+      break;
+    case DaemonController::STATE_STARTED:
+      response->SetString("state", DaemonController::kStateStarted);
+      break;
+    case DaemonController::STATE_STOPPING:
+      response->SetString("state", DaemonController::kStateStopping);
+      break;
+    case DaemonController::STATE_UNKNOWN:
+      response->SetString("state", DaemonController::kStateUnknown);
+      break;
+  }
   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)));
@@ skipping 18 matching lines @@
     bool set_by_policy) {
   response->SetBoolean("supported", supported);
   response->SetBoolean("allowed", allowed);
   response->SetBoolean("set_by_policy", set_by_policy);
   SendResponse(response.Pass());
 }
 
 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);
+  switch (result) {
+    case DaemonController::RESULT_OK:
+      response->SetString("result", DaemonController::kResultOk);
+      break;
+    case DaemonController::RESULT_FAILED:
+      response->SetString("result", DaemonController::kResultFailed);
+      break;
+    case DaemonController::RESULT_CANCELLED:
+      response->SetString("result", DaemonController::kResultCancelled);
+      break;
+    case DaemonController::RESULT_FAILED_DIRECTORY:
+      response->SetString("result", DaemonController::kResultFailedDirectory);
+      break;
+  }
   SendResponse(response.Pass());
 }
 
 }  // namespace remoting